Function useDiscoverTree

ui/src/components/panels/useDiscoverTree.ts:44–262

({
  dataProvider,
  refreshKey,
  isExpandable = defaultIsExpandable,
  autoExpandDepth = 3,
}: UseDiscoverTreeOptions)

 * the returned state into `<DiscoverPanel>`.
 */
export function useDiscoverTree({
  dataProvider,
  refreshKey,
  isExpandable = defaultIsExpandable,
  autoExpandDepth = 3,
}: UseDiscoverTreeOptions): UseDiscoverTreeResult {
  const [roots, setRoots] = useState<TreeNodeData[]>([]);
  const [loading, setLoading] = useState(true);
  const [expanded, setExpanded] = useState<Set<string>>(new Set());
  const [childrenMap, setChildrenMap] = useState<Map<string, TreeNodeData[]>>(
    new Map(),
  );
  const [loadingSet, setLoadingSet] = useState<Set<string>>(new Set());

  // Refs for latest values — used by async effects to avoid stale closures
  const rootsRef = useRef(roots);
  rootsRef.current = roots;
  const childrenMapRef = useRef(childrenMap);
  childrenMapRef.current = childrenMap;
  const expandedRef = useRef(expanded);
  expandedRef.current = expanded;

  // O(1) node-type lookup map, rebuilt when roots/childrenMap change
  const nodeTypeMapRef = useRef(new Map<string, string>());
  nodeTypeMapRef.current = (() => {
    const m = new Map<string, string>();
    for (const r of roots) m.set(r.id, r.type);
    for (const children of childrenMap.values()) {
      for (const c of children) m.set(c.id, c.type);
    }
    return m;
  })();

  /** Fetch children and write them into state. */
  const loadChildren = useCallback(
    async (nodeId: string, nodeType: string): Promise<TreeNodeData[]> => {
      const children = await dataProvider.fetchChildren(nodeId, nodeType);
      setChildrenMap((prev) => {
        const next = new Map(prev);
        next.set(nodeId, children);
        return next;
      });
      return children;
    },
    [dataProvider],
  );

  // Load roots on mount (and re-load when refreshKey changes), then auto-expand
  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 → ...)