Flatten

In this medium-level challenge, you'll write a type that takes a nested array and produces a fully flattened array type, recursively unwrapping all levels of nesting.

[object Object]

/* _____________ Your Code Here _____________ */

type Flatten = any

/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '../helpers'

type cases = [
  Expect<Equal<Flatten<[]>, []>>,
  Expect<Equal<Flatten<[1, 2, 3, 4]>, [1, 2, 3, 4]>>,
  Expect<Equal<Flatten<[1, [2]]>, [1, 2]>>,
  Expect<Equal<Flatten<[1, 2, [3, 4], [[[5]]]]>, [1, 2, 3, 4, 5]>>,
  Expect<
    Equal<
      Flatten<[{ foo: 'bar'; 2: 10 }, 'foobar']>,
      [{ foo: 'bar'; 2: 10 }, 'foobar']
    >
  >,
]

// @ts-expect-error
type error = Flatten<'1'>

Detailed Explanation

We recursively process each element of the tuple. If an element is itself an array, we flatten it first and spread the result, then continue with the rest.

type Flatten<T extends any[]> = T extends [infer First, ...infer Rest]
  ? First extends any[]
    ? [...Flatten<First>, ...Flatten<Rest>]
    : [First, ...Flatten<Rest>]
  : []

How it works:

• T extends [infer First, ...infer Rest] destructures the tuple into the first element and the remaining elements
• First extends any[] checks whether the first element is itself an array
• If First is an array, we recursively flatten it with Flatten<First> and spread the result, then concatenate with the recursively flattened Rest
• If First is not an array, we keep it as-is and continue flattening Rest
• The base case returns an empty tuple when the input array is empty

This challenge helps you understand recursive type flattening with conditional array detection and how to apply this concept in real-world scenarios.