Deeply Required Types in TypeScript

TypeScript's type system is powerful, but sometimes you need more than just marking a field as required. This challenge focuses on creating a utility type that recursively marks all properties within nested objects as required. This is useful for ensuring that all fields, even those deeply nested, are explicitly defined when using the type, preventing unexpected undefined values and improving code robustness.

Problem Description

You are tasked with creating a TypeScript utility type called DeepRequired<T> that takes a type T and returns a new type where all properties of T, including those within nested objects, are marked as required. This means that if T has a property x of type string | undefined, DeepRequired<T> should have a property x of type string. The utility type should handle arbitrarily nested objects.

Key Requirements:

• Recursion: The utility type must recursively traverse nested objects within the input type.
• required Marking: All properties, at any level of nesting, must be marked as required.
• Type Preservation (where possible): The utility type should preserve the original types of the properties as much as possible, only changing undefined to never (or equivalent) to enforce the required nature.
• Handles Unions: The utility type should correctly handle unions, ensuring that undefined is removed from the union.

Expected Behavior:

Given a type T, DeepRequired<T> should return a type where all properties are required.

Edge Cases to Consider:

• Primitive Types: The utility type should not modify primitive types (e.g., string, number, boolean).
• Arrays: Arrays should also have their elements deeply required.
• Tuples: Tuples should also have their elements deeply required.
• Optional Chaining: Consider how optional chaining (?.) might interact with the resulting type.
• Nullish Coalescing: Consider how nullish coalescing (??) might interact with the resulting type.

Examples

Example 1:

type Input = {
  name?: string;
  address?: {
    street?: string;
    city?: string | undefined;
  };
};

type Expected = DeepRequired<Input>;

// Expected Output:
// type Expected = {
//   name: string;
//   address: {
//     street: string;
//     city: string;
//   };
// }

Example 2:

type Input2 = {
  a?: number;
  b?: {
    c?: string | undefined;
    d?: (boolean | undefined)[];
  };
};

type Expected2 = DeepRequired<Input2>;

// Expected Output:
// type Expected2 = {
//   a: number;
//   b: {
//     c: string;
//     d: boolean[];
//   };
// }

Example 3: (Edge Case - Array)

type Input3 = {
  items?: (string | undefined)[];
};

type Expected3 = DeepRequired<Input3>;

// Expected Output:
// type Expected3 = {
//   items: string[];
// }

Constraints

• The solution must be a valid TypeScript type definition.
• The solution should be as concise and readable as possible.
• The solution should handle arbitrarily nested objects.
• The solution should not introduce any runtime overhead. It's a type-level operation.
• The solution should be compatible with TypeScript 4.0 or later.

Notes

• Consider using conditional types and mapped types to achieve the desired recursion.
• The Required<T> utility type is a good starting point, but it only applies to the top-level properties.
• Think about how to handle different types (primitive, object, array, tuple) within the recursive process.
• The goal is to create a type-level transformation, not a runtime function. No code execution is involved.
• Pay close attention to how TypeScript handles optional properties and unions.