Carlos Florêncio
594 lines
21 KiB
TypeScript
594 lines
21 KiB
TypeScript
"use client";
|
|
|
|
import { useEffect, useState, useCallback, useRef, useMemo } from "react";
|
|
import { getWebSocketClient } from "@/lib/ws/connection";
|
|
import { requestFileTree, searchWorkspaceFiles } from "@/lib/ws/workspace-files";
|
|
import type { FileTreeNode } from "@/lib/types/backend";
|
|
import { useSessionAgentctl } from "@/hooks/domains/session/use-session-agentctl";
|
|
import { getFilesPanelExpandedPaths, setFilesPanelExpandedPaths } from "@/lib/local-storage";
|
|
import { useTree, type VisibleRow } from "@/hooks/use-tree";
|
|
import { mergeTreeNodes } from "./file-browser-parts";
|
|
import { compareTreeNodes, sortRootChildren } from "./file-tree-utils";
|
|
import { createDebugLogger, IS_DEBUG } from "@/lib/debug/log";
|
|
|
|
const debugLoad = createDebugLogger("file-browser:load");
|
|
const debugChanges = createDebugLogger("file-browser:changes");
|
|
|
|
const FB_GET_PATH = (n: FileTreeNode) => n.path;
|
|
// Children are sorted (dirs first, then files, alphabetically) on every
|
|
// access so the flat visibleRows list comes out in the same order the
|
|
// recursive render produced. The backend doesn't guarantee order and tree
|
|
// mutations (rename / create) can insert arbitrarily.
|
|
const FB_GET_CHILDREN = (n: FileTreeNode) =>
|
|
n.children ? [...n.children].sort(compareTreeNodes) : undefined;
|
|
const FB_IS_DIR = (n: FileTreeNode) => n.is_dir;
|
|
|
|
export type FileBrowserRow = VisibleRow<FileTreeNode>;
|
|
|
|
const MAX_RETRY_ATTEMPTS = 4;
|
|
const RETRY_DELAYS_MS = [1000, 2000, 5000, 10000];
|
|
|
|
export type LoadState = "loading" | "waiting" | "loaded" | "manual" | "error";
|
|
|
|
/** Hook encapsulating file search state and handlers. */
|
|
export function useFileBrowserSearch(sessionId: string) {
|
|
const [isSearchActive, setIsSearchActive] = useState(false);
|
|
const [localSearchQuery, setLocalSearchQuery] = useState("");
|
|
const [searchResults, setSearchResults] = useState<string[] | null>(null);
|
|
const [isSearching, setIsSearching] = useState(false);
|
|
const searchTimeoutRef = useRef<NodeJS.Timeout | null>(null);
|
|
const searchInputRef = useRef<HTMLInputElement>(null);
|
|
|
|
// Focus search input when search opens
|
|
useEffect(() => {
|
|
if (isSearchActive && searchInputRef.current) {
|
|
searchInputRef.current.focus();
|
|
}
|
|
}, [isSearchActive]);
|
|
|
|
// Clear search when closing
|
|
useEffect(() => {
|
|
if (!isSearchActive) {
|
|
setLocalSearchQuery("");
|
|
setSearchResults(null);
|
|
setIsSearching(false);
|
|
if (searchTimeoutRef.current) clearTimeout(searchTimeoutRef.current);
|
|
}
|
|
}, [isSearchActive]);
|
|
|
|
// Cleanup on unmount
|
|
useEffect(() => {
|
|
return () => {
|
|
if (searchTimeoutRef.current) clearTimeout(searchTimeoutRef.current);
|
|
};
|
|
}, []);
|
|
|
|
const handleSearchChange = useCallback(
|
|
(e: React.ChangeEvent<HTMLInputElement>) => {
|
|
const value = e.target.value;
|
|
setLocalSearchQuery(value);
|
|
if (searchTimeoutRef.current) clearTimeout(searchTimeoutRef.current);
|
|
if (!value.trim()) {
|
|
setSearchResults(null);
|
|
setIsSearching(false);
|
|
return;
|
|
}
|
|
setIsSearching(true);
|
|
searchTimeoutRef.current = setTimeout(async () => {
|
|
try {
|
|
const client = getWebSocketClient();
|
|
if (!client) return;
|
|
const response = await searchWorkspaceFiles(client, sessionId, value, 50);
|
|
setSearchResults(response.files || []);
|
|
} catch (error) {
|
|
console.error("Failed to search files:", error);
|
|
setSearchResults([]);
|
|
} finally {
|
|
setIsSearching(false);
|
|
}
|
|
}, 300);
|
|
},
|
|
[sessionId],
|
|
);
|
|
|
|
const handleCloseSearch = useCallback(() => {
|
|
setIsSearchActive(false);
|
|
setLocalSearchQuery("");
|
|
setSearchResults(null);
|
|
setIsSearching(false);
|
|
if (searchTimeoutRef.current) clearTimeout(searchTimeoutRef.current);
|
|
}, []);
|
|
|
|
return {
|
|
isSearchActive,
|
|
setIsSearchActive,
|
|
localSearchQuery,
|
|
searchResults,
|
|
isSearching,
|
|
searchInputRef,
|
|
handleSearchChange,
|
|
handleCloseSearch,
|
|
};
|
|
}
|
|
|
|
/** Apply incoming file changes to the tree by refreshing affected folders. */
|
|
export function applyFileChanges(ctx: {
|
|
client: ReturnType<typeof getWebSocketClient>;
|
|
sessionId: string;
|
|
expandedPaths: ReadonlySet<string>;
|
|
changes: Array<{ path: string; operation?: string; repository_name?: string }>;
|
|
setTree: React.Dispatch<React.SetStateAction<FileTreeNode | null>>;
|
|
setLoadState: React.Dispatch<React.SetStateAction<LoadState>>;
|
|
}) {
|
|
const { client, sessionId, expandedPaths, changes, setTree, setLoadState } = ctx;
|
|
const foldersToRefresh = new Set<string>();
|
|
for (const change of changes) {
|
|
// `refresh` events have empty path; refresh root + every expanded folder under the affected repo so new files show up.
|
|
if (change.operation === "refresh") {
|
|
foldersToRefresh.add("");
|
|
const repo = change.repository_name;
|
|
for (const exp of expandedPaths) {
|
|
if (!repo || exp === repo || exp.startsWith(repo + "/")) {
|
|
foldersToRefresh.add(exp);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
const p = change.path;
|
|
const lastSlash = p.lastIndexOf("/");
|
|
const parent = lastSlash === -1 ? "" : p.substring(0, lastSlash);
|
|
if (parent === "" || expandedPaths.has(parent)) foldersToRefresh.add(parent);
|
|
if (p === "" || expandedPaths.has(p)) foldersToRefresh.add(p);
|
|
}
|
|
if (foldersToRefresh.size === 0) {
|
|
if (IS_DEBUG)
|
|
debugChanges("no-folders-to-refresh", {
|
|
sessionId,
|
|
candidates: changes.length,
|
|
expandedPaths: expandedPaths.size,
|
|
});
|
|
return;
|
|
}
|
|
if (IS_DEBUG)
|
|
debugChanges("refresh", {
|
|
sessionId,
|
|
folders: Array.from(foldersToRefresh).slice(0, 5),
|
|
total: foldersToRefresh.size,
|
|
});
|
|
|
|
void (async () => {
|
|
try {
|
|
const folderUpdates = new Map<string, FileTreeNode[] | undefined>();
|
|
await Promise.all(
|
|
Array.from(foldersToRefresh).map(async (folder) => {
|
|
try {
|
|
const res = await requestFileTree(client!, sessionId, folder || "", 1);
|
|
folderUpdates.set(folder, res.root?.children);
|
|
} catch {
|
|
/* Folder may have been removed */
|
|
}
|
|
}),
|
|
);
|
|
setTree((prev) => {
|
|
if (!prev) return prev;
|
|
let updated = prev;
|
|
if (folderUpdates.has("")) {
|
|
const freshRootChildren = folderUpdates.get("");
|
|
const existingByPath = new Map((updated.children ?? []).map((c) => [c.path, c]));
|
|
const mergedRootChildren = freshRootChildren?.map((incoming) => {
|
|
const existing = existingByPath.get(incoming.path);
|
|
return existing && existing.is_dir && incoming.is_dir
|
|
? mergeTreeNodes(existing, incoming)
|
|
: incoming;
|
|
});
|
|
updated = { ...updated, children: mergedRootChildren };
|
|
}
|
|
const subFolders = Array.from(folderUpdates.keys()).filter((k) => k !== "");
|
|
if (subFolders.length === 0) return updated;
|
|
const patchNode = (node: FileTreeNode): FileTreeNode => {
|
|
if (node.is_dir && folderUpdates.has(node.path)) {
|
|
return { ...node, children: folderUpdates.get(node.path)?.map(patchNode) };
|
|
}
|
|
return node.children ? { ...node, children: node.children.map(patchNode) } : node;
|
|
};
|
|
// Skip root: already merged above; re-matching folderUpdates.has("") here would overwrite preserved subtrees.
|
|
return { ...updated, children: updated.children?.map(patchNode) };
|
|
});
|
|
setLoadState("loaded");
|
|
} catch (error) {
|
|
console.error("[FileBrowser] Failed to refresh file tree:", error);
|
|
}
|
|
})();
|
|
}
|
|
|
|
function useLoadingTimers() {
|
|
const loadingTimersRef = useRef<Map<string, NodeJS.Timeout>>(new Map());
|
|
const activeLoadsRef = useRef<Set<string>>(new Set());
|
|
const [visibleLoadingPaths, setVisibleLoadingPaths] = useState<Set<string>>(new Set());
|
|
|
|
const showLoading = useCallback((path: string) => {
|
|
activeLoadsRef.current.add(path);
|
|
const timer = setTimeout(() => {
|
|
setVisibleLoadingPaths((prev) => new Set(prev).add(path));
|
|
loadingTimersRef.current.delete(path);
|
|
}, 150);
|
|
loadingTimersRef.current.set(path, timer);
|
|
}, []);
|
|
|
|
const hideLoading = useCallback((path: string) => {
|
|
activeLoadsRef.current.delete(path);
|
|
const timer = loadingTimersRef.current.get(path);
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
loadingTimersRef.current.delete(path);
|
|
}
|
|
setVisibleLoadingPaths((prev) => {
|
|
const next = new Set(prev);
|
|
next.delete(path);
|
|
return next;
|
|
});
|
|
}, []);
|
|
|
|
const isLoading = useCallback((path: string) => activeLoadsRef.current.has(path), []);
|
|
|
|
return { visibleLoadingPaths, showLoading, hideLoading, isLoading };
|
|
}
|
|
|
|
type TreeLoaderContext = {
|
|
sessionId: string;
|
|
clearRetryTimer: () => void;
|
|
retryAttemptRef: React.MutableRefObject<number>;
|
|
retryTimerRef: React.MutableRefObject<NodeJS.Timeout | null>;
|
|
setTree: React.Dispatch<React.SetStateAction<FileTreeNode | null>>;
|
|
setIsLoadingTree: React.Dispatch<React.SetStateAction<boolean>>;
|
|
setLoadState: React.Dispatch<React.SetStateAction<LoadState>>;
|
|
setLoadError: React.Dispatch<React.SetStateAction<string | null>>;
|
|
};
|
|
|
|
// Thin wrapper so loadTree callers don't each pay a complexity point for IS_DEBUG.
|
|
function logLoad(event: string, data: Record<string, unknown>) {
|
|
if (IS_DEBUG) debugLoad(event, data);
|
|
}
|
|
|
|
function useTreeLoader(ctx: TreeLoaderContext) {
|
|
const {
|
|
clearRetryTimer,
|
|
retryAttemptRef,
|
|
retryTimerRef,
|
|
setTree,
|
|
setIsLoadingTree,
|
|
setLoadState,
|
|
setLoadError,
|
|
} = ctx;
|
|
// Use ref for sessionId so loadTree stays stable across session switches.
|
|
// This prevents the tree-clearing effect from re-firing when only sessionId changes.
|
|
const sessionIdRef = useRef(ctx.sessionId);
|
|
sessionIdRef.current = ctx.sessionId;
|
|
const loadInFlightRef = useRef(false);
|
|
const loadTree = useCallback(
|
|
async (options?: { resetRetry?: boolean }) => {
|
|
if (loadInFlightRef.current) {
|
|
logLoad("skip-in-flight", { sessionId: sessionIdRef.current });
|
|
return;
|
|
}
|
|
loadInFlightRef.current = true;
|
|
setIsLoadingTree(true);
|
|
setLoadState("loading");
|
|
setLoadError(null);
|
|
if (options?.resetRetry) {
|
|
retryAttemptRef.current = 0;
|
|
clearRetryTimer();
|
|
}
|
|
logLoad("start", {
|
|
sessionId: sessionIdRef.current,
|
|
resetRetry: options?.resetRetry === true,
|
|
retryAttempt: retryAttemptRef.current,
|
|
});
|
|
try {
|
|
const client = getWebSocketClient();
|
|
if (!client) throw new Error("WebSocket client not available");
|
|
const response = await requestFileTree(client, sessionIdRef.current, "", 1);
|
|
setTree(response.root ?? null);
|
|
setLoadState("loaded");
|
|
retryAttemptRef.current = 0;
|
|
clearRetryTimer();
|
|
logLoad("loaded", {
|
|
sessionId: sessionIdRef.current,
|
|
rootPath: response.root?.path ?? null,
|
|
children: response.root?.children?.length ?? 0,
|
|
});
|
|
} catch (error) {
|
|
const message = error instanceof Error ? error.message : "Failed to load file tree";
|
|
setLoadError(message);
|
|
if (retryAttemptRef.current < MAX_RETRY_ATTEMPTS) {
|
|
const delay =
|
|
RETRY_DELAYS_MS[Math.min(retryAttemptRef.current, RETRY_DELAYS_MS.length - 1)];
|
|
retryAttemptRef.current += 1;
|
|
setLoadState("waiting");
|
|
clearRetryTimer();
|
|
logLoad("retry", {
|
|
sessionId: sessionIdRef.current,
|
|
attempt: retryAttemptRef.current,
|
|
delayMs: delay,
|
|
error: message,
|
|
});
|
|
retryTimerRef.current = setTimeout(() => {
|
|
void loadTree();
|
|
}, delay);
|
|
} else {
|
|
setLoadState("manual");
|
|
logLoad("gave-up", { sessionId: sessionIdRef.current, error: message });
|
|
}
|
|
} finally {
|
|
setIsLoadingTree(false);
|
|
loadInFlightRef.current = false;
|
|
}
|
|
},
|
|
[
|
|
clearRetryTimer,
|
|
retryAttemptRef,
|
|
retryTimerRef,
|
|
setIsLoadingTree,
|
|
setLoadError,
|
|
setLoadState,
|
|
setTree,
|
|
],
|
|
);
|
|
return loadTree;
|
|
}
|
|
|
|
type TreeLoadEffectsContext = {
|
|
sessionId: string;
|
|
effectiveResetKey: string;
|
|
agentctlIsReady: boolean;
|
|
agentctlIsReadyRef: React.MutableRefObject<boolean>;
|
|
loadStateRef: React.MutableRefObject<LoadState>;
|
|
treeRef: React.MutableRefObject<FileTreeNode | null>;
|
|
retryAttemptRef: React.MutableRefObject<number>;
|
|
hasInitializedExpandedRef: React.MutableRefObject<string | null>;
|
|
clearRetryTimer: () => void;
|
|
loadTree: (options?: { resetRetry?: boolean }) => Promise<void> | void;
|
|
setTree: React.Dispatch<React.SetStateAction<FileTreeNode | null>>;
|
|
setIsLoadingTree: React.Dispatch<React.SetStateAction<boolean>>;
|
|
setLoadState: React.Dispatch<React.SetStateAction<LoadState>>;
|
|
setLoadError: React.Dispatch<React.SetStateAction<string | null>>;
|
|
setExpandedPaths: (paths: Set<string>) => void;
|
|
};
|
|
|
|
/** Owns the two effects that drive initial load and the waiting→ready flip. */
|
|
function useTreeLoadEffects(ctx: TreeLoadEffectsContext) {
|
|
const {
|
|
sessionId,
|
|
effectiveResetKey,
|
|
agentctlIsReady,
|
|
agentctlIsReadyRef,
|
|
loadStateRef,
|
|
treeRef,
|
|
retryAttemptRef,
|
|
hasInitializedExpandedRef,
|
|
clearRetryTimer,
|
|
loadTree,
|
|
setTree,
|
|
setIsLoadingTree,
|
|
setLoadState,
|
|
setLoadError,
|
|
setExpandedPaths,
|
|
} = ctx;
|
|
|
|
useEffect(() => {
|
|
setTree(null);
|
|
setIsLoadingTree(true);
|
|
setLoadState(agentctlIsReadyRef.current ? "loading" : "waiting");
|
|
setLoadError(null);
|
|
retryAttemptRef.current = 0;
|
|
clearRetryTimer();
|
|
hasInitializedExpandedRef.current = null;
|
|
const savedPaths = getFilesPanelExpandedPaths(effectiveResetKey);
|
|
setExpandedPaths(savedPaths.length > 0 ? new Set(savedPaths) : new Set());
|
|
if (savedPaths.length > 0) hasInitializedExpandedRef.current = effectiveResetKey;
|
|
logLoad("init-effect", {
|
|
sessionId,
|
|
effectiveResetKey,
|
|
agentctlReady: agentctlIsReadyRef.current,
|
|
savedPaths: savedPaths.length,
|
|
willLoad: agentctlIsReadyRef.current,
|
|
});
|
|
if (agentctlIsReadyRef.current) void loadTree({ resetRetry: true });
|
|
else setIsLoadingTree(false);
|
|
return () => {
|
|
clearRetryTimer();
|
|
};
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps -- refs intentionally omitted
|
|
}, [clearRetryTimer, loadTree, effectiveResetKey, setExpandedPaths]);
|
|
|
|
// Fire the initial load on the waiting → ready transition. `loadState` is
|
|
// read via a ref so a failed load (which sets state back to "waiting") does
|
|
// not re-fire this effect and cancel the retry timer via `resetRetry: true`.
|
|
// The `treeRef.current` check alongside "loaded" is load-bearing:
|
|
// `applyFileChanges` can flip state to "loaded" while the tree is still
|
|
// null, and without the tree check this effect would skip the real load.
|
|
useEffect(() => {
|
|
let reason: string | null = null;
|
|
if (!agentctlIsReady) reason = "agentctl-not-ready";
|
|
else if (loadStateRef.current === "loading") reason = "already-loading";
|
|
else if (loadStateRef.current === "loaded" && treeRef.current) reason = "already-loaded";
|
|
if (reason) {
|
|
logLoad("ready-effect-skip", { sessionId, reason, loadState: loadStateRef.current });
|
|
return;
|
|
}
|
|
logLoad("ready-flip", { sessionId, loadState: loadStateRef.current });
|
|
void loadTree({ resetRetry: true });
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps -- refs intentionally omitted
|
|
}, [agentctlIsReady, loadTree, sessionId]);
|
|
}
|
|
|
|
function useFileChangeSubscription({
|
|
sessionIdRef,
|
|
expandedPathsRef,
|
|
setTree,
|
|
setLoadState,
|
|
}: {
|
|
sessionIdRef: React.MutableRefObject<string>;
|
|
expandedPathsRef: React.MutableRefObject<ReadonlySet<string>>;
|
|
setTree: React.Dispatch<React.SetStateAction<FileTreeNode | null>>;
|
|
setLoadState: React.Dispatch<React.SetStateAction<LoadState>>;
|
|
}) {
|
|
// expandedPaths is read via ref so that toggling a directory (which mints a
|
|
// new Set) does not tear down and re-attach this WS listener — any event
|
|
// arriving during the swap would otherwise be silently dropped.
|
|
useEffect(() => {
|
|
const client = getWebSocketClient();
|
|
if (!client) return;
|
|
return client.on("session.workspace.file.changes", (msg) => {
|
|
const changes = msg.payload?.changes;
|
|
if (!changes || changes.length === 0) {
|
|
if (IS_DEBUG) debugChanges("event-empty", { sessionId: sessionIdRef.current });
|
|
return;
|
|
}
|
|
if (IS_DEBUG)
|
|
debugChanges("event", {
|
|
sessionId: sessionIdRef.current,
|
|
count: changes.length,
|
|
expandedPaths: expandedPathsRef.current.size,
|
|
firstPaths: changes.slice(0, 3).map((c: { path: string }) => c.path),
|
|
});
|
|
applyFileChanges({
|
|
client,
|
|
sessionId: sessionIdRef.current,
|
|
expandedPaths: expandedPathsRef.current,
|
|
changes,
|
|
setTree,
|
|
setLoadState,
|
|
});
|
|
});
|
|
}, [sessionIdRef, expandedPathsRef, setTree, setLoadState]);
|
|
}
|
|
|
|
/**
|
|
* Hook for tree loading with retry logic, file-change subscription, and expanded state.
|
|
* @param sessionId - Session ID for API calls (agentctl routing).
|
|
* @param resetKey - Optional stable key (e.g. environmentId) that controls when the tree
|
|
* does a full reset. When sessions share the same environment, this prevents the tree
|
|
* from flashing on tab switch.
|
|
*/
|
|
export function useFileBrowserTree(sessionId: string, resetKey?: string) {
|
|
const effectiveResetKey = resetKey ?? sessionId;
|
|
const [tree, setTree] = useState<FileTreeNode | null>(null);
|
|
// Expansion + flat visibleRows come from the shared useTree hook. tree is
|
|
// a single root node with children; useTree wants an array, so feed it the
|
|
// root's children (pre-sorted — see sortRootChildren).
|
|
const treeNodes = useMemo(() => sortRootChildren(tree), [tree]);
|
|
const treeApi = useTree<FileTreeNode>({
|
|
nodes: treeNodes,
|
|
getPath: FB_GET_PATH,
|
|
getChildren: FB_GET_CHILDREN,
|
|
isDir: FB_IS_DIR,
|
|
});
|
|
const expandedPaths = treeApi.expanded;
|
|
const setExpandedPaths = treeApi.setExpanded;
|
|
const visibleRows = treeApi.visibleRows;
|
|
// Stable ref over `expandedPaths` so the WS file-change subscription does
|
|
// not re-attach on every toggle (each toggle mints a new Set reference).
|
|
const expandedPathsRef = useRef<ReadonlySet<string>>(expandedPaths);
|
|
expandedPathsRef.current = expandedPaths;
|
|
const [isLoadingTree, setIsLoadingTree] = useState(true);
|
|
const [loadState, setLoadState] = useState<LoadState>("loading");
|
|
const [loadError, setLoadError] = useState<string | null>(null);
|
|
const hasInitializedExpandedRef = useRef<string | null>(null);
|
|
const retryAttemptRef = useRef(0);
|
|
const retryTimerRef = useRef<NodeJS.Timeout | null>(null);
|
|
const sessionIdRef = useRef(sessionId);
|
|
sessionIdRef.current = sessionId;
|
|
const agentctlStatus = useSessionAgentctl(sessionId);
|
|
const { visibleLoadingPaths, showLoading, hideLoading, isLoading } = useLoadingTimers();
|
|
|
|
const clearRetryTimer = useCallback(() => {
|
|
if (retryTimerRef.current) {
|
|
clearTimeout(retryTimerRef.current);
|
|
retryTimerRef.current = null;
|
|
}
|
|
}, []);
|
|
|
|
const loadTree = useTreeLoader({
|
|
sessionId,
|
|
clearRetryTimer,
|
|
retryAttemptRef,
|
|
retryTimerRef,
|
|
setTree,
|
|
setIsLoadingTree,
|
|
setLoadState,
|
|
setLoadError,
|
|
});
|
|
|
|
// Refs for effects below to read without adding deps — avoids infinite
|
|
// retry loops and wipe-on-reconnect when `isReady`/`loadState`/`tree` tick.
|
|
const agentctlIsReadyRef = useRef(agentctlStatus.isReady);
|
|
const loadStateRef = useRef(loadState);
|
|
const treeRef = useRef(tree);
|
|
agentctlIsReadyRef.current = agentctlStatus.isReady;
|
|
loadStateRef.current = loadState;
|
|
treeRef.current = tree;
|
|
useTreeLoadEffects({
|
|
sessionId,
|
|
effectiveResetKey,
|
|
agentctlIsReady: agentctlStatus.isReady,
|
|
agentctlIsReadyRef,
|
|
loadStateRef,
|
|
treeRef,
|
|
retryAttemptRef,
|
|
hasInitializedExpandedRef,
|
|
clearRetryTimer,
|
|
loadTree,
|
|
setTree,
|
|
setIsLoadingTree,
|
|
setLoadState,
|
|
setLoadError,
|
|
setExpandedPaths,
|
|
});
|
|
|
|
useEffect(() => {
|
|
if (!tree || isLoadingTree || hasInitializedExpandedRef.current === effectiveResetKey) return;
|
|
hasInitializedExpandedRef.current = effectiveResetKey;
|
|
setExpandedPaths(new Set());
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
}, [tree?.children?.length, isLoadingTree, effectiveResetKey]);
|
|
|
|
useEffect(() => {
|
|
if (expandedPaths.size > 0 || hasInitializedExpandedRef.current === effectiveResetKey) {
|
|
setFilesPanelExpandedPaths(effectiveResetKey, Array.from(expandedPaths));
|
|
}
|
|
}, [expandedPaths, effectiveResetKey]);
|
|
|
|
useFileChangeSubscription({ sessionIdRef, expandedPathsRef, setTree, setLoadState });
|
|
|
|
const collapseAll = treeApi.collapseAll;
|
|
|
|
return {
|
|
tree,
|
|
setTree,
|
|
expandedPaths,
|
|
setExpandedPaths,
|
|
visibleRows,
|
|
visibleLoadingPaths,
|
|
isLoadingTree,
|
|
loadState,
|
|
loadError,
|
|
loadTree,
|
|
showLoading,
|
|
hideLoading,
|
|
isLoading,
|
|
collapseAll,
|
|
};
|
|
}
|
|
|
|
// useScrollPersistence, loadNodeChildren, toggleFolderExpand, fetchAndOpenFile,
|
|
// and the ToggleFolderExpandDeps type live in ./file-browser-actions.ts to keep
|
|
// this file within the 600-line lint limit.
|
|
export {
|
|
useScrollPersistence,
|
|
loadNodeChildren,
|
|
toggleFolderExpand,
|
|
fetchAndOpenFile,
|
|
} from "./file-browser-actions";
|
|
export type { ToggleFolderExpandDeps } from "./file-browser-actions";
|