Count Element Number To Object

In this medium-level challenge, you'll implement CountElementNumberToObject<T> which counts the occurrences of every element in a potentially nested array and returns an object mapping each element to its count.

type Simple1 = CountElementNumberToObject<[]> // return {}
type Simple2 = CountElementNumberToObject<[1,2,3,4,5]>
// return {
//   1: 1,
//   2: 1,
//   3: 1,
//   4: 1,
//   5: 1
// }
 
type Simple3 = CountElementNumberToObject<[1,2,3,4,5,[1,2,3]]>
// return {
//   1: 2,
//   2: 2,
//   3: 2,
//   4: 1,
//   5: 1
// }

type cases = [
  Expect<
    Equal<
      CountElementNumberToObject<[1, 2, 3, 4, 5]>,
      {
        1: 1
        2: 1
        3: 1
        4: 1
        5: 1
      }
    >
  >,
  Expect<
    Equal<
      CountElementNumberToObject<[1, 2, 3, 4, 5, [1, 2, 3]]>,
      {
        1: 2
        2: 2
        3: 2
        4: 1
        5: 1
      }
    >
  >,
  Expect<
    Equal<
      CountElementNumberToObject<[1, 2, 3, 4, 5, [1, 2, 3, [4, 4, 1, 2]]]>,
      {
        1: 3
        2: 3
        3: 2
        4: 3
        5: 1
      }
    >
  >,
  Expect<Equal<CountElementNumberToObject<[never]>, {}>>,

Detailed Explanation

type Flatten<T extends any[]> = T extends [infer First, ...infer Rest]
  ? First extends any[]
    ? [...Flatten<First>, ...Flatten<Rest>]
    : [First, ...Flatten<Rest>]
  : []
 
type FilterNever<T extends any[]> = T extends [infer First, ...infer Rest]
  ? [First] extends [never]
    ? FilterNever<Rest>
    : [First, ...FilterNever<Rest>]
  : []
 
type Count<T extends any[], V, Acc extends unknown[] = []> = T extends [infer First, ...infer Rest]
  ? Equal<First, V> extends true
    ? Count<Rest, V, [...Acc, unknown]>
    : Count<Rest, V, Acc>
  : Acc['length']
 
type CountElementNumberToObject<T extends any[], F extends any[] = FilterNever<Flatten<T>>> = {
  [K in F[number] as K & PropertyKey]: Count<F, K>
}

How it works:

• Flatten<T> recursively flattens nested arrays into a single-level tuple, so [1, [2, [3]]] becomes [1, 2, 3]
• FilterNever<T> removes any never values from the flattened array, since [never] should produce an empty object {}
• Count<T, V> counts how many times value V appears in the array by using an accumulator tuple Acc and returning its length
• CountElementNumberToObject combines everything: it flattens, filters never, then maps over each unique element using F[number] as the key (cast to PropertyKey) with its count as the value
• The K & PropertyKey intersection ensures only valid property keys (strings, numbers, symbols) are used as object keys

This challenge helps you understand deep array flattening, element counting at the type level, and mapped types with key remapping, and how to apply these concepts in real-world scenarios.