Implementing Deep Partial Types in TypeScript

Many real-world applications involve complex nested data structures. When updating these structures, you often only need to modify a small subset of fields, potentially deeply nested. TypeScript's built-in Partial utility type only makes the top-level properties optional. This challenge asks you to create a DeepPartial utility type that recursively makes all properties within a type, including those in nested objects and arrays, optional. This is incredibly useful for creating flexible update functions or configuration objects.

Problem Description

Your task is to implement a TypeScript utility type named DeepPartial<T>. This type should take a type T and return a new type where all properties of T are made optional, and importantly, if a property is itself an object or an array of objects, its properties should also be recursively made optional.

Key Requirements:

1. Recursive Optionality: All properties, at any level of nesting, should become optional.
2. Handling of Primitive Types: Primitive types (string, number, boolean, null, undefined, symbol, bigint) should remain as they are (or be considered optional if they are properties of an object).
3. Handling of Arrays: If a property is an array, its elements should also be recursively processed for deep partiality. This means if an array contains objects, those objects' properties should become optional.
4. Handling of Non-Object/Non-Array Types: Other types like functions, Dates, etc., should be treated as primitives and just become optional if they are properties.

Expected Behavior:

When DeepPartial<T> is applied to a type T:

• If T is a primitive, it should remain a primitive.
• If T is an object, all its properties should become optional (?:). If a property's value is an object or an array of objects, DeepPartial should be applied recursively to that property's type.
• If T is an array, DeepPartial should be applied to the element type of the array, wrapped in an array type (e.g., DeepPartial<U>[]).

Examples

Example 1:

Input Type:

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

Output Type (after applying DeepPartial<User>):

{
  id?: number | undefined;
  name?: string | undefined;
  address?: {
    street?: string | undefined;
    city?: string | undefined;
    zip?: number | undefined;
  } | undefined;
  roles?: string[] | undefined; // Note: arrays of primitives are not recursively deep-partialized in this way
}

Example 2:

Input Type:

interface Product {
  id: string;
  details: {
    name: string;
    manufacturer: {
      name: string;
      location: string;
    };
    tags: string[];
  };
  reviews: Array<{
    author: string;
    comment: string;
    rating: number;
  }>;
}

Output Type (after applying DeepPartial<Product>):

{
  id?: string | undefined;
  details?: {
    name?: string | undefined;
    manufacturer?: {
      name?: string | undefined;
      location?: string | undefined;
    } | undefined;
    tags?: string[] | undefined;
  } | undefined;
  reviews?: Array<{
    author?: string | undefined;
    comment?: string | undefined;
    rating?: number | undefined;
  }> | undefined;
}

Example 3 (Edge Case with Array of Arrays):

Input Type:

interface Matrix {
  data: number[][];
  config: {
    dimensions: {
      rows: number;
      cols: number;
    };
  };
}

Output Type (after applying DeepPartial<Matrix>):

{
  data?: number[][] | undefined; // arrays of primitives remain as is, just optional
  config?: {
    dimensions?: {
      rows?: number | undefined;
      cols?: number | undefined;
    } | undefined;
  } | undefined;
}

(Self-correction: The initial thought might be to deeply partial primitive arrays. However, the common interpretation and utility of DeepPartial focuses on making object properties optional recursively. Arrays of primitives are typically not recursively modified in this context, only the array property itself becomes optional.)

Constraints

• The solution must be a single TypeScript utility type named DeepPartial<T>.
• The solution should handle standard TypeScript primitive types correctly.
• The solution must work for arbitrarily nested objects and arrays of objects.
• No runtime code is required; this is purely a type-level challenge.

Notes

• Consider how to distinguish between objects, arrays, and primitive types at the type level.
• Conditional types and mapped types will be your primary tools.
• Think about how to handle null and undefined explicitly or implicitly.
• The Partial<T> utility type might be a useful building block or inspiration, but your solution needs to go beyond it.
• For arrays, you'll need to consider the element type. If the element type is itself an object, you'll want to apply DeepPartial to it. However, if the array contains primitives, the array type itself just becomes optional.