Function flattenTree

packages/core/src/widgets/tree.ts:55–109

(
  data: T | readonly T[],
  getKey: (node: T) => string,
  getChildren: ((node: T) => readonly T[] | undefined) | undefined,
  hasChildrenFn: ((node: T) => boolean) | undefined,
  expanded: readonly string[],
  expandedSet?: ReadonlySet<string>,
)

 * @returns Array of flattened nodes
 */
export function flattenTree<T>(
  data: T | readonly T[],
  getKey: (node: T) => string,
  getChildren: ((node: T) => readonly T[] | undefined) | undefined,
  hasChildrenFn: ((node: T) => boolean) | undefined,
  expanded: readonly string[],
  expandedSet?: ReadonlySet<string>,
): readonly FlattenedNode<T>[] {
  const result: FlattenedNode<T>[] = [];
  const expandedLookup = expandedSet ?? new Set(expanded);

  // Normalize to array of roots
  const roots: readonly T[] = Array.isArray(data) ? (data as readonly T[]) : [data as T];

  function traverse(
    nodes: readonly T[],
    depth: number,
    parentKey: string | null,
    ancestorIsLast: readonly boolean[],
  ): void {
    const siblingCount = nodes.length;

    for (let i = 0; i < siblingCount; i++) {
      const node = nodes[i];
      if (node === undefined) continue;

      const key = getKey(node);
      const children = getChildren?.(node);
      const hasChildren = hasChildrenFn ? hasChildrenFn(node) : (children?.length ?? 0) > 0;
      const isLast = i === siblingCount - 1;

      const flatNode: FlattenedNode<T> = Object.freeze({
        node,
        depth,
        siblingIndex: i,
        siblingCount,
        key,
        parentKey,
        hasChildren,
        ancestorIsLast: Object.freeze([...ancestorIsLast, isLast]),
      });

      result.push(flatNode);

      // Recurse into children if expanded
      if (hasChildren && expandedLookup.has(key) && children && children.length > 0) {
        traverse(children, depth + 1, key, flatNode.ancestorIsLast);
      }
    }
  }

  traverse(roots, 0, null, []);

  return Object.freeze(result);
}

/* ========== NodeState Computation ========== */