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`

interface Test1 {
  readonly title: string
  readonly description: string
  readonly completed: boolean
  readonly meta: {
    readonly author: string
  }
}
type Test2 = {
  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'
      }
      readonly l: readonly [
        'hi',
        {
          readonly m: readonly ['hey']
        },
      ]
    }
  }
}
interface DeepMutableTest1 {
  title: string
  description: str

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.