Deeply Required Object Types in TypeScript

TypeScript's Required<T> utility type makes all properties of an object type optional. However, this only operates at the top level. This challenge requires you to implement a DeepRequired<T> type that recursively makes all properties, including those nested within objects and arrays, required. This is crucial for ensuring data integrity when dealing with complex, nested configurations or API responses where you need to guarantee the presence of every piece of information.

Problem Description

Your task is to create a TypeScript utility type called DeepRequired<T>. This type should take an object type T and return a new type where all properties, at every level of nesting, are made required. This includes properties within nested objects, and elements within arrays of objects.

Key Requirements:

• The DeepRequired<T> type must recursively traverse the structure of T.
• If a property is an object, its properties should also be processed by DeepRequired.
• If a property is an array of objects (e.g., Array<{ prop: string } | undefined>), the elements within the array should also be processed. Specifically, if an array element is an object type, its properties should be made required.
• Primitive types (string, number, boolean, null, undefined, bigint, symbol) should remain as they are, but if they are properties of an object, they should become required.
• Readonly properties should be handled correctly, and the resulting required properties should not be readonly unless they were originally.

Expected Behavior:

Given an input type, DeepRequired<T> should produce a type where:

• All optional properties (?) are removed.
• All properties whose types include undefined (e.g., string | undefined) are transformed to not include undefined if the original property was optional or its type included undefined inherently. For example, foo?: string | undefined should become foo: string.
• Nested objects are similarly processed.
• Arrays containing object types have their object elements recursively processed.

Edge Cases:

• Handling of null and undefined as property values.
• Arrays of primitives.
• Readonly modifiers on properties and nested objects.
• Empty object types.
• Union types where one of the members might be undefined.

Examples

Example 1:

type InputType1 = {
  a?: string;
  b: number | undefined;
  c: {
    d?: boolean;
    e: {
      f?: string | null;
    };
  };
};

type OutputType1 = DeepRequired<InputType1>;

// Expected OutputType1 should be equivalent to:
// {
//   a: string;
//   b: number;
//   c: {
//     d: boolean;
//     e: {
//       f: string | null;
//     };
//   };
// }

Explanation: a was optional and string | undefined, it's now required and string. b was optional and number | undefined, it's now required and number. c.d was optional and boolean | undefined, it's now required and boolean. c.e.f was optional and string | null | undefined, it's now required and string | null.

Example 2:

type InputType2 = {
  items?: Array<{
    id?: number;
    name?: string | undefined;
  }>;
  config?: {
    retries?: number;
  };
};

type OutputType2 = DeepRequired<InputType2>;

// Expected OutputType2 should be equivalent to:
// {
//   items: Array<{
//     id: number;
//     name: string;
//   }>;
//   config: {
//     retries: number;
//   };
// }

Explanation: items was optional and an array. The array elements, which are objects, are now deeply required. items.id became number, and items.name became string. config.retries was optional and number | undefined, it's now required and number.

Example 3: Handling Readonly and Nullable Nested Objects

type InputType3 = {
  readonly settings?: {
    timeout?: number;
    verbose?: boolean | undefined;
  };
  data: Array<{
    value?: string;
  } | null | undefined>;
};

type OutputType3 = DeepRequired<InputType3>;

// Expected OutputType3 should be equivalent to:
// {
//   readonly settings: {
//     timeout: number;
//     verbose: boolean;
//   };
//   data: Array<{
//     value: string;
//   } | null>; // Note: null is still possible in the array, but objects within it are deeply required.
// }

Explanation: settings was readonly and optional. Its properties timeout and verbose are now required. The readonly modifier is preserved. data is an array that could contain objects, null, or undefined. The DeepRequired should ensure that if an element is an object, its properties are required. data itself is now required, and elements within the array that are objects have their value property made required. Null is still a possible type in the array.

Constraints

• Your solution must be a single TypeScript utility type DeepRequired<T>.
• The solution should not rely on external libraries or packages.
• The solution should correctly handle arbitrary levels of nesting.
• The solution should be efficient and not lead to excessive type instantiation or circular type definitions (where possible, though complex types can naturally lead to deep instantiation).

Notes

• Consider how to differentiate between a property that is optional and a property that inherently has undefined in its union type (e.g., prop?: string vs. prop: string | undefined). Both should result in a required property without undefined if possible.
• Think about how to process array types. If an array contains union types, you might need to unwrap and re-wrap them carefully.
• The Readonly modifier should be preserved. If a property is readonly, it should remain readonly after being made required.
• This challenge is a great exercise in recursive conditional types and understanding how to manipulate property modifiers and types in TypeScript.