Deep Partial Types in TypeScript

Deep partial types allow you to make all nested properties within an object optional. This is incredibly useful when dealing with complex data structures where you only want to update a subset of properties, potentially deep within the object, without having to explicitly mark every nested property as optional. This challenge asks you to implement a utility type that achieves this deep partial functionality.

Problem Description

You need to create a TypeScript utility type called DeepPartial<T> that takes a type T and returns a new type where all properties of T, including those nested within objects, are optional. This means if T has a property x which is itself an object with properties y and z, the resulting type should have x.y? and x.z?.

Key Requirements:

• The utility type must handle arbitrarily nested objects.
• Primitive types (string, number, boolean, etc.) within the object should remain unchanged.
• The utility type should correctly handle arrays of objects.
• The utility type should not modify the original type T.

Expected Behavior:

Given a type T, DeepPartial<T> should return a type where every property, at any level of nesting, is optional.

Edge Cases to Consider:

• Empty objects: DeepPartial<{}> should return {}.
• Arrays: DeepPartial<string[]> should return (string | undefined)[].
• Union types: DeepPartial<string | number> should return string | number | undefined.
• Intersection types: DeepPartial<A & B> should return DeepPartial<A> & DeepPartial<B>.
• Readonly properties: DeepPartial<Readonly<{ a: number }>> should still make a optional.

Examples

Example 1:

Input:
type MyType = {
  name: string;
  address: {
    street: string;
    city: string;
  };
  hobbies: string[];
};

type DeepPartialResult = DeepPartial<MyType>;

Output:
type DeepPartialResult = {
  name?: string | undefined;
  address?: {
    street?: string | undefined;
    city?: string | undefined;
  } | undefined;
  hobbies?: (string | undefined)[] | undefined;
};

Explanation: All properties of MyType, including address.street and address.city, are now optional. The hobbies array now contains string | undefined.

Example 2:

Input:
type SimpleType = {
  a: number;
  b: boolean;
};

type DeepPartialResult = DeepPartial<SimpleType>;

Output:
type DeepPartialResult = {
  a?: number | undefined;
  b?: boolean | undefined;
};

Explanation: The simple object's properties are made optional.

Example 3:

Input:
type ArrayType = string[];

type DeepPartialResult = DeepPartial<ArrayType>;

Output:
type DeepPartialResult = (string | undefined)[];

Explanation: The array's elements are made optional.

Constraints

• The solution must be a valid TypeScript type definition.
• The solution should be concise and readable.
• The solution should handle all the edge cases mentioned above.
• The solution should not use any external libraries.
• The solution should be compatible with TypeScript 4.0 or higher.

Notes

Consider using conditional types and recursion to traverse the object structure and make properties optional. Think about how to handle primitive types and arrays differently than objects. The key is to recursively apply the partial transformation to nested objects.