Implement a Conditional Union Type in TypeScript

TypeScript's powerful type system allows for intricate and flexible type definitions. This challenge focuses on implementing a conditional union type that dynamically selects a type based on a generic parameter. This is a common pattern for creating reusable and type-safe utility types.

Problem Description

Your task is to create a TypeScript generic type, let's call it ConditionalUnion, that accepts two generic parameters:

1. T: The base type from which to derive the union.
2. U: A type that will be used to conditionally determine which part of T to select.

The ConditionalUnion type should behave as follows:

• If T is assignable to U, then ConditionalUnion<T, U> should resolve to true.
• Otherwise (if T is not assignable to U), ConditionalUnion<T, U> should resolve to false.

You need to define this ConditionalUnion type such that it can be used to create more complex conditional logic within your TypeScript projects.

Examples

Example 1:

// Input:
type MyTypeA = string;
type MyTypeB = string | number;

type Result1 = ConditionalUnion<MyTypeA, MyTypeB>;
// Expected Output: true
// Explanation: 'string' is assignable to 'string | number'.

Example 2:

// Input:
type MyTypeC = number;
type MyTypeD = string | boolean;

type Result2 = ConditionalUnion<MyTypeC, MyTypeD>;
// Expected Output: false
// Explanation: 'number' is not assignable to 'string | boolean'.

Example 3:

// Input:
type MyTypeE = { name: string };
type MyTypeF = { name: string; age: number };

type Result3 = ConditionalUnion<MyTypeE, MyTypeF>;
// Expected Output: false
// Explanation: '{ name: string }' is not assignable to '{ name: string; age: number }'
// (because MyTypeE lacks the 'age' property).

Example 4:

// Input:
type MyTypeG = { name: string; age: number };
type MyTypeH = { name: string };

type Result4 = ConditionalUnion<MyTypeG, MyTypeH>;
// Expected Output: true
// Explanation: '{ name: string; age: number }' is assignable to '{ name: string }'.

Constraints

• The solution must be a single TypeScript generic type definition.
• The type should only use standard TypeScript features available in TypeScript 3.0 and later.
• No external libraries or dependencies are allowed.

Notes

This problem directly tests your understanding of TypeScript's conditional types and how they interact with assignability checks. Think about how TypeScript's built-in infer keyword and the extends keyword within conditional types can be combined to achieve the desired outcome. The goal is to create a type that mirrors the behavior of a boolean check for assignability.