FlattenDepth

In this medium-level challenge, you'll implement FlattenDepth<T, Depth> which recursively flattens a nested array up to a specified number of times, with the depth defaulting to 1.

type a = FlattenDepth<[1, 2, [3, 4], [[[5]]]], 2> // [1, 2, 3, 4, [5]]. flattern 2 times
type b = FlattenDepth<[1, 2, [3, 4], [[[5]]]]> // [1, 2, 3, 4, [[5]]]. Depth defaults to be 1

Detailed Explanation

We need to flatten one level at a time and decrement a depth counter on each pass. A helper type flattens exactly one level, and we repeatedly apply it until the depth is exhausted or the array is already flat.

type FlattenOnce<T extends any[]> = T extends [infer First, ...infer Rest]
  ? First extends any[]
    ? [...First, ...FlattenOnce<Rest>]
    : [First, ...FlattenOnce<Rest>]
  : []
 
type FlattenDepth<
  T extends any[],
  Depth extends number = 1,
  Count extends any[] = []
> = Count['length'] extends Depth
  ? T
  : FlattenOnce<T> extends T
    ? T
    : FlattenDepth<FlattenOnce<T>, Depth, [...Count, 1]>

How it works:

• FlattenOnce<T> performs a single level of flattening by spreading any array elements one level deep
• Count is a tuple that acts as a counter, incrementing by one element each recursive step
• When Count['length'] equals Depth, we have flattened enough times and return T as-is
• FlattenOnce<T> extends T is an early exit: if flattening produces the same type, the array is already fully flat, so we stop early (this prevents infinite recursion for very large depth values)
• Otherwise, we flatten one level and recurse with an incremented counter

This challenge helps you understand depth-controlled recursive type flattening and how to apply this concept in real-world scenarios.