momoi-explorer 0.8.0

package/dist/index.cjs

@@ -0,0 +1,690 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ExplorerCommands: () => ExplorerCommands,
+  coalesceEvents: () => coalesceEvents,
+  computeSelection: () => computeSelection,
+  createEventProcessor: () => createEventProcessor,
+  createFileTree: () => createFileTree,
+  defaultExplorerKeybindings: () => defaultExplorerKeybindings,
+  defaultFilter: () => defaultFilter,
+  defaultSort: () => defaultSort,
+  findMatchingPaths: () => findMatchingPaths,
+  flattenTree: () => flattenTree,
+  fuzzyFind: () => fuzzyFind,
+  fuzzyMatch: () => fuzzyMatch
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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;
+}
+function fuzzyFind(files, query, maxResults = 50) {
+  if (!query) return [];
+  const scored = [];
+  for (const entry of files) {
+    const nameResult = fuzzyMatch(query, entry.name);
+    const pathResult = fuzzyMatch(query, entry.path);
+    const bestScore = Math.max(nameResult.score, pathResult.score * 0.5);
+    if (nameResult.match || pathResult.match) {
+      scored.push({ entry, score: bestScore });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, maxResults).map((s) => s.entry);
+}
+
+// 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/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" }
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExplorerCommands,
+  coalesceEvents,
+  computeSelection,
+  createEventProcessor,
+  createFileTree,
+  defaultExplorerKeybindings,
+  defaultFilter,
+  defaultSort,
+  findMatchingPaths,
+  flattenTree,
+  fuzzyFind,
+  fuzzyMatch
+});
+//# sourceMappingURL=index.cjs.map