Deep Readonly Types in TypeScript

Creating truly readonly types in TypeScript can be surprisingly tricky. Standard Readonly<T> only makes the top-level properties of an object readonly. This challenge focuses on creating a utility type that recursively makes all properties, including nested objects and arrays, readonly. This is crucial for ensuring data immutability and preventing accidental modifications within complex data structures.

Problem Description

You need to create a TypeScript utility type called DeepReadonly<T> that takes a type T and returns a new type where all properties, including those nested within objects and arrays, are readonly. This means that even properties within properties, or elements within arrays of objects, should be immutable.

Key Requirements:

• Recursive Readonly: The type must recursively apply readonly to all levels of nesting within objects and arrays.
• Handles Primitive Types: Primitive types (string, number, boolean, symbol, etc.) should be unaffected.
• Handles Union Types: The type should correctly handle union types, making all members of the union readonly.
• Handles Tuple Types: The type should correctly handle tuple types, making all elements readonly.
• Handles Optional Properties: The type should correctly handle optional properties, making them readonly when present.

Expected Behavior:

Given a type T, DeepReadonly<T> should produce a type where any property that is an object or array is itself readonly, and this applies recursively.

Edge Cases to Consider:

• Types with circular references (though you don't need to explicitly handle them, be aware of potential issues).
• Types with conditional types.
• Types with mapped types.
• Types with intersection types.

Examples

Example 1:

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

type DeepReadonlyInput = DeepReadonly<Input>;

// DeepReadonlyInput should be:
// type DeepReadonlyInput = {
//   readonly name: string;
//   readonly age: number;
//   readonly address: {
//     readonly street: string;
//     readonly city: string;
//   };
//   readonly hobbies: readonly string[];
// };

Explanation: All properties, including nested address and the hobbies array, are made readonly.

Example 2:

type Input2 = [string, number, { a: string }];

type DeepReadonlyInput2 = DeepReadonly<Input2>;

// DeepReadonlyInput2 should be:
// type DeepReadonlyInput2 = [readonly string, readonly number, readonly {
//   readonly a: string;
// }];

Explanation: The tuple elements are made readonly.

Example 3:

type Input3 = {
  a: string | number;
  b?: {
    c: string;
  }
};

type DeepReadonlyInput3 = DeepReadonly<Input3>;

// DeepReadonlyInput3 should be:
// type DeepReadonlyInput3 = {
//   readonly a: string | readonly number;
//   readonly b?: {
//     readonly c: string;
//   };
// };

Explanation: Union type member number becomes readonly number, and the optional property b and its nested property c are also made readonly.

Constraints

• The solution must be a valid TypeScript type definition.
• The solution should be as concise and efficient as possible while maintaining readability.
• The solution should work correctly for all valid TypeScript types, including those with complex nesting and various type constructs.
• No runtime code is required; this is purely a type-level challenge.

Notes

Consider using conditional types and mapped types to achieve the recursive readonly transformation. Think about how to differentiate between primitive types and complex types (objects and arrays) to avoid unnecessary transformations. The typeof operator can be helpful in determining the type of a property. Remember that Readonly<T> is a good starting point, but you need to extend its functionality to handle nested structures.