@huyooo/file-explorer-bridge-electron 0.2.0

package/dist/main/index.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main/index.ts
+var main_exports = {};
+__export(main_exports, {
+  createElectronAdapter: () => createElectronAdapter,
+  electronUrlEncoder: () => electronUrlEncoder,
+  registerFileExplorerHandlers: () => registerFileExplorerHandlers,
+  setClipboardAdapter: () => setClipboardAdapter
+});
+module.exports = __toCommonJS(main_exports);
+var import_electron = require("electron");
+var import_node_path = __toESM(require("path"), 1);
+var import_file_explorer_core = require("@huyooo/file-explorer-core");
+var import_node_fs = require("fs");
+var CHANNEL_PREFIX = "file-explorer";
+var channel = (name) => `${CHANNEL_PREFIX}:${name}`;
+var clipboardAdapter = null;
+function setClipboardAdapter(adapter) {
+  clipboardAdapter = adapter;
+}
+function createElectronAdapter() {
+  return {
+    trashItem: async (filePath) => {
+      await import_electron.shell.trashItem(filePath);
+    },
+    openPath: async (filePath) => {
+      await import_electron.shell.openPath(filePath);
+    }
+  };
+}
+function electronUrlEncoder(filePath) {
+  const encodedPath = encodeURIComponent(filePath);
+  return `app://file${encodedPath}`;
+}
+function registerFileExplorerHandlers() {
+  const adapter = createElectronAdapter();
+  import_electron.ipcMain.handle(channel("readDirectory"), async (_event, dirPath) => {
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    return await (0, import_file_explorer_core.readDirectory)(dirPath, {
+      urlEncoder: electronUrlEncoder,
+      getThumbnailUrl: thumbnailService ? (filePath) => thumbnailService.getThumbnailUrl(filePath) : void 0
+    });
+  });
+  import_electron.ipcMain.handle(channel("readSystemPath"), async (_event, pathId) => {
+    const systemPath = (0, import_file_explorer_core.getSystemPath)(pathId);
+    if (!systemPath) return [];
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    return await (0, import_file_explorer_core.readDirectory)(systemPath, {
+      urlEncoder: electronUrlEncoder,
+      getThumbnailUrl: thumbnailService ? (filePath) => thumbnailService.getThumbnailUrl(filePath) : void 0
+    });
+  });
+  import_electron.ipcMain.handle(channel("getSystemPath"), async (_event, pathId) => {
+    return (0, import_file_explorer_core.getSystemPath)(pathId);
+  });
+  import_electron.ipcMain.handle(channel("readFileContent"), async (_event, filePath) => {
+    return await (0, import_file_explorer_core.readFileContent)(filePath);
+  });
+  import_electron.ipcMain.handle(channel("writeFileContent"), async (_event, filePath, content) => {
+    return await (0, import_file_explorer_core.writeFileContent)(filePath, content);
+  });
+  import_electron.ipcMain.handle(channel("createFolder"), async (_event, parentDir, folderName) => {
+    const folderPath = import_node_path.default.join(parentDir, folderName);
+    return await (0, import_file_explorer_core.createFolder)(folderPath);
+  });
+  import_electron.ipcMain.handle(channel("createFile"), async (_event, parentDir, fileName, content) => {
+    const filePath = import_node_path.default.join(parentDir, fileName);
+    return await (0, import_file_explorer_core.createFile)(filePath, content);
+  });
+  import_electron.ipcMain.handle(channel("deleteFiles"), async (_event, paths) => {
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    return await (0, import_file_explorer_core.deleteFiles)(paths, {
+      adapter,
+      useTrash: true,
+      onDeleted: (p) => thumbnailService?.deleteThumbnail(p)
+    });
+  });
+  import_electron.ipcMain.handle(channel("renameFile"), async (_event, oldPath, newPath) => {
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    return await (0, import_file_explorer_core.renameFile)(oldPath, newPath, {
+      onRenamed: (old) => thumbnailService?.deleteThumbnail(old)
+    });
+  });
+  import_electron.ipcMain.handle(channel("copyFiles"), async (_event, sourcePaths, targetDir) => {
+    return await (0, import_file_explorer_core.copyFiles)(sourcePaths, targetDir);
+  });
+  import_electron.ipcMain.handle(channel("moveFiles"), async (_event, sourcePaths, targetDir) => {
+    return await (0, import_file_explorer_core.moveFiles)(sourcePaths, targetDir);
+  });
+  import_electron.ipcMain.handle(channel("getFileInfo"), async (_event, filePath) => {
+    return await (0, import_file_explorer_core.getFileInfo)(filePath);
+  });
+  import_electron.ipcMain.handle(channel("readImageAsBase64"), async (_event, imagePath) => {
+    return await (0, import_file_explorer_core.readImageAsBase64)(imagePath);
+  });
+  import_electron.ipcMain.handle(channel("openPath"), async (_event, filePath) => {
+    try {
+      await import_electron.shell.openPath(filePath);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  import_electron.ipcMain.handle(channel("getApplicationIcon"), async (_event, appPath) => {
+    return await (0, import_file_explorer_core.getApplicationIcon)(appPath);
+  });
+  import_electron.ipcMain.handle(channel("getThumbnailUrl"), async (_event, filePath) => {
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    if (!thumbnailService) return null;
+    return await thumbnailService.getThumbnailUrl(filePath);
+  });
+  import_electron.ipcMain.handle(channel("copyFilesToClipboard"), async (_event, filePaths) => {
+    if (!clipboardAdapter) {
+      return { success: false, error: "\u526A\u8D34\u677F\u9002\u914D\u5668\u672A\u521D\u59CB\u5316" };
+    }
+    return await (0, import_file_explorer_core.copyFilesToClipboard)(filePaths, clipboardAdapter);
+  });
+  import_electron.ipcMain.handle(channel("getClipboardFiles"), async () => {
+    if (!clipboardAdapter) {
+      return { success: false, error: "\u526A\u8D34\u677F\u9002\u914D\u5668\u672A\u521D\u59CB\u5316" };
+    }
+    return (0, import_file_explorer_core.getClipboardFiles)(clipboardAdapter);
+  });
+  import_electron.ipcMain.handle(channel("pasteFiles"), async (_event, targetDir, sourcePaths) => {
+    return await (0, import_file_explorer_core.pasteFiles)(targetDir, sourcePaths);
+  });
+  import_electron.ipcMain.handle(channel("searchFiles"), async (_event, searchPath, pattern, maxDepth) => {
+    try {
+      const filePaths = await (0, import_file_explorer_core.searchFiles)(searchPath, pattern, maxDepth);
+      const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+      const maxResults = 100;
+      const results = [];
+      for (const filePath of filePaths.slice(0, maxResults)) {
+        try {
+          const stats = await import_node_fs.promises.stat(filePath);
+          const fileType = (0, import_file_explorer_core.getFileType)(filePath, stats);
+          const item = {
+            id: filePath,
+            name: import_node_path.default.basename(filePath),
+            type: fileType,
+            size: stats.isDirectory() ? void 0 : (0, import_file_explorer_core.formatFileSize)(stats.size),
+            dateModified: (0, import_file_explorer_core.formatDateTime)(stats.mtime),
+            url: electronUrlEncoder(filePath)
+          };
+          if (thumbnailService) {
+            const thumbnailUrl = await thumbnailService.getThumbnailUrl(filePath);
+            if (thumbnailUrl) {
+              item.thumbnailUrl = thumbnailUrl;
+            }
+          }
+          results.push(item);
+        } catch {
+        }
+      }
+      return { success: true, data: { items: results, total: filePaths.length } };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  import_electron.ipcMain.handle(channel("searchFilesStream"), async (event, searchPath, pattern, searchId) => {
+    const thumbnailService = (0, import_file_explorer_core.getThumbnailService)();
+    const pathToItem = async (filePath) => {
+      try {
+        const stats = await import_node_fs.promises.stat(filePath);
+        const fileType = (0, import_file_explorer_core.getFileType)(filePath, stats);
+        const item = {
+          id: filePath,
+          name: import_node_path.default.basename(filePath),
+          type: fileType,
+          size: stats.isDirectory() ? void 0 : (0, import_file_explorer_core.formatFileSize)(stats.size),
+          dateModified: (0, import_file_explorer_core.formatDateTime)(stats.mtime),
+          url: electronUrlEncoder(filePath)
+        };
+        if (thumbnailService) {
+          const thumbnailUrl = await thumbnailService.getThumbnailUrl(filePath);
+          if (thumbnailUrl) {
+            item.thumbnailUrl = thumbnailUrl;
+          }
+        }
+        return item;
+      } catch {
+        return null;
+      }
+    };
+    (0, import_file_explorer_core.searchFilesStream)(searchPath, pattern, async (paths, done) => {
+      const items = [];
+      for (const p of paths) {
+        const item = await pathToItem(p);
+        if (item) items.push(item);
+      }
+      event.sender.send(channel("searchResults"), {
+        searchId,
+        items,
+        done
+      });
+    }, 100);
+    return { success: true };
+  });
+  console.log("\u2705 File Explorer IPC handlers registered");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createElectronAdapter,
+  electronUrlEncoder,
+  registerFileExplorerHandlers,
+  setClipboardAdapter
+});

package/dist/main/index.d.cts

@@ -0,0 +1,27 @@
+import { PlatformAdapter, ClipboardAdapter } from '@huyooo/file-explorer-core';
+
+/**
+ * File Explorer Electron Bridge - Main Process
+ *
+ * 只负责 IPC 通信，具体实现在 @huyooo/file-explorer-core 中
+ */
+
+/**
+ * 设置剪贴板适配器
+ * 在主进程中调用，注入 clipboard-files 模块
+ */
+declare function setClipboardAdapter(adapter: ClipboardAdapter): void;
+/**
+ * 创建 Electron 平台适配器
+ */
+declare function createElectronAdapter(): PlatformAdapter;
+/**
+ * URL 编码器（使用 app:// 协议）
+ */
+declare function electronUrlEncoder(filePath: string): string;
+/**
+ * 注册文件系统 IPC handlers
+ */
+declare function registerFileExplorerHandlers(): void;
+
+export { createElectronAdapter, electronUrlEncoder, registerFileExplorerHandlers, setClipboardAdapter };

package/dist/main/index.d.ts

@@ -0,0 +1,27 @@
+import { PlatformAdapter, ClipboardAdapter } from '@huyooo/file-explorer-core';
+
+/**
+ * File Explorer Electron Bridge - Main Process
+ *
+ * 只负责 IPC 通信，具体实现在 @huyooo/file-explorer-core 中
+ */
+
+/**
+ * 设置剪贴板适配器
+ * 在主进程中调用，注入 clipboard-files 模块
+ */
+declare function setClipboardAdapter(adapter: ClipboardAdapter): void;
+/**
+ * 创建 Electron 平台适配器
+ */
+declare function createElectronAdapter(): PlatformAdapter;
+/**
+ * URL 编码器（使用 app:// 协议）
+ */
+declare function electronUrlEncoder(filePath: string): string;
+/**
+ * 注册文件系统 IPC handlers
+ */
+declare function registerFileExplorerHandlers(): void;
+
+export { createElectronAdapter, electronUrlEncoder, registerFileExplorerHandlers, setClipboardAdapter };

package/dist/main/index.js

@@ -0,0 +1,220 @@
+// src/main/index.ts
+import { ipcMain, shell } from "electron";
+import path from "path";
+import {
+  readDirectory,
+  readFileContent,
+  readImageAsBase64,
+  writeFileContent,
+  createFolder,
+  createFile,
+  deleteFiles,
+  renameFile,
+  copyFiles,
+  moveFiles,
+  getFileInfo,
+  getSystemPath,
+  getThumbnailService,
+  getApplicationIcon,
+  copyFilesToClipboard,
+  getClipboardFiles,
+  pasteFiles,
+  searchFiles,
+  searchFilesStream,
+  getFileType,
+  formatFileSize,
+  formatDateTime
+} from "@huyooo/file-explorer-core";
+import { promises as fs } from "fs";
+var CHANNEL_PREFIX = "file-explorer";
+var channel = (name) => `${CHANNEL_PREFIX}:${name}`;
+var clipboardAdapter = null;
+function setClipboardAdapter(adapter) {
+  clipboardAdapter = adapter;
+}
+function createElectronAdapter() {
+  return {
+    trashItem: async (filePath) => {
+      await shell.trashItem(filePath);
+    },
+    openPath: async (filePath) => {
+      await shell.openPath(filePath);
+    }
+  };
+}
+function electronUrlEncoder(filePath) {
+  const encodedPath = encodeURIComponent(filePath);
+  return `app://file${encodedPath}`;
+}
+function registerFileExplorerHandlers() {
+  const adapter = createElectronAdapter();
+  ipcMain.handle(channel("readDirectory"), async (_event, dirPath) => {
+    const thumbnailService = getThumbnailService();
+    return await readDirectory(dirPath, {
+      urlEncoder: electronUrlEncoder,
+      getThumbnailUrl: thumbnailService ? (filePath) => thumbnailService.getThumbnailUrl(filePath) : void 0
+    });
+  });
+  ipcMain.handle(channel("readSystemPath"), async (_event, pathId) => {
+    const systemPath = getSystemPath(pathId);
+    if (!systemPath) return [];
+    const thumbnailService = getThumbnailService();
+    return await readDirectory(systemPath, {
+      urlEncoder: electronUrlEncoder,
+      getThumbnailUrl: thumbnailService ? (filePath) => thumbnailService.getThumbnailUrl(filePath) : void 0
+    });
+  });
+  ipcMain.handle(channel("getSystemPath"), async (_event, pathId) => {
+    return getSystemPath(pathId);
+  });
+  ipcMain.handle(channel("readFileContent"), async (_event, filePath) => {
+    return await readFileContent(filePath);
+  });
+  ipcMain.handle(channel("writeFileContent"), async (_event, filePath, content) => {
+    return await writeFileContent(filePath, content);
+  });
+  ipcMain.handle(channel("createFolder"), async (_event, parentDir, folderName) => {
+    const folderPath = path.join(parentDir, folderName);
+    return await createFolder(folderPath);
+  });
+  ipcMain.handle(channel("createFile"), async (_event, parentDir, fileName, content) => {
+    const filePath = path.join(parentDir, fileName);
+    return await createFile(filePath, content);
+  });
+  ipcMain.handle(channel("deleteFiles"), async (_event, paths) => {
+    const thumbnailService = getThumbnailService();
+    return await deleteFiles(paths, {
+      adapter,
+      useTrash: true,
+      onDeleted: (p) => thumbnailService?.deleteThumbnail(p)
+    });
+  });
+  ipcMain.handle(channel("renameFile"), async (_event, oldPath, newPath) => {
+    const thumbnailService = getThumbnailService();
+    return await renameFile(oldPath, newPath, {
+      onRenamed: (old) => thumbnailService?.deleteThumbnail(old)
+    });
+  });
+  ipcMain.handle(channel("copyFiles"), async (_event, sourcePaths, targetDir) => {
+    return await copyFiles(sourcePaths, targetDir);
+  });
+  ipcMain.handle(channel("moveFiles"), async (_event, sourcePaths, targetDir) => {
+    return await moveFiles(sourcePaths, targetDir);
+  });
+  ipcMain.handle(channel("getFileInfo"), async (_event, filePath) => {
+    return await getFileInfo(filePath);
+  });
+  ipcMain.handle(channel("readImageAsBase64"), async (_event, imagePath) => {
+    return await readImageAsBase64(imagePath);
+  });
+  ipcMain.handle(channel("openPath"), async (_event, filePath) => {
+    try {
+      await shell.openPath(filePath);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("getApplicationIcon"), async (_event, appPath) => {
+    return await getApplicationIcon(appPath);
+  });
+  ipcMain.handle(channel("getThumbnailUrl"), async (_event, filePath) => {
+    const thumbnailService = getThumbnailService();
+    if (!thumbnailService) return null;
+    return await thumbnailService.getThumbnailUrl(filePath);
+  });
+  ipcMain.handle(channel("copyFilesToClipboard"), async (_event, filePaths) => {
+    if (!clipboardAdapter) {
+      return { success: false, error: "\u526A\u8D34\u677F\u9002\u914D\u5668\u672A\u521D\u59CB\u5316" };
+    }
+    return await copyFilesToClipboard(filePaths, clipboardAdapter);
+  });
+  ipcMain.handle(channel("getClipboardFiles"), async () => {
+    if (!clipboardAdapter) {
+      return { success: false, error: "\u526A\u8D34\u677F\u9002\u914D\u5668\u672A\u521D\u59CB\u5316" };
+    }
+    return getClipboardFiles(clipboardAdapter);
+  });
+  ipcMain.handle(channel("pasteFiles"), async (_event, targetDir, sourcePaths) => {
+    return await pasteFiles(targetDir, sourcePaths);
+  });
+  ipcMain.handle(channel("searchFiles"), async (_event, searchPath, pattern, maxDepth) => {
+    try {
+      const filePaths = await searchFiles(searchPath, pattern, maxDepth);
+      const thumbnailService = getThumbnailService();
+      const maxResults = 100;
+      const results = [];
+      for (const filePath of filePaths.slice(0, maxResults)) {
+        try {
+          const stats = await fs.stat(filePath);
+          const fileType = getFileType(filePath, stats);
+          const item = {
+            id: filePath,
+            name: path.basename(filePath),
+            type: fileType,
+            size: stats.isDirectory() ? void 0 : formatFileSize(stats.size),
+            dateModified: formatDateTime(stats.mtime),
+            url: electronUrlEncoder(filePath)
+          };
+          if (thumbnailService) {
+            const thumbnailUrl = await thumbnailService.getThumbnailUrl(filePath);
+            if (thumbnailUrl) {
+              item.thumbnailUrl = thumbnailUrl;
+            }
+          }
+          results.push(item);
+        } catch {
+        }
+      }
+      return { success: true, data: { items: results, total: filePaths.length } };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("searchFilesStream"), async (event, searchPath, pattern, searchId) => {
+    const thumbnailService = getThumbnailService();
+    const pathToItem = async (filePath) => {
+      try {
+        const stats = await fs.stat(filePath);
+        const fileType = getFileType(filePath, stats);
+        const item = {
+          id: filePath,
+          name: path.basename(filePath),
+          type: fileType,
+          size: stats.isDirectory() ? void 0 : formatFileSize(stats.size),
+          dateModified: formatDateTime(stats.mtime),
+          url: electronUrlEncoder(filePath)
+        };
+        if (thumbnailService) {
+          const thumbnailUrl = await thumbnailService.getThumbnailUrl(filePath);
+          if (thumbnailUrl) {
+            item.thumbnailUrl = thumbnailUrl;
+          }
+        }
+        return item;
+      } catch {
+        return null;
+      }
+    };
+    searchFilesStream(searchPath, pattern, async (paths, done) => {
+      const items = [];
+      for (const p of paths) {
+        const item = await pathToItem(p);
+        if (item) items.push(item);
+      }
+      event.sender.send(channel("searchResults"), {
+        searchId,
+        items,
+        done
+      });
+    }, 100);
+    return { success: true };
+  });
+  console.log("\u2705 File Explorer IPC handlers registered");
+}
+export {
+  createElectronAdapter,
+  electronUrlEncoder,
+  registerFileExplorerHandlers,
+  setClipboardAdapter
+};

package/dist/preload/index.cjs

@@ -0,0 +1,71 @@
+"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/preload/index.ts
+var preload_exports = {};
+__export(preload_exports, {
+  createFileExplorerAPI: () => createFileExplorerAPI,
+  exposeFileExplorerAPI: () => exposeFileExplorerAPI
+});
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+var CHANNEL_PREFIX = "file-explorer";
+var channel = (name) => `${CHANNEL_PREFIX}:${name}`;
+function createFileExplorerAPI() {
+  return {
+    readDirectory: (dirPath) => import_electron.ipcRenderer.invoke(channel("readDirectory"), dirPath),
+    readSystemPath: (pathId) => import_electron.ipcRenderer.invoke(channel("readSystemPath"), pathId),
+    getSystemPath: (pathId) => import_electron.ipcRenderer.invoke(channel("getSystemPath"), pathId),
+    readFileContent: (filePath) => import_electron.ipcRenderer.invoke(channel("readFileContent"), filePath),
+    writeFileContent: (filePath, content) => import_electron.ipcRenderer.invoke(channel("writeFileContent"), filePath, content),
+    createFolder: (parentDir, folderName) => import_electron.ipcRenderer.invoke(channel("createFolder"), parentDir, folderName),
+    createFile: (parentDir, fileName, content) => import_electron.ipcRenderer.invoke(channel("createFile"), parentDir, fileName, content),
+    deleteFiles: (paths) => import_electron.ipcRenderer.invoke(channel("deleteFiles"), paths),
+    renameFile: (oldPath, newPath) => import_electron.ipcRenderer.invoke(channel("renameFile"), oldPath, newPath),
+    copyFiles: (sourcePaths, targetDir) => import_electron.ipcRenderer.invoke(channel("copyFiles"), sourcePaths, targetDir),
+    moveFiles: (sourcePaths, targetDir) => import_electron.ipcRenderer.invoke(channel("moveFiles"), sourcePaths, targetDir),
+    getFileInfo: (filePath) => import_electron.ipcRenderer.invoke(channel("getFileInfo"), filePath),
+    readImageAsBase64: (imagePath) => import_electron.ipcRenderer.invoke(channel("readImageAsBase64"), imagePath),
+    openPath: (filePath) => import_electron.ipcRenderer.invoke(channel("openPath"), filePath),
+    getApplicationIcon: (appPath) => import_electron.ipcRenderer.invoke(channel("getApplicationIcon"), appPath),
+    getThumbnailUrl: (filePath) => import_electron.ipcRenderer.invoke(channel("getThumbnailUrl"), filePath),
+    copyFilesToClipboard: (filePaths) => import_electron.ipcRenderer.invoke(channel("copyFilesToClipboard"), filePaths),
+    getClipboardFiles: () => import_electron.ipcRenderer.invoke(channel("getClipboardFiles")),
+    pasteFiles: (targetDir, sourcePaths) => import_electron.ipcRenderer.invoke(channel("pasteFiles"), targetDir, sourcePaths),
+    searchFiles: (searchPath, pattern, maxDepth) => import_electron.ipcRenderer.invoke(channel("searchFiles"), searchPath, pattern, maxDepth),
+    searchFilesStream: (searchPath, pattern, searchId) => import_electron.ipcRenderer.invoke(channel("searchFilesStream"), searchPath, pattern, searchId),
+    onSearchResults: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(channel("searchResults"), handler);
+      return () => import_electron.ipcRenderer.removeListener(channel("searchResults"), handler);
+    }
+  };
+}
+function exposeFileExplorerAPI(apiName = "fileExplorerAPI") {
+  const api = createFileExplorerAPI();
+  import_electron.contextBridge.exposeInMainWorld(apiName, api);
+  console.log(`\u2705 File Explorer API exposed as window.${apiName}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFileExplorerAPI,
+  exposeFileExplorerAPI
+});