Function init

ui/src/components/panels/useDiscoverTree.ts:94–142

()

  useEffect(() => {
    let cancelled = false;
    async function init() {
      setChildrenMap(new Map());
      try {
        const fetchedRoots = await dataProvider.fetchRoots();
        if (cancelled) return;
        setRoots(fetchedRoots);

        // Auto-expand N levels (root → children → grandchildren → ...)
        const newExpandedIds = new Set<string>();
        const newChildrenMap = new Map<string, TreeNodeData[]>();

        async function expandLevel(
          nodes: TreeNodeData[],
          depth: number,
        ): Promise<void> {
          if (depth >= autoExpandDepth || cancelled) return;
          const expandable = nodes.filter((n) => isExpandable(n));
          const childResults = await Promise.all(
            expandable.map(async (n) => {
              const children = await dataProvider.fetchChildren(n.id, n.type);
              return { parentId: n.id, children };
            }),
          );
          if (cancelled) return;
          for (const { parentId, children } of childResults) {
            newChildrenMap.set(parentId, children);
            if (children.length > 0) newExpandedIds.add(parentId);
          }
          const allChildren = childResults.flatMap((r) => r.children);
          await expandLevel(allChildren, depth + 1);
        }

        await expandLevel(fetchedRoots, 0);
        if (!cancelled) {
          setChildrenMap((prev) => {
            const next = new Map(prev);
            for (const [k, v] of newChildrenMap) next.set(k, v);
            return next;
          });
          setExpanded((prev) => {
            const next = new Set(prev);
            for (const id of newExpandedIds) next.add(id);
            return next;
          });
        }
      } finally {
        if (!cancelled) setLoading(false);
      }
    }
    init().catch((err: unknown) => {
      // AbortError fires when clearGraph races with in-flight expansions
      // (e.g. project switch). Expected — swallow silently. Preserve