Standard flat(Infinity) flattens depth-first — once it descends into a nested array, it emits everything inside before returning. For "top-level first, then nested" we need breadth-first ordering.

Example

flattenBFS([1, [2, [3, 4], 5], 6, [7]])
// depth-first (flat):   [1, 2, 3, 4, 5, 6, 7]
// breadth-first (this): [1, 6, 2, 5, 7, 3, 4]

All level-0 primitives, then level-1, then level-2, etc.

Implementation

function flattenBFS(arr) {
  const out = [];
  let queue = [arr];
  while (queue.length) {
    const next = [];
    for (const node of queue) {
      for (const item of node) {
        if (Array.isArray(item)) next.push(item);
        else out.push(item);
      }
    }
    queue = next;
  }
  return out;
}

Per level: emit primitives in order, defer arrays. Repeat with the deferred set. O(n) in total elements; O(w) extra space for the queue (w = widest level).

Variant: depth-first with explicit depth control

If the question instead means "flatten to N levels":

function flatN(arr, depth = Infinity, out = []) {
  for (const item of arr) {
    if (Array.isArray(item) && depth > 0) flatN(item, depth - 1, out);
    else out.push(item);
  }
  return out;
}

Interview framing

"flat(Infinity) is depth-first. For 'top-level first then nested' I'd do breadth-first: process the current array, emit primitives, queue any sub-arrays for the next pass. O(n) total work, iterative so no stack overflow on deep nests. If they wanted depth-first with a limit instead, that's a recursive walk with a depth counter."