DeepMutable

In this medium-level challenge, you'll implement DeepMutable<T> which recursively removes all readonly modifiers from every property of an object and its nested sub-objects, including arrays.

type X = {
readonly a: () => 1
readonly b: string
readonly c: {
readonly d: boolean
readonly e: {
readonly g: {
readonly h: {
readonly i: true
readonly j: "s"
}
readonly k: "hello"
}
}
}
}
 
type Expected = {
a: () => 1
b: string
c: {
d: boolean
e: {
g: {
h: {
i: true
j: "s"
}
k: "hello"
}
}
}
}
 
type Todo = DeepMutable<X> // should be same as `Expected`

Detailed Explanation

type DeepMutable<T extends Record<string, any>> = {
  -readonly [K in keyof T]: T[K] extends (...args: any[]) => any
    ? T[K]
    : T[K] extends object
      ? DeepMutable<T[K]>
      : T[K]
}

How it works:

• T extends Record<string, any> constrains the input to object types, which causes DeepMutable<'string'> and DeepMutable<0> to produce errors as expected
• -readonly [K in keyof T] uses the -readonly modifier to strip the readonly attribute from every property in the mapped type
• T[K] extends (...args: any[]) => any checks if the property value is a function; if so, it is returned as-is since functions should not be recursed into
• T[K] extends object checks if the value is an object (including arrays and tuples); if so, we recursively apply DeepMutable to strip readonly from nested properties
• For primitive values, we simply return T[K] unchanged
• This correctly handles readonly arrays and tuples (e.g., readonly ['hi', { readonly m: readonly ['hey'] }] becomes ['hi', { m: ['hey'] }])

This challenge helps you understand the -readonly mapped type modifier and recursive type traversal, and how to apply these concepts in real-world scenarios.