TypeScript Deep Partial Helper

Imagine you have a complex, deeply nested object structure in TypeScript. You often need to create a new object that's a partial copy of the original, meaning only some of its properties are defined, and these properties can also be deeply nested. This is common when updating configuration, merging data, or performing specific data transformations. This challenge will guide you in creating a utility type that recursively applies Partial to all levels of a nested object.

Problem Description

Your task is to create a TypeScript utility type, let's call it DeepPartial<T>, that takes a type T and returns a new type where all properties of T are made optional, recursively. This means that if T has a property that is itself an object type, that property's type should also be transformed into a DeepPartial version of itself. Primitive types and arrays should be handled appropriately.

Key Requirements:

1. Recursive Application: The Partial modifier must be applied to all levels of nested object properties.
2. Handling Primitives: Primitive types (string, number, boolean, null, undefined, symbol, bigint) should remain as they are.
3. Handling Arrays: If a property is an array of objects, each element in the array should be treated as a DeepPartial of its original type.
4. Handling Unions and Intersections: Consider how your type will behave with union and intersection types. (Hint: You might need to break them down.)
5. Handling null and undefined: These should be preserved as nullable types.

Expected Behavior:

Given an object type, DeepPartial<T> should allow you to create an object where any property, at any level of nesting, can be omitted or set to undefined.

Edge Cases to Consider:

• Empty objects.
• Objects with only primitive properties.
• Arrays of primitives.
• Arrays of objects.
• Properties that are already optional.
• null and undefined values within the object.
• Circular references (though for this challenge, you can assume no circular references for simplicity, but be aware of it in real-world scenarios).

Examples

Example 1:

Input Type:

interface User {
  id: number;
  name: string;
  address: {
    street: string;
    city: string;
    zip: number;
  };
  roles: string[];
}

Expected DeepPartial<User> output (conceptual):

{
  id?: number | undefined;
  name?: string | undefined;
  address?: {
    street?: string | undefined;
    city?: string | undefined;
    zip?: number | undefined;
  } | undefined;
  roles?: string[] | undefined;
}

Example 2:

Input Type:

interface Product {
  name: string;
  price: number;
  details: {
    weight: number;
    dimensions: {
      width: number;
      height: number;
      depth: number;
    };
  };
  tags: { id: number; name: string }[];
}

Expected DeepPartial<Product> output (conceptual):

{
  name?: string | undefined;
  price?: number | undefined;
  details?: {
    weight?: number | undefined;
    dimensions?: {
      width?: number | undefined;
      height?: number | undefined;
      depth?: number | undefined;
    } | undefined;
  } | undefined;
  tags?: { id?: number | undefined; name?: string | undefined }[] | undefined;
}

Example 3: Array of Objects

Input Type:

interface Config {
  settings: Array<{ key: string; value: any }>;
}

Expected DeepPartial<Config> output (conceptual):

{
  settings?: Array<{ key?: string | undefined; value?: any | undefined }> | undefined;
}

Constraints

• The solution must be implemented using TypeScript's type system.
• The solution should be a single utility type DeepPartial<T>.
• The solution should strive for reasonable performance within the TypeScript compiler. Avoid overly complex or computationally expensive type operations where simpler alternatives exist.
• The solution should correctly handle standard TypeScript types and constructs.

Notes

• This is an exercise in understanding and manipulating TypeScript's advanced type features, particularly mapped types and conditional types.
• You'll likely need to distinguish between object types, array types, and primitive types within your type definition.
• Consider using keyof T to iterate over properties of an object type.
• Partial<T> is your starting point, but you'll need to build upon it to achieve the "deep" aspect.
• Think about how to handle properties that are already optional (?). They should remain optional.
• The | undefined in the expected output signifies that a property can be explicitly set to undefined or omitted entirely (which also implies undefined).