momoi-explorer 0.8.0

package/dist/react.cjs

@@ -0,0 +1,850 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  TreeContext: () => TreeContext,
+  TreeProvider: () => TreeProvider,
+  useContextMenu: () => useContextMenu,
+  useExplorerFocus: () => useExplorerFocus,
+  useExplorerKeybindings: () => useExplorerKeybindings,
+  useFileTree: () => useFileTree,
+  useTreeContext: () => useTreeContext,
+  useTreeNode: () => useTreeNode
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/TreeProvider.tsx
+var import_react2 = require("react");
+
+// src/core/event-processor.ts
+var DEFAULT_DEBOUNCE_MS = 75;
+var DEFAULT_THROTTLE_CHUNK_SIZE = 500;
+var DEFAULT_THROTTLE_DELAY_MS = 200;
+function coalesceEvents(raw) {
+  const expanded = [];
+  for (const event of raw) {
+    if (event.type === "rename" && event.newPath) {
+      expanded.push({ type: "delete", path: event.path, isDirectory: event.isDirectory });
+      expanded.push({ type: "create", path: event.newPath, isDirectory: event.isDirectory });
+    } else {
+      expanded.push({ type: event.type, path: event.path, isDirectory: event.isDirectory });
+    }
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const event of expanded) {
+    const existing = byPath.get(event.path);
+    if (!existing) {
+      byPath.set(event.path, event);
+      continue;
+    }
+    if (existing.type === "delete" && event.type === "create") {
+      byPath.set(event.path, { type: "modify", path: event.path, isDirectory: event.isDirectory });
+      continue;
+    }
+    if (existing.type === "create" && event.type === "modify") {
+      continue;
+    }
+    if (existing.type === "create" && event.type === "delete") {
+      byPath.delete(event.path);
+      continue;
+    }
+    byPath.set(event.path, event);
+  }
+  const result = Array.from(byPath.values());
+  const deletedDirs = /* @__PURE__ */ new Set();
+  for (const event of result) {
+    if (event.type === "delete" && event.isDirectory) {
+      deletedDirs.add(event.path);
+    }
+  }
+  if (deletedDirs.size === 0) return result;
+  return result.filter((event) => {
+    if (event.type !== "delete") return true;
+    for (const dir of deletedDirs) {
+      if (event.path !== dir && event.path.startsWith(dir + "/")) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function createEventProcessor(callback, options = {}) {
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const shouldCoalesce = options.coalesce ?? true;
+  const throttleChunkSize = options.throttle?.maxChunkSize ?? DEFAULT_THROTTLE_CHUNK_SIZE;
+  const throttleDelayMs = options.throttle?.delayMs ?? DEFAULT_THROTTLE_DELAY_MS;
+  let buffer = [];
+  let debounceTimer = null;
+  let throttleTimer = null;
+  let destroyed = false;
+  function processBuffer() {
+    if (destroyed || buffer.length === 0) return;
+    const raw = buffer;
+    buffer = [];
+    const events = shouldCoalesce ? coalesceEvents(raw) : raw.map((e) => ({
+      type: e.type === "rename" ? "modify" : e.type,
+      path: e.type === "rename" && e.newPath ? e.newPath : e.path,
+      isDirectory: e.isDirectory
+    }));
+    if (events.length === 0) return;
+    if (events.length <= throttleChunkSize) {
+      callback(events);
+      return;
+    }
+    let offset = 0;
+    function emitChunk() {
+      if (destroyed || offset >= events.length) return;
+      const chunk = events.slice(offset, offset + throttleChunkSize);
+      offset += throttleChunkSize;
+      callback(chunk);
+      if (offset < events.length) {
+        throttleTimer = setTimeout(emitChunk, throttleDelayMs);
+      }
+    }
+    emitChunk();
+  }
+  return {
+    push(events) {
+      if (destroyed) return;
+      buffer.push(...events);
+      if (debounceTimer !== null) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(processBuffer, debounceMs);
+    },
+    flush() {
+      if (debounceTimer !== null) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      processBuffer();
+    },
+    destroy() {
+      destroyed = true;
+      if (debounceTimer !== null) clearTimeout(debounceTimer);
+      if (throttleTimer !== null) clearTimeout(throttleTimer);
+      buffer = [];
+    }
+  };
+}
+
+// src/core/flatten.ts
+function flattenTree(nodes, expandedPaths, matchingPaths) {
+  const result = [];
+  function walk(children, depth) {
+    for (const node of children) {
+      if (matchingPaths && !matchingPaths.has(node.path)) continue;
+      result.push({ node, depth });
+      if (node.isDirectory && node.children) {
+        if (matchingPaths || expandedPaths.has(node.path)) {
+          walk(node.children, depth + 1);
+        }
+      }
+    }
+  }
+  walk(nodes, 0);
+  return result;
+}
+
+// src/core/selection.ts
+function computeSelection(currentSelected, anchorPath, targetPath, mode, flatList) {
+  switch (mode) {
+    case "replace":
+      return {
+        selectedPaths: /* @__PURE__ */ new Set([targetPath]),
+        anchorPath: targetPath
+      };
+    case "toggle": {
+      const next = new Set(currentSelected);
+      if (next.has(targetPath)) {
+        next.delete(targetPath);
+      } else {
+        next.add(targetPath);
+      }
+      return {
+        selectedPaths: next,
+        anchorPath: targetPath
+      };
+    }
+    case "range": {
+      if (!anchorPath) {
+        return {
+          selectedPaths: /* @__PURE__ */ new Set([targetPath]),
+          anchorPath: targetPath
+        };
+      }
+      const paths = flatList.map((f) => f.node.path);
+      const anchorIdx = paths.indexOf(anchorPath);
+      const targetIdx = paths.indexOf(targetPath);
+      if (anchorIdx === -1 || targetIdx === -1) {
+        return {
+          selectedPaths: /* @__PURE__ */ new Set([targetPath]),
+          anchorPath: targetPath
+        };
+      }
+      const start = Math.min(anchorIdx, targetIdx);
+      const end = Math.max(anchorIdx, targetIdx);
+      const rangePaths = new Set(paths.slice(start, end + 1));
+      return {
+        selectedPaths: rangePaths,
+        anchorPath
+        // range選択ではanchorは変えない
+      };
+    }
+  }
+}
+
+// src/core/sort.ts
+function defaultSort(a, b) {
+  if (a.isDirectory !== b.isDirectory) {
+    return a.isDirectory ? -1 : 1;
+  }
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+
+// src/core/filter.ts
+function defaultFilter(_entry) {
+  return true;
+}
+
+// src/core/search.ts
+function fuzzyMatch(query, target) {
+  const q = query.toLowerCase();
+  const t = target.toLowerCase();
+  if (q.length === 0) return { match: true, score: 0 };
+  if (q.length > t.length) return { match: false, score: 0 };
+  if (t === q) return { match: true, score: 100 };
+  if (t.startsWith(q)) return { match: true, score: 90 };
+  if (t.includes(q)) return { match: true, score: 80 };
+  let qi = 0;
+  let score = 0;
+  let lastMatchIndex = -2;
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t[ti] === q[qi]) {
+      qi++;
+      if (ti === lastMatchIndex + 1) {
+        score += 5;
+      }
+      if (ti === 0 || "/\\-_.".includes(t[ti - 1])) {
+        score += 10;
+      }
+      score += 1;
+      lastMatchIndex = ti;
+    }
+  }
+  if (qi < q.length) return { match: false, score: 0 };
+  return { match: true, score };
+}
+function findMatchingPaths(nodes, query) {
+  const matching = /* @__PURE__ */ new Set();
+  function walk(node, ancestors) {
+    const nameMatch = fuzzyMatch(query, node.name).match;
+    let childMatch = false;
+    if (node.children) {
+      for (const child of node.children) {
+        if (walk(child, [...ancestors, node.path])) {
+          childMatch = true;
+        }
+      }
+    }
+    if (nameMatch || childMatch) {
+      matching.add(node.path);
+      for (const a of ancestors) {
+        matching.add(a);
+      }
+      return true;
+    }
+    return false;
+  }
+  for (const node of nodes) {
+    walk(node, []);
+  }
+  return matching;
+}
+
+// src/core/tree.ts
+function toTreeNode(entry, depth) {
+  return {
+    ...entry,
+    depth,
+    children: entry.isDirectory ? void 0 : void 0,
+    childrenLoaded: false
+  };
+}
+function findNode(nodes, path) {
+  for (const node of nodes) {
+    if (node.path === path) return node;
+    if (node.children) {
+      const found = findNode(node.children, path);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function dirname(path) {
+  const sep = path.includes("\\") ? "\\" : "/";
+  const idx = path.lastIndexOf(sep);
+  return idx === -1 ? "" : path.slice(0, idx);
+}
+function createFileTree(options) {
+  const { adapter, rootPath, onEvent } = options;
+  let sortFn = options.sort ?? defaultSort;
+  let filterFn = options.filter ?? defaultFilter;
+  let state = {
+    rootPath,
+    rootNodes: [],
+    expandedPaths: /* @__PURE__ */ new Set(),
+    selectedPaths: /* @__PURE__ */ new Set(),
+    anchorPath: null,
+    renamingPath: null,
+    creatingState: null,
+    searchQuery: null,
+    flatList: []
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let expandingPaths = /* @__PURE__ */ new Set();
+  function emit(event) {
+    onEvent?.(event);
+  }
+  function notify() {
+    const matchingPaths = state.searchQuery ? findMatchingPaths(state.rootNodes, state.searchQuery) : null;
+    state = { ...state, flatList: flattenTree(state.rootNodes, state.expandedPaths, matchingPaths) };
+    for (const listener of listeners) {
+      listener(state);
+    }
+  }
+  async function loadChildren(node) {
+    const entries = await adapter.readDir(node.path);
+    const filtered = entries.filter(filterFn);
+    filtered.sort(sortFn);
+    const oldChildMap = node.children ? new Map(node.children.map((c) => [c.path, c])) : /* @__PURE__ */ new Map();
+    node.children = filtered.map((e) => {
+      const existing = oldChildMap.get(e.path);
+      if (existing && existing.childrenLoaded) {
+        return { ...toTreeNode(e, node.depth + 1), children: existing.children, childrenLoaded: true };
+      }
+      return toTreeNode(e, node.depth + 1);
+    });
+    node.childrenLoaded = true;
+  }
+  async function refreshParent(parentPath) {
+    const parentNode = findNode(state.rootNodes, parentPath);
+    if (parentNode) {
+      await loadChildren(parentNode);
+      state.expandedPaths = new Set(state.expandedPaths);
+      state.expandedPaths.add(parentPath);
+    } else if (parentPath === rootPath) {
+      const entries = await adapter.readDir(rootPath);
+      const filtered = entries.filter(filterFn);
+      filtered.sort(sortFn);
+      const oldNodeMap = new Map(state.rootNodes.map((n) => [n.path, n]));
+      state.rootNodes = filtered.map((e) => {
+        const existing = oldNodeMap.get(e.path);
+        if (existing && existing.childrenLoaded) {
+          return { ...toTreeNode(e, 0), children: existing.children, childrenLoaded: true };
+        }
+        return toTreeNode(e, 0);
+      });
+    }
+  }
+  function sortNodes(nodes) {
+    nodes.sort(sortFn);
+    for (const node of nodes) {
+      if (node.children) {
+        sortNodes(node.children);
+      }
+    }
+  }
+  function filterNodes(nodes) {
+    return nodes.filter((node) => {
+      if (!filterFn(node)) return false;
+      if (node.children) {
+        node.children = filterNodes(node.children);
+      }
+      return true;
+    });
+  }
+  let unwatchFn = null;
+  let eventProcessor = null;
+  function handleWatchEvents(events) {
+    emit({ type: "external-change", changes: events });
+    const dirsToRefresh = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      const parent = dirname(event.path);
+      if (parent === rootPath || state.expandedPaths.has(parent)) {
+        dirsToRefresh.add(parent);
+      }
+      if (event.isDirectory && state.expandedPaths.has(event.path)) {
+        dirsToRefresh.add(event.path);
+      }
+    }
+    for (const dir of dirsToRefresh) {
+      refreshParent(dir).then(() => notify()).catch(() => {
+      });
+    }
+  }
+  function startWatching() {
+    if (!adapter.watch) return;
+    eventProcessor = createEventProcessor(handleWatchEvents, options.watchOptions);
+    unwatchFn = adapter.watch(rootPath, (events) => {
+      eventProcessor.push(events);
+    });
+  }
+  function stopWatching() {
+    if (unwatchFn) {
+      unwatchFn();
+      unwatchFn = null;
+    }
+    if (eventProcessor) {
+      eventProcessor.destroy();
+      eventProcessor = null;
+    }
+  }
+  const controller = {
+    getState() {
+      return state;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async loadRoot() {
+      const entries = await adapter.readDir(rootPath);
+      const filtered = entries.filter(filterFn);
+      filtered.sort(sortFn);
+      state.rootNodes = filtered.map((e) => toTreeNode(e, 0));
+      notify();
+      startWatching();
+    },
+    async expand(path) {
+      if (expandingPaths.has(path)) return;
+      expandingPaths.add(path);
+      try {
+        const node = findNode(state.rootNodes, path);
+        if (!node || !node.isDirectory) return;
+        if (!node.childrenLoaded) {
+          await loadChildren(node);
+        }
+        state.expandedPaths = new Set(state.expandedPaths);
+        state.expandedPaths.add(path);
+        notify();
+        emit({ type: "expand", path });
+      } finally {
+        expandingPaths.delete(path);
+      }
+    },
+    collapse(path) {
+      const sep = path.includes("\\") ? "\\" : "/";
+      const prefix = path + sep;
+      state.expandedPaths = new Set(state.expandedPaths);
+      state.expandedPaths.delete(path);
+      for (const p of state.expandedPaths) {
+        if (p.startsWith(prefix)) {
+          state.expandedPaths.delete(p);
+        }
+      }
+      notify();
+      emit({ type: "collapse", path });
+    },
+    async toggleExpand(path) {
+      if (expandingPaths.has(path)) return;
+      if (state.expandedPaths.has(path)) {
+        controller.collapse(path);
+      } else {
+        await controller.expand(path);
+      }
+    },
+    async expandTo(path) {
+      const parts = [];
+      let current = path;
+      while (current !== rootPath && current !== "") {
+        const parent = dirname(current);
+        if (parent === current) break;
+        parts.unshift(parent);
+        current = parent;
+      }
+      for (const ancestorPath of parts) {
+        if (ancestorPath === rootPath) continue;
+        if (!state.expandedPaths.has(ancestorPath)) {
+          await controller.expand(ancestorPath);
+        }
+      }
+    },
+    select(path, mode = "replace") {
+      const result = computeSelection(
+        state.selectedPaths,
+        state.anchorPath,
+        path,
+        mode,
+        state.flatList
+      );
+      state.selectedPaths = result.selectedPaths;
+      state.anchorPath = result.anchorPath;
+      notify();
+      emit({ type: "select", paths: Array.from(result.selectedPaths) });
+    },
+    selectAll() {
+      state.selectedPaths = new Set(state.flatList.map((f) => f.node.path));
+      notify();
+      emit({ type: "select", paths: Array.from(state.selectedPaths) });
+    },
+    clearSelection() {
+      state.selectedPaths = /* @__PURE__ */ new Set();
+      state.anchorPath = null;
+      notify();
+      emit({ type: "select", paths: [] });
+    },
+    startRename(path) {
+      state.renamingPath = path;
+      notify();
+    },
+    async commitRename(newName) {
+      if (!state.renamingPath || !adapter.rename) return;
+      const oldPath = state.renamingPath;
+      const parent = dirname(oldPath);
+      const sep = oldPath.includes("\\") ? "\\" : "/";
+      const newPath = parent + sep + newName;
+      await adapter.rename(oldPath, newPath);
+      state.renamingPath = null;
+      if (parent === rootPath) {
+        await controller.loadRoot();
+      } else {
+        const parentNode = findNode(state.rootNodes, parent);
+        if (parentNode) {
+          await loadChildren(parentNode);
+        }
+      }
+      notify();
+      emit({ type: "rename", oldPath, newPath });
+    },
+    cancelRename() {
+      state.renamingPath = null;
+      notify();
+    },
+    async startCreate(parentPath, isDirectory, insertAfterPath) {
+      if (parentPath !== rootPath && !state.expandedPaths.has(parentPath)) {
+        await controller.expand(parentPath);
+      }
+      state.creatingState = { parentPath, isDirectory, insertAfterPath };
+      notify();
+    },
+    async commitCreate(name) {
+      if (!state.creatingState) return;
+      const { parentPath, isDirectory } = state.creatingState;
+      state.creatingState = null;
+      if (isDirectory) {
+        await controller.createDir(parentPath, name);
+      } else {
+        await controller.createFile(parentPath, name);
+      }
+    },
+    cancelCreate() {
+      state.creatingState = null;
+      notify();
+    },
+    async createFile(parentPath, name) {
+      if (!adapter.createFile) return;
+      await adapter.createFile(parentPath, name);
+      await refreshParent(parentPath);
+      notify();
+      emit({ type: "create", parentPath, name, isDirectory: false });
+    },
+    async createDir(parentPath, name) {
+      if (!adapter.createDir) return;
+      await adapter.createDir(parentPath, name);
+      await refreshParent(parentPath);
+      notify();
+      emit({ type: "create", parentPath, name, isDirectory: true });
+    },
+    async deleteSelected() {
+      if (!adapter.delete || state.selectedPaths.size === 0) return;
+      const paths = Array.from(state.selectedPaths);
+      await adapter.delete(paths);
+      state.selectedPaths = /* @__PURE__ */ new Set();
+      state.anchorPath = null;
+      const parentDirs = new Set(paths.map(dirname));
+      for (const dir of parentDirs) {
+        await refreshParent(dir);
+      }
+      notify();
+      emit({ type: "delete", paths });
+    },
+    async refresh(path) {
+      if (!path || path === rootPath) {
+        await refreshParent(rootPath);
+      } else {
+        const node = findNode(state.rootNodes, path);
+        if (node && node.isDirectory) {
+          await loadChildren(node);
+        }
+      }
+      notify();
+      emit({ type: "refresh", path });
+    },
+    setSearchQuery(query) {
+      state.searchQuery = query && query.trim() ? query.trim() : null;
+      notify();
+    },
+    async collectAllFiles() {
+      const result = [];
+      async function walk(dirPath) {
+        const entries = await adapter.readDir(dirPath);
+        for (const entry of entries) {
+          if (!filterFn(entry)) continue;
+          result.push(entry);
+          if (entry.isDirectory) {
+            await walk(entry.path);
+          }
+        }
+      }
+      await walk(rootPath);
+      return result;
+    },
+    setFilter(fn) {
+      filterFn = fn ?? defaultFilter;
+      state.rootNodes = filterNodes(state.rootNodes);
+      notify();
+    },
+    setSort(fn) {
+      sortFn = fn ?? defaultSort;
+      sortNodes(state.rootNodes);
+      notify();
+    },
+    destroy() {
+      stopWatching();
+      listeners.clear();
+    }
+  };
+  return controller;
+}
+
+// src/react/context.ts
+var import_react = require("react");
+var TreeContext = (0, import_react.createContext)(null);
+function useTreeContext() {
+  const ctx = (0, import_react.useContext)(TreeContext);
+  if (!ctx) {
+    throw new Error("useTreeContext must be used within a <TreeProvider>");
+  }
+  return ctx;
+}
+
+// src/react/TreeProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function TreeProvider({
+  adapter,
+  rootPath,
+  sort,
+  filter,
+  watchOptions,
+  onEvent,
+  children
+}) {
+  const onEventRef = (0, import_react2.useRef)(onEvent);
+  onEventRef.current = onEvent;
+  const controller = (0, import_react2.useMemo)(() => {
+    return createFileTree({
+      adapter,
+      rootPath,
+      sort,
+      filter,
+      watchOptions,
+      onEvent: (event) => onEventRef.current?.(event)
+    });
+  }, [adapter, rootPath]);
+  const [state, setState] = (0, import_react2.useState)(() => controller.getState());
+  (0, import_react2.useEffect)(() => {
+    const unsub = controller.subscribe(setState);
+    controller.loadRoot();
+    return () => {
+      unsub();
+      controller.destroy();
+    };
+  }, [controller]);
+  const value = (0, import_react2.useMemo)(() => ({ controller, state }), [controller, state]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TreeContext.Provider, { value, children });
+}
+
+// src/react/useFileTree.ts
+function useFileTree() {
+  const { controller, state } = useTreeContext();
+  return { ...state, controller };
+}
+
+// src/react/useTreeNode.ts
+var import_react3 = require("react");
+function useTreeNode(path) {
+  const { state } = useTreeContext();
+  return (0, import_react3.useMemo)(() => {
+    const flatItem = state.flatList.find((f) => f.node.path === path);
+    if (!flatItem) return null;
+    return {
+      node: flatItem.node,
+      isExpanded: state.expandedPaths.has(path),
+      isSelected: state.selectedPaths.has(path),
+      isRenaming: state.renamingPath === path,
+      depth: flatItem.depth
+    };
+  }, [state, path]);
+}
+
+// src/react/useContextMenu.ts
+var import_react4 = require("react");
+function useContextMenu() {
+  const [menuState, setMenuState] = (0, import_react4.useState)({
+    isVisible: false,
+    x: 0,
+    y: 0,
+    targetPath: null
+  });
+  const show = (0, import_react4.useCallback)((e, targetPath) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setMenuState({
+      isVisible: true,
+      x: e.clientX,
+      y: e.clientY,
+      targetPath
+    });
+  }, []);
+  const hide = (0, import_react4.useCallback)(() => {
+    setMenuState((prev) => ({ ...prev, isVisible: false, targetPath: null }));
+  }, []);
+  return { ...menuState, show, hide };
+}
+
+// src/react/useExplorerKeybindings.ts
+var import_react5 = require("react");
+
+// src/core/keybindings.ts
+var ExplorerCommands = {
+  DELETE: "explorer.delete",
+  RENAME: "explorer.rename",
+  NEW_FILE: "explorer.newFile",
+  NEW_FOLDER: "explorer.newFolder",
+  REFRESH: "explorer.refresh",
+  COLLAPSE_ALL: "explorer.collapseAll",
+  SELECT_ALL: "explorer.selectAll",
+  COPY_PATH: "explorer.copyPath"
+};
+var defaultExplorerKeybindings = [
+  { key: "Delete", command: ExplorerCommands.DELETE, when: "explorerFocus" },
+  { key: "F2", command: ExplorerCommands.RENAME, when: "explorerFocus" },
+  { key: "Ctrl+N", command: ExplorerCommands.NEW_FILE, when: "explorerFocus" },
+  { key: "Ctrl+Shift+N", command: ExplorerCommands.NEW_FOLDER, when: "explorerFocus" },
+  { key: "Ctrl+R", command: ExplorerCommands.REFRESH, when: "explorerFocus" },
+  { key: "Ctrl+Shift+E", command: ExplorerCommands.COLLAPSE_ALL, when: "explorerFocus" },
+  { key: "Ctrl+A", command: ExplorerCommands.SELECT_ALL, when: "explorerFocus" },
+  { key: "Ctrl+Shift+C", command: ExplorerCommands.COPY_PATH, when: "explorerFocus" }
+];
+
+// src/react/useExplorerKeybindings.ts
+function useExplorerKeybindings(inputService, options) {
+  const { controller, state } = useTreeContext();
+  const stateRef = (0, import_react5.useRef)(state);
+  stateRef.current = state;
+  const optionsRef = (0, import_react5.useRef)(options);
+  optionsRef.current = options;
+  const getCreateTarget = (0, import_react5.useCallback)(() => {
+    const s = stateRef.current;
+    if (s.selectedPaths.size === 0) return { parentPath: s.rootPath };
+    const firstSelected = s.flatList.find((f) => s.selectedPaths.has(f.node.path));
+    if (!firstSelected) return { parentPath: s.rootPath };
+    if (firstSelected.node.isDirectory) return { parentPath: firstSelected.node.path };
+    const sep = firstSelected.node.path.includes("\\") ? "\\" : "/";
+    const idx = firstSelected.node.path.lastIndexOf(sep);
+    const parentPath = idx === -1 ? s.rootPath : firstSelected.node.path.slice(0, idx);
+    return { parentPath, insertAfterPath: firstSelected.node.path };
+  }, []);
+  (0, import_react5.useEffect)(() => {
+    if (!inputService) return;
+    const disposers = [];
+    const handlers = {
+      [ExplorerCommands.DELETE]: () => controller.deleteSelected(),
+      [ExplorerCommands.RENAME]: () => {
+        const s = stateRef.current;
+        if (s.selectedPaths.size === 1) {
+          controller.startRename(Array.from(s.selectedPaths)[0]);
+        }
+      },
+      [ExplorerCommands.NEW_FILE]: () => {
+        const t = getCreateTarget();
+        controller.startCreate(t.parentPath, false, t.insertAfterPath);
+      },
+      [ExplorerCommands.NEW_FOLDER]: () => {
+        const t = getCreateTarget();
+        controller.startCreate(t.parentPath, true, t.insertAfterPath);
+      },
+      [ExplorerCommands.REFRESH]: () => controller.refresh(),
+      [ExplorerCommands.COLLAPSE_ALL]: () => {
+        const s = stateRef.current;
+        for (const path of s.expandedPaths) {
+          controller.collapse(path);
+        }
+      },
+      [ExplorerCommands.SELECT_ALL]: () => controller.selectAll(),
+      [ExplorerCommands.COPY_PATH]: () => {
+        const s = stateRef.current;
+        const paths = Array.from(s.selectedPaths);
+        optionsRef.current?.onCopyPath?.(paths);
+      }
+    };
+    for (const [command, handler] of Object.entries(handlers)) {
+      disposers.push(inputService.registerCommand(command, handler));
+    }
+    return () => {
+      for (const dispose of disposers) {
+        dispose();
+      }
+    };
+  }, [inputService, controller, getCreateTarget]);
+}
+
+// src/react/useExplorerFocus.ts
+var import_react6 = require("react");
+function useExplorerFocus(inputService, contextKey = "explorerFocus") {
+  const focused = (0, import_react6.useRef)(false);
+  const onFocus = (0, import_react6.useCallback)(() => {
+    if (!focused.current) {
+      focused.current = true;
+      inputService?.setContext(contextKey, true);
+    }
+  }, [inputService, contextKey]);
+  const onBlur = (0, import_react6.useCallback)(() => {
+    if (focused.current) {
+      focused.current = false;
+      inputService?.deleteContext(contextKey);
+    }
+  }, [inputService, contextKey]);
+  return { onFocus, onBlur, tabIndex: 0 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TreeContext,
+  TreeProvider,
+  useContextMenu,
+  useExplorerFocus,
+  useExplorerKeybindings,
+  useFileTree,
+  useTreeContext,
+  useTreeNode
+});
+//# sourceMappingURL=react.cjs.map