@huyooo/file-explorer-core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1259 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileType: () => FileType,
+  SqliteThumbnailDatabase: () => SqliteThumbnailDatabase,
+  ThumbnailService: () => ThumbnailService,
+  copyFiles: () => copyFiles,
+  copyFilesToClipboard: () => copyFilesToClipboard,
+  createFfmpegVideoProcessor: () => createFfmpegVideoProcessor,
+  createFile: () => createFile,
+  createFolder: () => createFolder,
+  createSharpImageProcessor: () => createSharpImageProcessor,
+  createSqliteThumbnailDatabase: () => createSqliteThumbnailDatabase,
+  deleteFiles: () => deleteFiles,
+  exists: () => exists,
+  formatDate: () => formatDate,
+  formatDateTime: () => formatDateTime,
+  formatFileSize: () => formatFileSize,
+  getAllSystemPaths: () => getAllSystemPaths,
+  getApplicationIcon: () => getApplicationIcon,
+  getClipboardFiles: () => getClipboardFiles,
+  getFileHash: () => getFileHash,
+  getFileHashes: () => getFileHashes,
+  getFileInfo: () => getFileInfo,
+  getFileType: () => getFileType,
+  getHomeDirectory: () => getHomeDirectory,
+  getPlatform: () => getPlatform,
+  getSqliteThumbnailDatabase: () => getSqliteThumbnailDatabase,
+  getSystemPath: () => getSystemPath,
+  getThumbnailService: () => getThumbnailService,
+  initThumbnailService: () => initThumbnailService,
+  isDirectory: () => isDirectory,
+  isMediaFile: () => isMediaFile,
+  isPreviewable: () => isPreviewable,
+  moveFiles: () => moveFiles,
+  pasteFiles: () => pasteFiles,
+  readDirectory: () => readDirectory,
+  readFileContent: () => readFileContent,
+  readImageAsBase64: () => readImageAsBase64,
+  renameFile: () => renameFile,
+  searchFiles: () => searchFiles,
+  searchFilesStream: () => searchFilesStream,
+  searchFilesSync: () => searchFilesSync,
+  writeFileContent: () => writeFileContent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2["FOLDER"] = "folder";
+  FileType2["FILE"] = "file";
+  FileType2["IMAGE"] = "image";
+  FileType2["VIDEO"] = "video";
+  FileType2["MUSIC"] = "music";
+  FileType2["DOCUMENT"] = "document";
+  FileType2["CODE"] = "code";
+  FileType2["TEXT"] = "text";
+  FileType2["ARCHIVE"] = "archive";
+  FileType2["APPLICATION"] = "application";
+  FileType2["UNKNOWN"] = "unknown";
+  return FileType2;
+})(FileType || {});
+
+// src/utils/file-type.ts
+var import_node_path = __toESM(require("path"), 1);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".bmp",
+  ".webp",
+  ".svg",
+  ".ico",
+  ".tiff",
+  ".tif",
+  ".heic",
+  ".heif"
+]);
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".wmv",
+  ".flv",
+  ".webm",
+  ".m4v",
+  ".3gp",
+  ".mpeg",
+  ".mpg"
+]);
+var MUSIC_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mp3",
+  ".wav",
+  ".flac",
+  ".aac",
+  ".ogg",
+  ".wma",
+  ".m4a",
+  ".aiff",
+  ".alac"
+]);
+var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".rtf",
+  ".pages",
+  ".numbers",
+  ".key"
+]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".html",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".sql",
+  ".graphql",
+  ".prisma"
+]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".markdown",
+  ".log",
+  ".ini",
+  ".conf",
+  ".cfg",
+  ".env"
+]);
+var ARCHIVE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".zip",
+  ".rar",
+  ".7z",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".dmg",
+  ".iso"
+]);
+var APPLICATION_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".app",
+  ".exe",
+  ".msi",
+  ".deb",
+  ".rpm",
+  ".pkg",
+  ".apk",
+  ".ipa"
+]);
+function getFileType(filePath, stats) {
+  if (stats.isDirectory()) {
+    if (filePath.endsWith(".app")) {
+      return "application" /* APPLICATION */;
+    }
+    return "folder" /* FOLDER */;
+  }
+  const ext = import_node_path.default.extname(filePath).toLowerCase();
+  if (IMAGE_EXTENSIONS.has(ext)) return "image" /* IMAGE */;
+  if (VIDEO_EXTENSIONS.has(ext)) return "video" /* VIDEO */;
+  if (MUSIC_EXTENSIONS.has(ext)) return "music" /* MUSIC */;
+  if (DOCUMENT_EXTENSIONS.has(ext)) return "document" /* DOCUMENT */;
+  if (CODE_EXTENSIONS.has(ext)) return "code" /* CODE */;
+  if (TEXT_EXTENSIONS.has(ext)) return "text" /* TEXT */;
+  if (ARCHIVE_EXTENSIONS.has(ext)) return "archive" /* ARCHIVE */;
+  if (APPLICATION_EXTENSIONS.has(ext)) return "application" /* APPLICATION */;
+  return "file" /* FILE */;
+}
+function isMediaFile(type) {
+  return type === "image" /* IMAGE */ || type === "video" /* VIDEO */ || type === "music" /* MUSIC */;
+}
+function isPreviewable(type) {
+  return type === "image" /* IMAGE */ || type === "video" /* VIDEO */ || type === "music" /* MUSIC */ || type === "text" /* TEXT */ || type === "code" /* CODE */;
+}
+
+// src/utils/formatters.ts
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;
+}
+function formatDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
+  if (days === 0) {
+    return date.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
+  } else if (days === 1) {
+    return "\u6628\u5929";
+  } else if (days < 7) {
+    return `${days} \u5929\u524D`;
+  } else {
+    return date.toLocaleDateString("zh-CN", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    });
+  }
+}
+function formatDateTime(date) {
+  return date.toLocaleString("zh-CN", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+
+// src/operations/read.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var defaultUrlEncoder = (filePath) => `file://${encodeURIComponent(filePath)}`;
+async function readDirectory(dirPath, options = {}) {
+  const {
+    urlEncoder = defaultUrlEncoder,
+    includeHidden = false,
+    getThumbnailUrl
+  } = options;
+  try {
+    const entries = await import_node_fs.promises.readdir(dirPath, { withFileTypes: true });
+    const items = [];
+    for (const entry of entries) {
+      if (!includeHidden && entry.name.startsWith(".")) {
+        continue;
+      }
+      const fullPath = import_node_path2.default.join(dirPath, entry.name);
+      try {
+        let stats;
+        try {
+          stats = await import_node_fs.promises.lstat(fullPath);
+        } catch {
+          try {
+            stats = await import_node_fs.promises.stat(fullPath);
+          } catch (statError) {
+            const err = statError;
+            if (err.code !== "ENOENT") {
+              console.warn(`Cannot access file ${fullPath}:`, err.message);
+            }
+            continue;
+          }
+        }
+        const fileType = getFileType(fullPath, stats);
+        const fileUrl = urlEncoder(fullPath);
+        const item = {
+          id: fullPath,
+          name: entry.name,
+          type: fileType,
+          dateModified: formatDate(stats.mtime),
+          url: fileUrl
+        };
+        if (stats.isDirectory()) {
+          item.children = [];
+        } else {
+          item.size = formatFileSize(stats.size);
+          if (getThumbnailUrl && (fileType === "image" /* IMAGE */ || fileType === "video" /* VIDEO */)) {
+            const thumbUrl = await getThumbnailUrl(fullPath);
+            if (thumbUrl) {
+              item.thumbnailUrl = thumbUrl;
+            }
+          }
+        }
+        items.push(item);
+      } catch (itemError) {
+        const err = itemError;
+        if (err.code !== "ENOENT") {
+          console.warn(`Error processing file ${fullPath}:`, err.message);
+        }
+        continue;
+      }
+    }
+    items.sort((a, b) => {
+      if (a.type === "folder" /* FOLDER */ && b.type !== "folder" /* FOLDER */) return -1;
+      if (a.type !== "folder" /* FOLDER */ && b.type === "folder" /* FOLDER */) return 1;
+      return a.name.localeCompare(b.name, "zh-CN");
+    });
+    return items;
+  } catch (error) {
+    console.error(`Error reading directory ${dirPath}:`, error);
+    return [];
+  }
+}
+async function readFileContent(filePath) {
+  return await import_node_fs.promises.readFile(filePath, "utf-8");
+}
+async function readImageAsBase64(imagePath) {
+  try {
+    let actualPath = imagePath;
+    if (imagePath.startsWith("app://file")) {
+      actualPath = decodeURIComponent(imagePath.replace("app://file", ""));
+    } else if (imagePath.startsWith("file://")) {
+      actualPath = decodeURIComponent(imagePath.replace("file://", ""));
+    }
+    const stats = await import_node_fs.promises.stat(actualPath);
+    if (!stats.isFile()) {
+      return { success: false, error: `\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6: ${actualPath}` };
+    }
+    const buffer = await import_node_fs.promises.readFile(actualPath);
+    const base64 = buffer.toString("base64");
+    const ext = import_node_path2.default.extname(actualPath).toLowerCase().slice(1);
+    const mimeTypes = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      bmp: "image/bmp",
+      svg: "image/svg+xml"
+    };
+    const mimeType = mimeTypes[ext] || "image/jpeg";
+    return { success: true, base64, mimeType };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// src/operations/write.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+async function writeFileContent(filePath, content) {
+  try {
+    await import_node_fs2.promises.writeFile(filePath, content, "utf-8");
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function createFolder(folderPath) {
+  try {
+    try {
+      await import_node_fs2.promises.access(folderPath);
+    } catch {
+      await import_node_fs2.promises.mkdir(folderPath, { recursive: true });
+      return { success: true, data: { finalPath: folderPath } };
+    }
+    const dir = import_node_path3.default.dirname(folderPath);
+    const baseName = import_node_path3.default.basename(folderPath);
+    let counter = 2;
+    let finalPath = import_node_path3.default.join(dir, `${baseName} ${counter}`);
+    while (true) {
+      try {
+        await import_node_fs2.promises.access(finalPath);
+        counter++;
+        finalPath = import_node_path3.default.join(dir, `${baseName} ${counter}`);
+      } catch {
+        break;
+      }
+    }
+    await import_node_fs2.promises.mkdir(finalPath, { recursive: true });
+    return { success: true, data: { finalPath } };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function createFile(filePath, content = "") {
+  try {
+    const dir = import_node_path3.default.dirname(filePath);
+    await import_node_fs2.promises.mkdir(dir, { recursive: true });
+    try {
+      await import_node_fs2.promises.access(filePath);
+    } catch {
+      await import_node_fs2.promises.writeFile(filePath, content, "utf-8");
+      return { success: true, data: { finalPath: filePath } };
+    }
+    const dirname = import_node_path3.default.dirname(filePath);
+    const ext = import_node_path3.default.extname(filePath);
+    const basename = import_node_path3.default.basename(filePath, ext);
+    let counter = 2;
+    let finalPath = import_node_path3.default.join(dirname, `${basename} ${counter}${ext}`);
+    while (true) {
+      try {
+        await import_node_fs2.promises.access(finalPath);
+        counter++;
+        finalPath = import_node_path3.default.join(dirname, `${basename} ${counter}${ext}`);
+      } catch {
+        break;
+      }
+    }
+    await import_node_fs2.promises.writeFile(finalPath, content, "utf-8");
+    return { success: true, data: { finalPath } };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// src/operations/delete.ts
+var import_node_fs3 = require("fs");
+async function deleteFiles(paths, options = {}) {
+  const { adapter, useTrash = true, onDeleted } = options;
+  try {
+    for (const filePath of paths) {
+      if (useTrash && adapter?.trashItem) {
+        await adapter.trashItem(filePath);
+      } else {
+        const stats = await import_node_fs3.promises.stat(filePath);
+        if (stats.isDirectory()) {
+          await import_node_fs3.promises.rm(filePath, { recursive: true, force: true });
+        } else {
+          await import_node_fs3.promises.unlink(filePath);
+        }
+      }
+      onDeleted?.(filePath);
+    }
+    return {
+      success: true,
+      message: useTrash ? "\u6587\u4EF6\u5DF2\u79FB\u52A8\u5230\u56DE\u6536\u7AD9" : "\u6587\u4EF6\u5DF2\u5220\u9664"
+    };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// src/operations/rename.ts
+var import_node_fs4 = require("fs");
+async function renameFile(oldPath, newPath, options = {}) {
+  const { onRenamed } = options;
+  try {
+    await import_node_fs4.promises.rename(oldPath, newPath);
+    onRenamed?.(oldPath, newPath);
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// src/operations/copy.ts
+var import_node_fs5 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+async function copyFiles(sourcePaths, targetDir) {
+  try {
+    const copiedPaths = [];
+    for (const sourcePath of sourcePaths) {
+      const fileName = import_node_path4.default.basename(sourcePath);
+      let destPath = import_node_path4.default.join(targetDir, fileName);
+      let counter = 1;
+      while (true) {
+        try {
+          await import_node_fs5.promises.access(destPath);
+          const ext = import_node_path4.default.extname(fileName);
+          const baseName = import_node_path4.default.basename(fileName, ext);
+          destPath = import_node_path4.default.join(targetDir, `${baseName} ${++counter}${ext}`);
+        } catch {
+          break;
+        }
+      }
+      const stats = await import_node_fs5.promises.stat(sourcePath);
+      if (stats.isDirectory()) {
+        await copyDirectory(sourcePath, destPath);
+      } else {
+        await import_node_fs5.promises.copyFile(sourcePath, destPath);
+      }
+      copiedPaths.push(destPath);
+    }
+    return { success: true, data: { copiedPaths } };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function moveFiles(sourcePaths, targetDir) {
+  try {
+    const movedPaths = [];
+    for (const sourcePath of sourcePaths) {
+      const fileName = import_node_path4.default.basename(sourcePath);
+      let destPath = import_node_path4.default.join(targetDir, fileName);
+      let counter = 1;
+      while (true) {
+        try {
+          await import_node_fs5.promises.access(destPath);
+          const ext = import_node_path4.default.extname(fileName);
+          const baseName = import_node_path4.default.basename(fileName, ext);
+          destPath = import_node_path4.default.join(targetDir, `${baseName} ${++counter}${ext}`);
+        } catch {
+          break;
+        }
+      }
+      try {
+        await import_node_fs5.promises.rename(sourcePath, destPath);
+      } catch {
+        const stats = await import_node_fs5.promises.stat(sourcePath);
+        if (stats.isDirectory()) {
+          await copyDirectory(sourcePath, destPath);
+        } else {
+          await import_node_fs5.promises.copyFile(sourcePath, destPath);
+        }
+        await import_node_fs5.promises.rm(sourcePath, { recursive: true, force: true });
+      }
+      movedPaths.push(destPath);
+    }
+    return { success: true, data: { movedPaths } };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function copyDirectory(source, dest) {
+  await import_node_fs5.promises.mkdir(dest, { recursive: true });
+  const entries = await import_node_fs5.promises.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = import_node_path4.default.join(source, entry.name);
+    const destPath = import_node_path4.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, destPath);
+    } else {
+      await import_node_fs5.promises.copyFile(sourcePath, destPath);
+    }
+  }
+}
+
+// src/operations/info.ts
+var import_node_fs6 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
+async function getFileInfo(filePath) {
+  try {
+    const stats = await import_node_fs6.promises.stat(filePath);
+    const name = import_node_path5.default.basename(filePath);
+    const ext = import_node_path5.default.extname(name);
+    return {
+      success: true,
+      data: {
+        path: filePath,
+        name,
+        size: stats.size,
+        isFile: stats.isFile(),
+        isDirectory: stats.isDirectory(),
+        createdAt: stats.birthtime,
+        updatedAt: stats.mtime,
+        extension: ext || void 0
+      }
+    };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function exists(filePath) {
+  try {
+    await import_node_fs6.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(filePath) {
+  try {
+    const stats = await import_node_fs6.promises.stat(filePath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/system-paths.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var platform = process.platform;
+function getSystemPath(pathId) {
+  const homeDir = import_node_os.default.homedir();
+  switch (pathId) {
+    case "desktop":
+      return import_node_path6.default.join(homeDir, "Desktop");
+    case "documents":
+      return import_node_path6.default.join(homeDir, "Documents");
+    case "downloads":
+      return import_node_path6.default.join(homeDir, "Downloads");
+    case "pictures":
+      return import_node_path6.default.join(homeDir, "Pictures");
+    case "music":
+      return import_node_path6.default.join(homeDir, "Music");
+    case "videos":
+      return platform === "darwin" ? import_node_path6.default.join(homeDir, "Movies") : import_node_path6.default.join(homeDir, "Videos");
+    case "applications":
+      return platform === "darwin" ? "/Applications" : platform === "win32" ? process.env.ProgramFiles || "C:\\Program Files" : "/usr/share/applications";
+    case "home":
+      return homeDir;
+    case "root":
+      return platform === "darwin" ? "/" : platform === "win32" ? "C:\\" : "/";
+    default:
+      return null;
+  }
+}
+function getAllSystemPaths() {
+  const pathIds = [
+    "desktop",
+    "documents",
+    "downloads",
+    "pictures",
+    "music",
+    "videos",
+    "applications",
+    "home",
+    "root"
+  ];
+  const result = {};
+  for (const id of pathIds) {
+    result[id] = getSystemPath(id);
+  }
+  return result;
+}
+function getHomeDirectory() {
+  return import_node_os.default.homedir();
+}
+function getPlatform() {
+  return process.platform;
+}
+
+// src/search.ts
+var import_fdir = require("fdir");
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+function patternToRegex(pattern) {
+  return new RegExp(pattern.replace(/\*/g, ".*"), "i");
+}
+async function searchFiles(searchPath, pattern, maxDepth) {
+  const builder = new import_fdir.fdir().withFullPaths().withDirs();
+  if (maxDepth && maxDepth > 0) {
+    builder.withMaxDepth(maxDepth);
+  }
+  const api = builder.crawl(searchPath);
+  const files = await api.withPromise();
+  if (pattern) {
+    const regex = patternToRegex(pattern);
+    return files.filter((file) => regex.test(import_node_path7.default.basename(file)));
+  }
+  return files;
+}
+async function searchFilesStream(searchPath, pattern, onResults, maxResults = 100) {
+  const regex = patternToRegex(pattern);
+  const results = [];
+  let stopped = false;
+  async function searchDir(dirPath) {
+    if (stopped) return;
+    try {
+      const entries = await import_node_fs7.promises.readdir(dirPath, { withFileTypes: true });
+      const matched = [];
+      const subdirs = [];
+      for (const entry of entries) {
+        if (stopped) return;
+        const fullPath = import_node_path7.default.join(dirPath, entry.name);
+        if (regex.test(entry.name)) {
+          matched.push(fullPath);
+          results.push(fullPath);
+          if (results.length >= maxResults) {
+            stopped = true;
+            onResults(matched, true);
+            return;
+          }
+        }
+        if (entry.isDirectory()) {
+          subdirs.push(fullPath);
+        }
+      }
+      if (matched.length > 0) {
+        onResults(matched, false);
+      }
+      for (const subdir of subdirs) {
+        await searchDir(subdir);
+      }
+    } catch {
+    }
+  }
+  await searchDir(searchPath);
+  if (!stopped) {
+    onResults([], true);
+  }
+}
+function searchFilesSync(searchPath, pattern, maxDepth) {
+  const builder = new import_fdir.fdir().withFullPaths().withDirs();
+  if (maxDepth && maxDepth > 0) {
+    builder.withMaxDepth(maxDepth);
+  }
+  const api = builder.crawl(searchPath);
+  const files = api.sync();
+  if (pattern) {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"), "i");
+    return files.filter((file) => regex.test(import_node_path7.default.basename(file)));
+  }
+  return files;
+}
+
+// src/hash.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+async function getFileHash(filePath) {
+  try {
+    const stats = await (0, import_promises.stat)(filePath);
+    const hashInput = `${filePath}:${stats.size}:${stats.mtime.getTime()}`;
+    return (0, import_node_crypto.createHash)("md5").update(hashInput).digest("hex");
+  } catch (error) {
+    console.error(`Error computing hash for ${filePath}:`, error);
+    return (0, import_node_crypto.createHash)("md5").update(filePath).digest("hex");
+  }
+}
+async function getFileHashes(filePaths) {
+  const hashMap = /* @__PURE__ */ new Map();
+  await Promise.allSettled(
+    filePaths.map(async (filePath) => {
+      const hash = await getFileHash(filePath);
+      hashMap.set(filePath, hash);
+    })
+  );
+  return hashMap;
+}
+
+// src/clipboard.ts
+var import_node_fs8 = require("fs");
+var import_node_path8 = __toESM(require("path"), 1);
+async function copyFilesToClipboard(filePaths, clipboard) {
+  try {
+    const cleanPaths = [];
+    for (const p of filePaths) {
+      try {
+        await import_node_fs8.promises.access(p);
+        cleanPaths.push(p);
+      } catch {
+      }
+    }
+    if (cleanPaths.length === 0) {
+      return { success: false, error: "\u6CA1\u6709\u627E\u5230\u6709\u6548\u7684\u6587\u4EF6" };
+    }
+    clipboard.writeFiles(cleanPaths);
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+function getClipboardFiles(clipboard) {
+  try {
+    const files = clipboard.readFiles();
+    if (files && Array.isArray(files) && files.length > 0) {
+      return { success: true, data: { files } };
+    }
+    return { success: false, error: "\u526A\u8D34\u677F\u4E2D\u6CA1\u6709\u6587\u4EF6" };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function pasteFiles(targetDir, sourcePaths) {
+  try {
+    if (!targetDir || typeof targetDir !== "string") {
+      return { success: false, error: "\u76EE\u6807\u76EE\u5F55\u8DEF\u5F84\u65E0\u6548" };
+    }
+    if (!sourcePaths || !Array.isArray(sourcePaths) || sourcePaths.length === 0) {
+      return { success: false, error: "\u6E90\u6587\u4EF6\u8DEF\u5F84\u5217\u8868\u65E0\u6548" };
+    }
+    const pastedPaths = [];
+    for (const sourcePath of sourcePaths) {
+      const fileName = import_node_path8.default.basename(sourcePath);
+      let destPath = import_node_path8.default.join(targetDir, fileName);
+      let counter = 1;
+      while (true) {
+        try {
+          await import_node_fs8.promises.access(destPath);
+          const ext = import_node_path8.default.extname(fileName);
+          const baseName = import_node_path8.default.basename(fileName, ext);
+          destPath = import_node_path8.default.join(targetDir, `${baseName} ${++counter}${ext}`);
+        } catch {
+          break;
+        }
+      }
+      const stats = await import_node_fs8.promises.stat(sourcePath);
+      if (stats.isDirectory()) {
+        await copyDirectory2(sourcePath, destPath);
+      } else {
+        await import_node_fs8.promises.copyFile(sourcePath, destPath);
+      }
+      pastedPaths.push(destPath);
+    }
+    return { success: true, data: { pastedPaths } };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+async function copyDirectory2(source, dest) {
+  await import_node_fs8.promises.mkdir(dest, { recursive: true });
+  const entries = await import_node_fs8.promises.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = import_node_path8.default.join(source, entry.name);
+    const destPath = import_node_path8.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory2(sourcePath, destPath);
+    } else {
+      await import_node_fs8.promises.copyFile(sourcePath, destPath);
+    }
+  }
+}
+
+// src/application-icon.ts
+var import_node_fs9 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+async function findAppIconPath(appPath) {
+  const resourcesPath = import_node_path9.default.join(appPath, "Contents", "Resources");
+  try {
+    const commonIconNames = [
+      "AppIcon.icns",
+      "app.icns",
+      "application.icns",
+      "icon.icns"
+    ];
+    const infoPlistPath = import_node_path9.default.join(appPath, "Contents", "Info.plist");
+    try {
+      const infoPlistContent = await import_node_fs9.promises.readFile(infoPlistPath, "utf-8");
+      const iconFileMatch = infoPlistContent.match(/<key>CFBundleIconFile<\/key>\s*<string>([^<]+)<\/string>/);
+      if (iconFileMatch && iconFileMatch[1]) {
+        let iconFileName = iconFileMatch[1].trim();
+        if (!iconFileName.endsWith(".icns")) {
+          iconFileName += ".icns";
+        }
+        const iconPath = import_node_path9.default.join(resourcesPath, iconFileName);
+        try {
+          await import_node_fs9.promises.access(iconPath);
+          return iconPath;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    for (const iconName of commonIconNames) {
+      const iconPath = import_node_path9.default.join(resourcesPath, iconName);
+      try {
+        await import_node_fs9.promises.access(iconPath);
+        return iconPath;
+      } catch {
+        continue;
+      }
+    }
+    try {
+      const entries = await import_node_fs9.promises.readdir(resourcesPath);
+      const icnsFile = entries.find((entry) => entry.toLowerCase().endsWith(".icns"));
+      if (icnsFile) {
+        return import_node_path9.default.join(resourcesPath, icnsFile);
+      }
+    } catch {
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function getApplicationIcon(appPath) {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const stats = await import_node_fs9.promises.stat(appPath);
+    if (!stats.isDirectory() || !appPath.endsWith(".app")) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  const iconPath = await findAppIconPath(appPath);
+  if (!iconPath) {
+    return null;
+  }
+  try {
+    const tempPngPath = import_node_path9.default.join(import_node_os2.default.tmpdir(), `app-icon-${Date.now()}.png`);
+    await execAsync(
+      `sips -s format png "${iconPath}" --out "${tempPngPath}" --resampleHeightWidthMax 128`
+    );
+    const pngBuffer = await import_node_fs9.promises.readFile(tempPngPath);
+    try {
+      await import_node_fs9.promises.unlink(tempPngPath);
+    } catch {
+    }
+    const base64 = pngBuffer.toString("base64");
+    return `data:image/png;base64,${base64}`;
+  } catch {
+    return null;
+  }
+}
+
+// src/thumbnail/service.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
+var IMAGE_EXTENSIONS2 = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"];
+var VIDEO_EXTENSIONS2 = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".wmv"];
+var ThumbnailService = class {
+  database;
+  imageProcessor;
+  videoProcessor;
+  urlEncoder;
+  getApplicationIcon;
+  constructor(options) {
+    this.database = options.database;
+    this.imageProcessor = options.imageProcessor || null;
+    this.videoProcessor = options.videoProcessor || null;
+    this.urlEncoder = options.urlEncoder || ((p) => `file://${encodeURIComponent(p)}`);
+    this.getApplicationIcon = options.getApplicationIcon || null;
+  }
+  /**
+   * 获取缓存的缩略图 URL（不生成新的）
+   */
+  async getCachedThumbnailUrl(filePath) {
+    try {
+      const stats = await import_node_fs10.promises.stat(filePath);
+      const fileType = getFileType(filePath, stats);
+      if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
+        return await this.getApplicationIcon(filePath);
+      }
+      if (fileType !== "image" /* IMAGE */ && fileType !== "video" /* VIDEO */) {
+        return null;
+      }
+      const mtime = stats.mtime.getTime();
+      const cachedPath = this.database.getThumbnailPathFast(filePath, mtime);
+      if (cachedPath) {
+        return this.urlEncoder(cachedPath);
+      }
+      getFileHash(filePath).then((fileHash) => {
+        this.generateThumbnail(filePath, fileHash, mtime).catch(() => {
+        });
+      }).catch(() => {
+      });
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * 获取缩略图 URL（如果没有缓存则生成）
+   */
+  async getThumbnailUrl(filePath) {
+    try {
+      const stats = await import_node_fs10.promises.stat(filePath);
+      const fileType = getFileType(filePath, stats);
+      if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
+        return await this.getApplicationIcon(filePath);
+      }
+      if (fileType !== "image" /* IMAGE */ && fileType !== "video" /* VIDEO */) {
+        return null;
+      }
+      const mtime = stats.mtime.getTime();
+      const cachedPath = this.database.getThumbnailPathFast(filePath, mtime);
+      if (cachedPath) {
+        return this.urlEncoder(cachedPath);
+      }
+      const fileHash = await getFileHash(filePath);
+      const thumbnailPath = await this.generateThumbnail(filePath, fileHash, mtime);
+      if (thumbnailPath) {
+        return this.urlEncoder(thumbnailPath);
+      }
+      return null;
+    } catch (error) {
+      console.error(`Error getting thumbnail for ${filePath}:`, error);
+      return null;
+    }
+  }
+  /**
+   * 生成缩略图
+   */
+  async generateThumbnail(filePath, fileHash, mtime) {
+    const cachedPath = this.database.getThumbnailPath(filePath, fileHash, mtime);
+    if (cachedPath) {
+      return cachedPath;
+    }
+    try {
+      const ext = import_node_path10.default.extname(filePath).toLowerCase();
+      const hashPrefix = fileHash.substring(0, 16);
+      const thumbnailFileName = `${hashPrefix}.jpg`;
+      const thumbnailPath = import_node_path10.default.join(this.database.getCacheDir(), thumbnailFileName);
+      if (IMAGE_EXTENSIONS2.includes(ext) && this.imageProcessor) {
+        await this.imageProcessor.resize(filePath, thumbnailPath, 256);
+      } else if (VIDEO_EXTENSIONS2.includes(ext) && this.videoProcessor) {
+        await this.videoProcessor.screenshot(filePath, thumbnailPath, "00:00:01", "256x256");
+      } else {
+        return null;
+      }
+      this.database.saveThumbnail(filePath, fileHash, mtime, thumbnailPath);
+      return thumbnailPath;
+    } catch (error) {
+      console.debug(`Error generating thumbnail for ${filePath}:`, error);
+      return null;
+    }
+  }
+  /**
+   * 批量生成缩略图
+   */
+  async generateThumbnailsBatch(files) {
+    await Promise.allSettled(
+      files.map((file) => this.generateThumbnail(file.path, file.hash, file.mtime))
+    );
+  }
+  /**
+   * 删除缩略图
+   */
+  deleteThumbnail(filePath) {
+    this.database.deleteThumbnail(filePath);
+  }
+  /**
+   * 清理旧缩略图
+   */
+  cleanupOldThumbnails() {
+    this.database.cleanupOldThumbnails();
+  }
+};
+var thumbnailService = null;
+function initThumbnailService(options) {
+  thumbnailService = new ThumbnailService(options);
+  return thumbnailService;
+}
+function getThumbnailService() {
+  return thumbnailService;
+}
+
+// src/thumbnail/database.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var SqliteThumbnailDatabase = class {
+  db = null;
+  cacheDir;
+  constructor(userDataPath) {
+    this.cacheDir = import_node_path11.default.join(userDataPath, "cache");
+    if (!(0, import_node_fs11.existsSync)(this.cacheDir)) {
+      (0, import_node_fs11.mkdirSync)(this.cacheDir, { recursive: true });
+    }
+  }
+  /**
+   * 初始化数据库
+   */
+  init() {
+    if (this.db) return;
+    const dbPath = import_node_path11.default.join(this.cacheDir, "thumbnails.db");
+    this.db = new import_better_sqlite3.default(dbPath, {
+      fileMustExist: false
+    });
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS thumbnails (
+        file_path TEXT PRIMARY KEY,
+        file_hash TEXT NOT NULL,
+        mtime INTEGER NOT NULL,
+        thumbnail_path TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_file_hash ON thumbnails(file_hash);
+      CREATE INDEX IF NOT EXISTS idx_mtime ON thumbnails(mtime);
+    `);
+  }
+  getCacheDir() {
+    return this.cacheDir;
+  }
+  /**
+   * 快速查询缩略图（用路径和修改时间，不需要哈希）
+   * 比计算文件哈希快很多
+   */
+  getThumbnailPathFast(filePath, mtime) {
+    if (!this.db) this.init();
+    const stmt = this.db.prepare(`
+      SELECT thumbnail_path 
+      FROM thumbnails 
+      WHERE file_path = ? AND mtime = ?
+    `);
+    const row = stmt.get(filePath, mtime);
+    if (row && (0, import_node_fs11.existsSync)(row.thumbnail_path)) {
+      return row.thumbnail_path;
+    }
+    return null;
+  }
+  getThumbnailPath(filePath, fileHash, mtime) {
+    if (!this.db) this.init();
+    const stmt = this.db.prepare(`
+      SELECT thumbnail_path, mtime 
+      FROM thumbnails 
+      WHERE file_path = ? AND file_hash = ?
+    `);
+    const row = stmt.get(filePath, fileHash);
+    if (row && row.mtime === mtime && (0, import_node_fs11.existsSync)(row.thumbnail_path)) {
+      return row.thumbnail_path;
+    }
+    return null;
+  }
+  saveThumbnail(filePath, fileHash, mtime, thumbnailPath) {
+    if (!this.db) this.init();
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO thumbnails 
+      (file_path, file_hash, mtime, thumbnail_path, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(filePath, fileHash, mtime, thumbnailPath, Date.now());
+  }
+  deleteThumbnail(filePath) {
+    if (!this.db) this.init();
+    const stmt = this.db.prepare("DELETE FROM thumbnails WHERE file_path = ?");
+    stmt.run(filePath);
+  }
+  cleanupOldThumbnails() {
+    if (!this.db) this.init();
+    const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+    const stmt = this.db.prepare("DELETE FROM thumbnails WHERE created_at < ?");
+    stmt.run(thirtyDaysAgo);
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+var thumbnailDb = null;
+function createSqliteThumbnailDatabase(userDataPath) {
+  if (!thumbnailDb) {
+    thumbnailDb = new SqliteThumbnailDatabase(userDataPath);
+    thumbnailDb.init();
+  }
+  return thumbnailDb;
+}
+function getSqliteThumbnailDatabase() {
+  return thumbnailDb;
+}
+
+// src/thumbnail/processors.ts
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+function createSharpImageProcessor(sharp) {
+  return {
+    async resize(filePath, outputPath, size) {
+      await sharp(filePath).resize(size, size, {
+        fit: "inside",
+        withoutEnlargement: true
+      }).jpeg({ quality: 85 }).toFile(outputPath);
+    }
+  };
+}
+function createFfmpegVideoProcessor(ffmpegPath) {
+  return {
+    async screenshot(filePath, outputPath, timestamp, size) {
+      const scaleSize = size.replace("x", ":");
+      await execFileAsync(ffmpegPath, [
+        "-i",
+        filePath,
+        "-ss",
+        timestamp,
+        "-vframes",
+        "1",
+        "-vf",
+        `scale=${scaleSize}:force_original_aspect_ratio=decrease`,
+        "-y",
+        outputPath
+      ]);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileType,
+  SqliteThumbnailDatabase,
+  ThumbnailService,
+  copyFiles,
+  copyFilesToClipboard,
+  createFfmpegVideoProcessor,
+  createFile,
+  createFolder,
+  createSharpImageProcessor,
+  createSqliteThumbnailDatabase,
+  deleteFiles,
+  exists,
+  formatDate,
+  formatDateTime,
+  formatFileSize,
+  getAllSystemPaths,
+  getApplicationIcon,
+  getClipboardFiles,
+  getFileHash,
+  getFileHashes,
+  getFileInfo,
+  getFileType,
+  getHomeDirectory,
+  getPlatform,
+  getSqliteThumbnailDatabase,
+  getSystemPath,
+  getThumbnailService,
+  initThumbnailService,
+  isDirectory,
+  isMediaFile,
+  isPreviewable,
+  moveFiles,
+  pasteFiles,
+  readDirectory,
+  readFileContent,
+  readImageAsBase64,
+  renameFile,
+  searchFiles,
+  searchFilesStream,
+  searchFilesSync,
+  writeFileContent
+});
+//# sourceMappingURL=index.cjs.map