@tutti-os/workspace-file-reference 0.0.1

package/dist/chunk-LS7P3J6Z.js

@@ -0,0 +1,901 @@
+import {
+  uniqueWorkspaceFileReferences
+} from "./chunk-PAR2R2G5.js";
+
+// src/react/internal/reference/WorkspaceFileReferencePickerState.ts
+var workspaceFileReferenceDefaultExpandedDepth = 4;
+function normalizeDirectoryPath(path) {
+  if (!path || path === "/") {
+    return "/";
+  }
+  return path.replace(/\/+$/, "") || "/";
+}
+function collectVisibleTreeEntries(entries, directoryStateByPath, expandedFolderPaths) {
+  const collected = [];
+  for (const entry of entries) {
+    collected.push(entry);
+    if (entry.kind !== "folder") {
+      continue;
+    }
+    const folderKey = normalizeDirectoryPath(entry.path);
+    if (!expandedFolderPaths[folderKey]) {
+      continue;
+    }
+    const childEntries = directoryStateByPath[folderKey]?.entries ?? [];
+    if (childEntries.length === 0) {
+      continue;
+    }
+    collected.push(
+      ...collectVisibleTreeEntries(
+        childEntries,
+        directoryStateByPath,
+        expandedFolderPaths
+      )
+    );
+  }
+  return collected;
+}
+function mergeExpandedFolderPaths(current, prefetched) {
+  return {
+    ...prefetched,
+    ...current
+  };
+}
+function mergePrefetchedDirectoryState(current, prefetched) {
+  return {
+    ...current,
+    ...prefetched
+  };
+}
+function createWorkspaceFileReferenceDirectoryStateFromSnapshot(snapshot) {
+  const stateByPath = {};
+  addReferenceDirectoryStateFromSnapshot(stateByPath, snapshot.directory);
+  return stateByPath;
+}
+function addReferenceDirectoryStateFromSnapshot(stateByPath, directory) {
+  const normalizedPath = normalizeDirectoryPath(directory.directoryPath);
+  stateByPath[normalizedPath] = {
+    displayPath: directory.directoryPath,
+    entries: directory.entries.map((entry) => ({
+      displayName: entry.displayName,
+      kind: entry.kind,
+      path: entry.path
+    })),
+    loaded: true,
+    loading: false,
+    prefetchReason: directory.prefetchReason,
+    prefetchState: directory.prefetchState
+  };
+  for (const entry of directory.entries) {
+    if (entry.kind !== "folder") {
+      continue;
+    }
+    const folderKey = normalizeDirectoryPath(entry.path);
+    if (entry.prefetchedDirectory) {
+      addReferenceDirectoryStateFromSnapshot(
+        stateByPath,
+        entry.prefetchedDirectory
+      );
+      continue;
+    }
+    if (entry.prefetchState) {
+      stateByPath[folderKey] = {
+        displayPath: entry.path,
+        entries: [],
+        loaded: false,
+        loading: false,
+        prefetchReason: entry.prefetchReason,
+        prefetchState: entry.prefetchState
+      };
+    }
+  }
+}
+async function prefetchReferenceTree(input) {
+  const { depth = 1, listDirectory, maxDepth, path } = input;
+  const listing = await listDirectory(path);
+  if (!listing) {
+    return {
+      directoryStateByPath: {},
+      expandedFolderPaths: {}
+    };
+  }
+  const directoryStateByPath = {
+    [listing.normalizedPath]: {
+      displayPath: listing.displayPath,
+      entries: listing.entries,
+      loaded: true,
+      loading: false
+    }
+  };
+  const expandedFolderPaths = {
+    [listing.normalizedPath]: true
+  };
+  if (depth >= maxDepth) {
+    return {
+      directoryStateByPath,
+      expandedFolderPaths
+    };
+  }
+  for (const entry of listing.entries) {
+    if (entry.kind !== "folder") {
+      continue;
+    }
+    try {
+      const childTree = await prefetchReferenceTree({
+        depth: depth + 1,
+        listDirectory,
+        maxDepth,
+        path: entry.path
+      });
+      Object.assign(directoryStateByPath, childTree.directoryStateByPath);
+      Object.assign(expandedFolderPaths, childTree.expandedFolderPaths);
+    } catch {
+    }
+  }
+  return {
+    directoryStateByPath,
+    expandedFolderPaths
+  };
+}
+
+// src/react/internal/reference/useWorkspaceFileReferencePickerView.ts
+import {
+  useCallback,
+  useEffect,
+  useEffectEvent,
+  useMemo,
+  useState
+} from "react";
+import { useSnapshot } from "valtio";
+
+// src/react/internal/reference/WorkspaceFileReferencePickerController.ts
+import { proxy } from "valtio/vanilla";
+import {
+  createWorkspaceFilePreviewLoadedState,
+  resolveWorkspaceFilePreviewReadiness
+} from "@tutti-os/workspace-file-preview";
+var defaultDirectoryPath = "/";
+var defaultSearchDebounceMs = 180;
+function createWorkspaceFileReferencePickerController(input) {
+  const searchDebounceMs = input.searchDebounceMs ?? defaultSearchDebounceMs;
+  let browseSequence = 0;
+  let previewObjectUrl = null;
+  let previewSequence = 0;
+  let retained = false;
+  let searchAbortController = null;
+  let searchSequence = 0;
+  let searchTimer = null;
+  let snapshot = {
+    browseError: null,
+    browseRootPath: null,
+    directoryStateByPath: {},
+    expandedFolderPaths: {},
+    initialPathRevealed: false,
+    isBrowseLoading: false,
+    isSearchLoading: false,
+    mode: "browse",
+    previewState: { status: "empty" },
+    searchEntries: [],
+    searchError: null,
+    searchQuery: ""
+  };
+  const store = proxy(snapshot);
+  const setSnapshot = (update) => {
+    const next = typeof update === "function" ? update(snapshot) : { ...snapshot, ...update };
+    if (next === snapshot) {
+      return;
+    }
+    snapshot = next;
+    Object.assign(store, next);
+  };
+  const loadDirectoryListing = async (path) => {
+    if (!input.fileAdapter?.listDirectory) {
+      return null;
+    }
+    const listing = await input.fileAdapter.listDirectory({
+      path: path ?? void 0,
+      workspaceId: input.workspaceId
+    });
+    const displayPath = listing.directoryPath || listing.rootPath || path || defaultDirectoryPath;
+    const normalizedPath = normalizeDirectoryPath(displayPath);
+    return {
+      displayPath,
+      entries: uniqueWorkspaceFileReferences(listing.entries),
+      normalizedPath
+    };
+  };
+  const resolveMode = (query) => query.trim().length > 0 && input.fileAdapter?.searchReferences ? "search" : "browse";
+  const clearSearchTimer = () => {
+    if (searchTimer === null) {
+      return;
+    }
+    clearTimeout(searchTimer);
+    searchTimer = null;
+  };
+  const cancelCurrentSearch = () => {
+    clearSearchTimer();
+    searchSequence += 1;
+    searchAbortController?.abort();
+    searchAbortController = null;
+  };
+  const cancelCurrentBrowse = () => {
+    browseSequence += 1;
+  };
+  const cancelCurrentPreview = () => {
+    previewSequence += 1;
+    if (!previewObjectUrl) {
+      return;
+    }
+    URL.revokeObjectURL(previewObjectUrl);
+    previewObjectUrl = null;
+  };
+  const clearSearchResults = () => {
+    cancelCurrentSearch();
+    setSnapshot({
+      isSearchLoading: false,
+      searchEntries: [],
+      searchError: null
+    });
+  };
+  const runSearch = async (query) => {
+    if (!retained || !input.fileAdapter?.searchReferences) {
+      return;
+    }
+    const sequence = ++searchSequence;
+    searchAbortController?.abort();
+    const abortController = new AbortController();
+    searchAbortController = abortController;
+    setSnapshot({
+      isSearchLoading: true,
+      searchError: null
+    });
+    try {
+      const refs = await input.fileAdapter.searchReferences({
+        query,
+        signal: abortController.signal,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== searchSequence) {
+        return;
+      }
+      setSnapshot({
+        isSearchLoading: false,
+        searchEntries: uniqueWorkspaceFileReferences(refs),
+        searchError: null
+      });
+    } catch (error) {
+      if (isAbortError(error) || sequence !== searchSequence || !retained) {
+        return;
+      }
+      setSnapshot({
+        isSearchLoading: false,
+        searchEntries: [],
+        searchError: normalizeControllerError(
+          error,
+          "Workspace file reference search failed"
+        )
+      });
+    } finally {
+      if (sequence === searchSequence) {
+        searchAbortController = null;
+      }
+    }
+  };
+  const scheduleSearch = () => {
+    clearSearchTimer();
+    const query = snapshot.searchQuery.trim();
+    if (!retained || !input.fileAdapter?.searchReferences || !query) {
+      clearSearchResults();
+      return;
+    }
+    if (searchDebounceMs <= 0) {
+      void runSearch(query);
+      return;
+    }
+    searchTimer = setTimeout(() => {
+      searchTimer = null;
+      void runSearch(query);
+    }, searchDebounceMs);
+  };
+  const loadBrowseRoot = async () => {
+    if (!retained || snapshot.mode !== "browse" || !(input.fileAdapter?.listDirectory || input.fileAdapter?.loadReferenceTree)) {
+      return;
+    }
+    const activeBrowseRootPath = snapshot.browseRootPath;
+    const normalizedRoot = activeBrowseRootPath ? normalizeDirectoryPath(activeBrowseRootPath) : null;
+    if (normalizedRoot && snapshot.directoryStateByPath[normalizedRoot]?.loaded) {
+      return;
+    }
+    const sequence = ++browseSequence;
+    setSnapshot({
+      browseError: null,
+      isBrowseLoading: true
+    });
+    try {
+      if (input.fileAdapter.loadReferenceTree) {
+        const treeSnapshot = await input.fileAdapter.loadReferenceTree({
+          path: activeBrowseRootPath ?? void 0,
+          prefetchBudgetMs: 500,
+          prefetchDepth: 4,
+          workspaceId: input.workspaceId
+        });
+        if (!retained || sequence !== browseSequence) {
+          return;
+        }
+        setSnapshot({
+          browseRootPath: normalizeDirectoryPath(
+            treeSnapshot.directory.directoryPath
+          ),
+          directoryStateByPath: createWorkspaceFileReferenceDirectoryStateFromSnapshot(
+            treeSnapshot
+          ),
+          isBrowseLoading: false
+        });
+        return;
+      }
+      const listing = await loadDirectoryListing(activeBrowseRootPath);
+      if (!retained || sequence !== browseSequence || !listing) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        browseRootPath: listing.normalizedPath,
+        directoryStateByPath: {
+          ...current.directoryStateByPath,
+          [listing.normalizedPath]: {
+            displayPath: listing.displayPath,
+            entries: listing.entries,
+            loaded: true,
+            loading: false
+          }
+        },
+        isBrowseLoading: false
+      }));
+    } catch (error) {
+      if (!retained || sequence !== browseSequence) {
+        return;
+      }
+      setSnapshot({
+        browseError: normalizeControllerError(
+          error,
+          "Workspace file reference browse failed"
+        ),
+        isBrowseLoading: false
+      });
+    }
+  };
+  const loadFolderChildren = async (folder) => {
+    const folderKey = normalizeDirectoryPath(folder.path);
+    if (!retained || snapshot.directoryStateByPath[folderKey]?.loaded || snapshot.directoryStateByPath[folderKey]?.loading) {
+      return;
+    }
+    const sequence = ++browseSequence;
+    setSnapshot((current) => ({
+      ...current,
+      directoryStateByPath: {
+        ...current.directoryStateByPath,
+        [folderKey]: {
+          displayPath: folder.path,
+          entries: current.directoryStateByPath[folderKey]?.entries ?? [],
+          loaded: current.directoryStateByPath[folderKey]?.loaded ?? false,
+          loading: true
+        }
+      }
+    }));
+    try {
+      const listing = await loadDirectoryListing(folderKey);
+      if (!retained || sequence !== browseSequence || !listing) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        directoryStateByPath: {
+          ...current.directoryStateByPath,
+          [folderKey]: {
+            displayPath: listing.displayPath,
+            entries: listing.entries,
+            loaded: true,
+            loading: false
+          }
+        }
+      }));
+    } catch {
+      if (!retained || sequence !== browseSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        directoryStateByPath: {
+          ...current.directoryStateByPath,
+          [folderKey]: {
+            displayPath: current.directoryStateByPath[folderKey]?.displayPath ?? folder.path,
+            entries: current.directoryStateByPath[folderKey]?.entries ?? [],
+            loaded: current.directoryStateByPath[folderKey]?.loaded ?? false,
+            loading: false
+          }
+        }
+      }));
+    }
+  };
+  const loadReferencePreview = async (reference, target, sequence) => {
+    try {
+      const preview = await input.fileAdapter?.readReferencePreview?.({
+        reference,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== previewSequence) {
+        return;
+      }
+      if (!preview) {
+        setSnapshot({
+          previewState: { reference, status: "unsupported" }
+        });
+        return;
+      }
+      const nextState = createReferencePreviewState(reference, target, preview);
+      if (!retained || sequence !== previewSequence) {
+        if (nextState.status === "image") {
+          URL.revokeObjectURL(nextState.objectUrl);
+        }
+        return;
+      }
+      if (nextState.status === "image") {
+        previewObjectUrl = nextState.objectUrl;
+      }
+      setSnapshot({
+        previewState: nextState
+      });
+    } catch {
+      if (!retained || sequence !== previewSequence) {
+        return;
+      }
+      setSnapshot({
+        previewState: { reference, status: "error" }
+      });
+    }
+  };
+  const setPreviewReference = (reference) => {
+    cancelCurrentPreview();
+    if (!retained || !reference) {
+      setSnapshot({
+        previewState: { status: "empty" }
+      });
+      return;
+    }
+    const readiness = resolveWorkspaceFilePreviewReadiness(reference);
+    if (readiness.status === "directory") {
+      setSnapshot({
+        previewState: { reference, status: "directory" }
+      });
+      return;
+    }
+    if (readiness.status === "unsupported") {
+      setSnapshot({
+        previewState: { reference, status: "unsupported" }
+      });
+      return;
+    }
+    if (readiness.status === "readonly") {
+      setSnapshot({
+        previewState: {
+          maxSizeBytes: readiness.maxSizeBytes,
+          reason: readiness.reason,
+          reference,
+          status: "readonly"
+        }
+      });
+      return;
+    }
+    if (!input.fileAdapter?.readReferencePreview) {
+      setSnapshot({
+        previewState: { reference, status: "unavailable" }
+      });
+      return;
+    }
+    const sequence = ++previewSequence;
+    setSnapshot({
+      previewState: { reference, status: "loading" }
+    });
+    void loadReferencePreview(reference, readiness.target, sequence);
+  };
+  return {
+    close() {
+      retained = false;
+      cancelCurrentBrowse();
+      cancelCurrentPreview();
+      cancelCurrentSearch();
+      setSnapshot({
+        isBrowseLoading: false,
+        isSearchLoading: false,
+        previewState: { status: "empty" }
+      });
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    loadBrowseRoot() {
+      void loadBrowseRoot();
+    },
+    open() {
+      if (retained) {
+        return;
+      }
+      retained = true;
+      if (snapshot.mode === "search") {
+        scheduleSearch();
+        return;
+      }
+      void loadBrowseRoot();
+    },
+    async revealInitialPath(initialDirectoryPath) {
+      if (!retained || snapshot.mode !== "browse" || snapshot.initialPathRevealed || !snapshot.browseRootPath) {
+        return null;
+      }
+      const rootPath = normalizeDirectoryPath(snapshot.browseRootPath);
+      if (!isPathInsideOrEqual(initialDirectoryPath, rootPath)) {
+        setSnapshot({
+          initialPathRevealed: true
+        });
+        return null;
+      }
+      const sequence = ++browseSequence;
+      const loadedDirectories = {};
+      const expandedDirectories = {};
+      const directoryState = (path) => loadedDirectories[path] ?? snapshot.directoryStateByPath[path];
+      const directoryPaths = directoryChainBetween(
+        rootPath,
+        initialDirectoryPath
+      );
+      for (const directoryPath of directoryPaths) {
+        expandedDirectories[directoryPath] = true;
+      }
+      const listings = await Promise.all(
+        directoryPaths.filter((directoryPath) => !directoryState(directoryPath)?.loaded).map(async (directoryPath) => {
+          try {
+            return await loadDirectoryListing(directoryPath);
+          } catch {
+            return null;
+          }
+        })
+      );
+      for (const listing of listings) {
+        if (!listing) {
+          continue;
+        }
+        loadedDirectories[listing.normalizedPath] = {
+          displayPath: listing.displayPath,
+          entries: listing.entries,
+          loaded: true,
+          loading: false
+        };
+      }
+      if (!retained || sequence !== browseSequence) {
+        return null;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        directoryStateByPath: {
+          ...current.directoryStateByPath,
+          ...loadedDirectories
+        },
+        expandedFolderPaths: {
+          ...current.expandedFolderPaths,
+          ...expandedDirectories
+        },
+        initialPathRevealed: true
+      }));
+      return initialDirectoryPath;
+    },
+    reset() {
+      cancelCurrentBrowse();
+      cancelCurrentPreview();
+      cancelCurrentSearch();
+      setSnapshot({
+        browseError: null,
+        browseRootPath: null,
+        directoryStateByPath: {},
+        expandedFolderPaths: {},
+        initialPathRevealed: false,
+        isBrowseLoading: false,
+        isSearchLoading: false,
+        mode: "browse",
+        previewState: { status: "empty" },
+        searchEntries: [],
+        searchError: null,
+        searchQuery: ""
+      });
+    },
+    setPreviewReference(reference) {
+      setPreviewReference(reference);
+    },
+    setSearchQuery(query) {
+      if (query === snapshot.searchQuery) {
+        return;
+      }
+      const nextMode = resolveMode(query);
+      setSnapshot({
+        mode: nextMode,
+        searchQuery: query,
+        ...nextMode === "browse" ? { isSearchLoading: false } : {}
+      });
+      if (nextMode === "search") {
+        cancelCurrentBrowse();
+        scheduleSearch();
+        return;
+      }
+      clearSearchResults();
+      void loadBrowseRoot();
+    },
+    get store() {
+      return store;
+    },
+    toggleFolder(entry) {
+      const folderKey = normalizeDirectoryPath(entry.path);
+      const childState = snapshot.directoryStateByPath[folderKey];
+      const nextExpanded = !(snapshot.expandedFolderPaths[folderKey] ?? false);
+      setSnapshot((current) => ({
+        ...current,
+        expandedFolderPaths: {
+          ...current.expandedFolderPaths,
+          [folderKey]: nextExpanded
+        }
+      }));
+      if (nextExpanded && !childState?.loaded && !childState?.loading) {
+        void loadFolderChildren(entry);
+      }
+    }
+  };
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function normalizeControllerError(error, fallbackMessage) {
+  return error instanceof Error ? error : new Error(fallbackMessage);
+}
+function createReferencePreviewState(reference, target, preview) {
+  const loadedState = createWorkspaceFilePreviewLoadedState({
+    bytes: preview.bytes,
+    contentType: preview.contentType,
+    entry: reference,
+    target: {
+      ...target,
+      fileKind: preview.kind
+    }
+  });
+  if (loadedState.status === "image") {
+    return {
+      objectUrl: URL.createObjectURL(
+        new Blob([loadedState.bytes], {
+          type: loadedState.contentType
+        })
+      ),
+      reference,
+      status: "image"
+    };
+  }
+  if (loadedState.status === "text") {
+    return {
+      content: loadedState.content,
+      reference,
+      status: "text"
+    };
+  }
+  return {
+    maxSizeBytes: loadedState.maxSizeBytes,
+    reason: loadedState.reason,
+    reference,
+    status: "readonly"
+  };
+}
+function isPathInsideOrEqual(path, root) {
+  const normalizedPath = normalizeDirectoryPath(path);
+  const normalizedRoot = normalizeDirectoryPath(root);
+  if (normalizedRoot === "/") {
+    return normalizedPath.startsWith("/");
+  }
+  return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+function directoryChainBetween(root, target) {
+  const normalizedRoot = normalizeDirectoryPath(root);
+  let current = normalizeDirectoryPath(target);
+  const chain = [];
+  while (current && current !== normalizedRoot) {
+    chain.unshift(current);
+    const parent = dirnameDirectoryPath(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return chain;
+}
+function dirnameDirectoryPath(path) {
+  const normalized = normalizeDirectoryPath(path);
+  if (normalized === "/") {
+    return "/";
+  }
+  const index = normalized.lastIndexOf("/");
+  if (index <= 0) {
+    return "/";
+  }
+  return normalized.slice(0, index);
+}
+
+// src/react/internal/reference/useWorkspaceFileReferencePickerView.ts
+function useWorkspaceFileReferencePickerView({
+  fileAdapter,
+  initialPath,
+  onClose,
+  onConfirm,
+  open,
+  workspaceId
+}) {
+  const readPickerSnapshot = useSnapshot;
+  const trimmedInitialPath = initialPath?.trim() ?? "";
+  const initialDirectoryPath = trimmedInitialPath ? normalizeDirectoryPath(trimmedInitialPath) : null;
+  const [focusedPath, setFocusedPath] = useState(null);
+  const [selectedRefs, setSelectedRefs] = useState(
+    []
+  );
+  const pickerController = useMemo(
+    () => createWorkspaceFileReferencePickerController({
+      fileAdapter,
+      workspaceId
+    }),
+    [fileAdapter, workspaceId]
+  );
+  const pickerSnapshot = readPickerSnapshot(pickerController.store);
+  const {
+    browseRootPath,
+    directoryStateByPath,
+    expandedFolderPaths,
+    isBrowseLoading,
+    isSearchLoading,
+    mode,
+    previewState,
+    searchEntries,
+    searchQuery
+  } = pickerSnapshot;
+  const isLoading = mode === "search" ? isSearchLoading : isBrowseLoading;
+  const finalizeRequestedReferences = useEffectEvent(
+    (refs) => {
+      onConfirm(uniqueWorkspaceFileReferences(refs));
+      onClose();
+    }
+  );
+  const setSearchQuery = useCallback(
+    (query) => {
+      pickerController.setSearchQuery(query);
+    },
+    [pickerController]
+  );
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    pickerController.reset();
+    pickerController.open();
+    setFocusedPath(null);
+    setSelectedRefs([]);
+    return () => {
+      pickerController.close();
+    };
+  }, [initialDirectoryPath, open, pickerController]);
+  useEffect(() => {
+    if (!open || mode !== "browse") {
+      return;
+    }
+    pickerController.loadBrowseRoot();
+  }, [mode, open, pickerController]);
+  useEffect(() => {
+    if (!open || !fileAdapter || mode !== "browse") {
+      return;
+    }
+    if (fileAdapter.listDirectory || fileAdapter.loadReferenceTree || !fileAdapter.requestReferences) {
+      return;
+    }
+    let canceled = false;
+    void fileAdapter.requestReferences({ workspaceId }).then((refs) => {
+      if (!canceled) {
+        finalizeRequestedReferences(refs);
+      }
+    });
+    return () => {
+      canceled = true;
+    };
+  }, [fileAdapter, finalizeRequestedReferences, mode, open, workspaceId]);
+  useEffect(() => {
+    if (!open || mode !== "browse" || pickerSnapshot.initialPathRevealed || !initialDirectoryPath || !browseRootPath) {
+      return;
+    }
+    let canceled = false;
+    const reveal = async () => {
+      const focusedInitialPath = await pickerController.revealInitialPath(initialDirectoryPath);
+      if (!canceled && focusedInitialPath) {
+        setFocusedPath(focusedInitialPath);
+      }
+    };
+    void reveal();
+    return () => {
+      canceled = true;
+    };
+  }, [
+    browseRootPath,
+    initialDirectoryPath,
+    mode,
+    open,
+    pickerController,
+    pickerSnapshot.initialPathRevealed
+  ]);
+  const browseRootEntries = useMemo(
+    () => browseRootPath ? directoryStateByPath[normalizeDirectoryPath(browseRootPath)]?.entries ?? [] : [],
+    [browseRootPath, directoryStateByPath]
+  );
+  const visibleEntries = useMemo(
+    () => mode === "search" ? searchEntries : collectVisibleTreeEntries(
+      browseRootEntries,
+      directoryStateByPath,
+      expandedFolderPaths
+    ),
+    [
+      browseRootEntries,
+      directoryStateByPath,
+      expandedFolderPaths,
+      mode,
+      searchEntries
+    ]
+  );
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    setFocusedPath((current) => {
+      if (current && visibleEntries.some((entry) => entry.path === current)) {
+        return current;
+      }
+      return visibleEntries[0]?.path ?? null;
+    });
+  }, [open, visibleEntries]);
+  const focusedEntry = visibleEntries.find((entry) => entry.path === focusedPath) ?? selectedRefs.find((entry) => entry.path === focusedPath) ?? null;
+  useEffect(() => {
+    pickerController.setPreviewReference(open ? focusedEntry : null);
+  }, [focusedEntry, open, pickerController]);
+  const toggleRef = (ref) => {
+    setSelectedRefs((current) => {
+      const existing = current.some((item) => item.path === ref.path);
+      return existing ? current.filter((item) => item.path !== ref.path) : uniqueWorkspaceFileReferences([...current, ref]);
+    });
+  };
+  const toggleFolder = (entry) => {
+    pickerController.toggleFolder(entry);
+  };
+  return {
+    browseRootEntries,
+    directoryStateByPath,
+    expandedFolderPaths,
+    focusedEntry,
+    focusedPath,
+    isLoading,
+    mode,
+    previewState,
+    searchQuery,
+    selectedRefs,
+    visibleEntries,
+    setFocusedPath,
+    setSearchQuery,
+    toggleFolder,
+    toggleRef
+  };
+}
+
+export {
+  workspaceFileReferenceDefaultExpandedDepth,
+  normalizeDirectoryPath,
+  collectVisibleTreeEntries,
+  mergeExpandedFolderPaths,
+  mergePrefetchedDirectoryState,
+  createWorkspaceFileReferenceDirectoryStateFromSnapshot,
+  prefetchReferenceTree,
+  useWorkspaceFileReferencePickerView
+};
+//# sourceMappingURL=chunk-LS7P3J6Z.js.map