@file-ud.js/core 0.1.0

package/dist/utils/index.js

@@ -0,0 +1,1609 @@
+'use strict';
+
+var SparkMD5 = require('spark-md5');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var SparkMD5__default = /*#__PURE__*/_interopDefault(SparkMD5);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/md5Worker.ts
+var md5Worker_exports = {};
+__export(md5Worker_exports, {
+  calculateFileMD5InWorker: () => calculateFileMD5InWorker,
+  disposeMD5Worker: () => disposeMD5Worker
+});
+function getWorkerBlobUrl() {
+  if (!_workerBlobUrl) {
+    const blob = new Blob([MD5_IMPL], { type: "text/javascript" });
+    _workerBlobUrl = URL.createObjectURL(blob);
+  }
+  return _workerBlobUrl;
+}
+async function calculateFileMD5InWorker(file, signal) {
+  const WORKER_TIMEOUT_MS = 6e4;
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    const abortHandler = () => {
+      reader.abort();
+      reject(new Error("MD5 \u8BA1\u7B97\u5DF2\u53D6\u6D88"));
+    };
+    if (signal) {
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    reader.onload = () => {
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      const fileBuffer = reader.result;
+      const workerUrl = getWorkerBlobUrl();
+      const worker = new Worker(workerUrl);
+      const timeout = setTimeout(() => {
+        worker.terminate();
+        reject(new Error("MD5 Worker \u8BA1\u7B97\u8D85\u65F6"));
+      }, WORKER_TIMEOUT_MS);
+      worker.onmessage = (e) => {
+        clearTimeout(timeout);
+        worker.terminate();
+        const { error, hash } = e.data;
+        if (error) {
+          reject(new Error(error));
+        } else {
+          resolve(hash);
+        }
+      };
+      worker.onerror = (err) => {
+        clearTimeout(timeout);
+        worker.terminate();
+        reject(new Error(err.message || "MD5 Worker \u5F02\u5E38"));
+      };
+      worker.postMessage({ fileBuffer }, [fileBuffer]);
+    };
+    reader.onerror = () => {
+      if (signal) {
+        signal.removeEventListener("abort", abortHandler);
+      }
+      reject(new Error("\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25"));
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}
+function disposeMD5Worker() {
+  if (_workerBlobUrl) {
+    URL.revokeObjectURL(_workerBlobUrl);
+    _workerBlobUrl = null;
+  }
+}
+var MD5_IMPL, _workerBlobUrl;
+var init_md5Worker = __esm({
+  "src/utils/md5Worker.ts"() {
+    MD5_IMPL = `
+function md5(data) {
+  function rotateLeft(v, n) { return (v << n) | (v >>> (32 - n)); }
+  function addUnsigned(x, y) { return ((x & 0x7fffffff) + (y & 0x7fffffff)) ^ (x & 0x80000000) ^ (y & 0x80000000); }
+
+  var F = function(x,y,z) { return (x & y) | ((~x) & z); };
+  var G = function(x,y,z) { return (x & z) | (y & (~z)); };
+  var H = function(x,y,z) { return x ^ y ^ z; };
+  var I = function(x,y,z) { return y ^ (x | (~z)); };
+
+  function transform(func, a, b, c, d, x, s, ac) {
+    a = addUnsigned(a, addUnsigned(addUnsigned(func(b, c, d), x), ac));
+    return addUnsigned(rotateLeft(a, s), b);
+  }
+
+  // Convert string/array to word array
+  var len = data.length;
+  var words = [];
+  for (var i = 0; i < len; i++) {
+    words[i >> 2] |= data[i] << ((i % 4) * 8);
+  }
+  words[len >> 2] |= 0x80 << ((len % 4) * 8);
+  words[(((len + 8) >>> 6) << 4) + 14] = len * 8;
+
+  var a = 0x67452301, b = 0xefcdab89, c = 0x98badcfe, d = 0x10325476;
+
+  for (var i = 0; i < words.length; i += 16) {
+    var oldA = a, oldB = b, oldC = c, oldD = d;
+    // Round 1
+    a = transform(F, a, b, c, d, words[i+0],  7, 0xd76aa478);
+    d = transform(F, d, a, b, c, words[i+1], 12, 0xe8c7b756);
+    c = transform(F, c, d, a, b, words[i+2], 17, 0x242070db);
+    b = transform(F, b, c, d, a, words[i+3], 22, 0xc1bdceee);
+    a = transform(F, a, b, c, d, words[i+4],  7, 0xf57c0faf);
+    d = transform(F, d, a, b, c, words[i+5], 12, 0x4787c62a);
+    c = transform(F, c, d, a, b, words[i+6], 17, 0xa8304613);
+    b = transform(F, b, c, d, a, words[i+7], 22, 0xfd469501);
+    a = transform(F, a, b, c, d, words[i+8],  7, 0x698098d8);
+    d = transform(F, d, a, b, c, words[i+9], 12, 0x8b44f7af);
+    c = transform(F, c, d, a, b, words[i+10],17, 0xffff5bb1);
+    b = transform(F, b, c, d, a, words[i+11],22, 0x895cd7be);
+    a = transform(F, a, b, c, d, words[i+12], 7, 0x6b901122);
+    d = transform(F, d, a, b, c, words[i+13],12, 0xfd987193);
+    c = transform(F, c, d, a, b, words[i+14],17, 0xa679438e);
+    b = transform(F, b, c, d, a, words[i+15],22, 0x49b40821);
+    // Round 2
+    a = transform(G, a, b, c, d, words[i+1],  5, 0xf61e2562);
+    d = transform(G, d, a, b, c, words[i+6],  9, 0xc040b340);
+    c = transform(G, c, d, a, b, words[i+11],14, 0x265e5a51);
+    b = transform(G, b, c, d, a, words[i+0], 20, 0xe9b6c7aa);
+    a = transform(G, a, b, c, d, words[i+5],  5, 0xd62f105d);
+    d = transform(G, d, a, b, c, words[i+10], 9, 0x02441453);
+    c = transform(G, c, d, a, b, words[i+15],14, 0xd8a1e681);
+    b = transform(G, b, c, d, a, words[i+4], 20, 0xe7d3fbc8);
+    a = transform(G, a, b, c, d, words[i+9],  5, 0x21e1cde6);
+    d = transform(G, d, a, b, c, words[i+14], 9, 0xc33707d6);
+    c = transform(G, c, d, a, b, words[i+3], 14, 0xf4d50d87);
+    b = transform(G, b, c, d, a, words[i+8], 20, 0x455a14ed);
+    a = transform(G, a, b, c, d, words[i+13], 5, 0xa9e3e905);
+    d = transform(G, d, a, b, c, words[i+2],  9, 0xfcefa3f8);
+    c = transform(G, c, d, a, b, words[i+7], 14, 0x676f02d9);
+    b = transform(G, b, c, d, a, words[i+12],20, 0x8d2a4c8a);
+    // Round 3
+    a = transform(H, a, b, c, d, words[i+5],  4, 0xfffa3942);
+    d = transform(H, d, a, b, c, words[i+8], 11, 0x8771f681);
+    c = transform(H, c, d, a, b, words[i+11],16, 0x6d9d6122);
+    b = transform(H, b, c, d, a, words[i+14],23, 0xfde5380c);
+    a = transform(H, a, b, c, d, words[i+1],  4, 0xa4beea44);
+    d = transform(H, d, a, b, c, words[i+4], 11, 0x4bdecfa9);
+    c = transform(H, c, d, a, b, words[i+7], 16, 0xf6bb4b60);
+    b = transform(H, b, c, d, a, words[i+10],23, 0xbebfbc70);
+    a = transform(H, a, b, c, d, words[i+13], 4, 0x289b7ec6);
+    d = transform(H, d, a, b, c, words[i+0], 11, 0xeaa127fa);
+    c = transform(H, c, d, a, b, words[i+3], 16, 0xd4ef3085);
+    b = transform(H, b, c, d, a, words[i+6], 23, 0x04881d05);
+    a = transform(H, a, b, c, d, words[i+9],  4, 0xd9d4d039);
+    d = transform(H, d, a, b, c, words[i+12],11, 0xe6db99e5);
+    c = transform(H, c, d, a, b, words[i+15],16, 0x1fa27cf8);
+    b = transform(H, b, c, d, a, words[i+2], 23, 0xc4ac5665);
+    // Round 4
+    a = transform(I, a, b, c, d, words[i+0],  6, 0xf4292244);
+    d = transform(I, d, a, b, c, words[i+7], 10, 0x432aff97);
+    c = transform(I, c, d, a, b, words[i+14],15, 0xab9423a7);
+    b = transform(I, b, c, d, a, words[i+5], 21, 0xfc93a039);
+    a = transform(I, a, b, c, d, words[i+12], 6, 0x655b59c3);
+    d = transform(I, d, a, b, c, words[i+3], 10, 0x8f0ccc92);
+    c = transform(I, c, d, a, b, words[i+10],15, 0xffeff47d);
+    b = transform(I, b, c, d, a, words[i+1], 21, 0x85845dd1);
+    a = transform(I, a, b, c, d, words[i+8],  6, 0x6fa87e4f);
+    d = transform(I, d, a, b, c, words[i+15],10, 0xfe2ce6e0);
+    c = transform(I, c, d, a, b, words[i+6], 15, 0xa3014314);
+    b = transform(I, b, c, d, a, words[i+13],21, 0x4e0811a1);
+    a = transform(I, a, b, c, d, words[i+4],  6, 0xf7537e82);
+    d = transform(I, d, a, b, c, words[i+11],10, 0xbd3af235);
+    c = transform(I, c, d, a, b, words[i+2], 15, 0x2ad7d2bb);
+    b = transform(I, b, c, d, a, words[i+9], 21, 0xeb86d391);
+    a = addUnsigned(a, oldA);
+    b = addUnsigned(b, oldB);
+    c = addUnsigned(c, oldC);
+    d = addUnsigned(d, oldD);
+  }
+
+  function toHex(v) {
+    var h = ''; for (var j = 0; j < 4; j++) h += ((v >> (j * 8)) & 0xff).toString(16).padStart(2, '0'); return h;
+  }
+  return toHex(a) + toHex(b) + toHex(c) + toHex(d);
+}
+
+self.onmessage = async function(e) {
+  try {
+    var fileBuffer = e.data.fileBuffer;
+    var hash = md5(new Uint8Array(fileBuffer));
+    self.postMessage({ error: null, hash: hash });
+  } catch (err) {
+    self.postMessage({ error: err.message, hash: null });
+  }
+};
+`;
+    _workerBlobUrl = null;
+  }
+});
+
+// src/utils/logger/index.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var LEVEL_LABELS = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+};
+var LEVEL_COLORS = {
+  [0 /* DEBUG */]: "\x1B[36m",
+  // 青色
+  [1 /* INFO */]: "\x1B[32m",
+  // 绿色
+  [2 /* WARN */]: "\x1B[33m",
+  // 黄色
+  [3 /* ERROR */]: "\x1B[31m"
+  // 红色
+};
+var RESET_COLOR = "\x1B[0m";
+var DEFAULT_OPTIONS = {
+  enabled: false,
+  level: typeof process !== "undefined" && process.env?.NODE_ENV === "production" ? 2 /* WARN */ : 0 /* DEBUG */,
+  showTimestamp: true,
+  enableColors: typeof process !== "undefined" && process.env?.NODE_ENV !== "production"
+};
+var currentOptions = { ...DEFAULT_OPTIONS };
+var logCollectors = [];
+function getLogLevelFromEnv() {
+  if (typeof process === "undefined" || !process.env)
+    return void 0;
+  const envLevel = process.env.VITE_LOG_LEVEL || process.env.LOG_LEVEL;
+  if (!envLevel)
+    return void 0;
+  const levelMap = {
+    debug: 0 /* DEBUG */,
+    info: 1 /* INFO */,
+    warn: 2 /* WARN */,
+    error: 3 /* ERROR */
+  };
+  return levelMap[envLevel.toLowerCase()];
+}
+function initLogger(options) {
+  const envLevel = getLogLevelFromEnv();
+  currentOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options || {},
+    // 环境变量优先级最高
+    ...envLevel !== void 0 ? { level: envLevel } : {}
+  };
+  console.log(`[Logger] Initialized with level: ${LEVEL_LABELS[currentOptions.level]}`);
+}
+function setLogLevel(level) {
+  currentOptions.level = level;
+}
+function addLogCollector(callback) {
+  logCollectors.push(callback);
+  return () => {
+    const index = logCollectors.indexOf(callback);
+    if (index > -1) {
+      logCollectors.splice(index, 1);
+    }
+  };
+}
+function clearLogCollectors() {
+  logCollectors.length = 0;
+}
+function formatMessage(level, module, message, args) {
+  const parts = [];
+  if (currentOptions.showTimestamp) {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    const milliseconds = String(now.getMilliseconds()).padStart(3, "0");
+    const timeStr = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    parts.push(`[${timeStr}]`);
+  }
+  const label = LEVEL_LABELS[level];
+  if (currentOptions.enableColors) {
+    parts.push(`${LEVEL_COLORS[level]}[${label}]${RESET_COLOR}`);
+  } else {
+    parts.push(`[${label}]`);
+  }
+  parts.push(`[${module}]`);
+  parts.push(message);
+  return parts.join(" ");
+}
+function extractStack(arg) {
+  if (arg instanceof Error) {
+    return arg.stack || arg.message;
+  }
+  return null;
+}
+function log(level, module, message, ...args) {
+  if (!currentOptions.enabled) {
+    return;
+  }
+  if (level < (currentOptions.level ?? 0 /* DEBUG */)) {
+    return;
+  }
+  const formattedMessage = formatMessage(level, module, message);
+  let stackInfo;
+  try {
+    const error = new Error();
+    const stackLines = error.stack?.split("\n") || [];
+    if (stackLines.length >= 3) {
+      stackInfo = stackLines[3].trim();
+    }
+  } catch (e) {
+  }
+  const outputArgs = stackInfo ? [...args, `
+    ${stackInfo}`] : args;
+  switch (level) {
+    case 0 /* DEBUG */:
+      console.debug(formattedMessage, ...outputArgs);
+      break;
+    case 1 /* INFO */:
+      console.info(formattedMessage, ...outputArgs);
+      break;
+    case 2 /* WARN */:
+      console.warn(formattedMessage, ...outputArgs);
+      break;
+    case 3 /* ERROR */:
+      console.error(formattedMessage, ...outputArgs);
+      break;
+  }
+  if (logCollectors.length > 0) {
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      module,
+      message,
+      args
+    };
+    const stack = args.find(extractStack);
+    if (stack) {
+      entry.stack = extractStack(stack) || void 0;
+    }
+    logCollectors.forEach((collector) => {
+      try {
+        const result = collector(entry);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error("[Logger] Collector error:", error);
+          });
+        }
+      } catch (error) {
+        console.error("[Logger] Collector error:", error);
+      }
+    });
+  }
+}
+var logger = {
+  /**
+   * 调试日志（仅开发环境）
+   * @param module 模块名称
+   * @param message 消息内容
+   * @param args 额外参数
+   */
+  debug: (module, message, ...args) => {
+    message = `\u{1F50D} ${message}`;
+    log(0 /* DEBUG */, module, message, ...args);
+  },
+  /**
+   * 信息日志
+   * @param module 模块名称
+   * @param message 消息内容
+   * @param args 额外参数
+   */
+  info: (module, message, ...args) => {
+    message = `\u2705 ${message}`;
+    log(1 /* INFO */, module, message, ...args);
+  },
+  /**
+   * 警告日志
+   * @param module 模块名称
+   * @param message 消息内容
+   * @param args 额外参数
+   */
+  warn: (module, message, ...args) => {
+    message = `\u26A0\uFE0F ${message}`;
+    log(2 /* WARN */, module, message, ...args);
+  },
+  /**
+   * 错误日志
+   * @param module 模块名称
+   * @param message 消息内容
+   * @param args 额外参数
+   */
+  error: (module, message, ...args) => {
+    message = `\u274C ${message}`;
+    log(3 /* ERROR */, module, message, ...args);
+  }
+};
+
+// src/utils/fileCache.ts
+var DB_NAME = "file-ud-cache";
+var DB_VERSION = 3;
+var STORE_NAME = "files";
+var DOWNLOAD_PROGRESS_STORE = "download-progress";
+var FILE_HANDLE_STORE = "file-handles";
+var dbInstance = null;
+var dbOpeningPromise = null;
+function openDB() {
+  if (dbInstance && dbInstance.version === DB_VERSION) {
+    try {
+      dbInstance.transaction([STORE_NAME], "readonly");
+      return Promise.resolve(dbInstance);
+    } catch (error) {
+      logger.warn("FileCache", "\u6570\u636E\u5E93\u8FDE\u63A5\u5DF2\u5931\u6548\uFF0C\u91CD\u65B0\u6253\u5F00", error);
+      dbInstance = null;
+      dbOpeningPromise = null;
+    }
+  }
+  if (dbOpeningPromise) {
+    return dbOpeningPromise;
+  }
+  dbOpeningPromise = new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => {
+      logger.error("FileCache", "\u6253\u5F00 IndexedDB \u5931\u8D25", request.error);
+      dbOpeningPromise = null;
+      reject(request.error);
+    };
+    request.onsuccess = () => {
+      dbInstance = request.result;
+      dbOpeningPromise = null;
+      dbInstance.onclose = () => {
+        logger.warn("FileCache", "\u6570\u636E\u5E93\u8FDE\u63A5\u5DF2\u5173\u95ED");
+        dbInstance = null;
+      };
+      dbInstance.onerror = (event) => {
+        logger.error("FileCache", "\u6570\u636E\u5E93\u8FDE\u63A5\u9519\u8BEF", event);
+        dbInstance = null;
+      };
+      resolve(dbInstance);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: "fileHash" });
+        store.createIndex("fileName", "fileName", { unique: false });
+        store.createIndex("createdAt", "createdAt", { unique: false });
+        store.createIndex("lastAccessedAt", "lastAccessedAt", { unique: false });
+        logger.info("FileCache", "IndexedDB \u6587\u4EF6\u7F13\u5B58\u5B58\u50A8\u521D\u59CB\u5316\u6210\u529F");
+      }
+      if (!db.objectStoreNames.contains(DOWNLOAD_PROGRESS_STORE)) {
+        const progressStore = db.createObjectStore(DOWNLOAD_PROGRESS_STORE, { keyPath: "fileHash" });
+        progressStore.createIndex("updatedAt", "updatedAt", { unique: false });
+        logger.info("FileCache", "IndexedDB \u4E0B\u8F7D\u8FDB\u5EA6\u5B58\u50A8\u521D\u59CB\u5316\u6210\u529F");
+      }
+      if (!db.objectStoreNames.contains(FILE_HANDLE_STORE)) {
+        const handleStore = db.createObjectStore(FILE_HANDLE_STORE, { keyPath: "fileName" });
+        handleStore.createIndex("updatedAt", "updatedAt", { unique: false });
+        logger.info("FileCache", "IndexedDB \u6587\u4EF6\u53E5\u67C4\u5B58\u50A8\u521D\u59CB\u5316\u6210\u529F");
+      }
+    };
+  });
+  return dbOpeningPromise;
+}
+function closeDB() {
+  if (dbInstance) {
+    try {
+      dbInstance.close();
+      logger.debug("FileCache", "\u6570\u636E\u5E93\u8FDE\u63A5\u5DF2\u5173\u95ED");
+    } catch (error) {
+      logger.warn("FileCache", "\u5173\u95ED\u6570\u636E\u5E93\u8FDE\u63A5\u65F6\u51FA\u9519", error);
+    } finally {
+      dbInstance = null;
+      dbOpeningPromise = null;
+    }
+  }
+}
+async function executeTransaction(operation) {
+  try {
+    const db = await openDB();
+    return await operation(db);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "InvalidStateError") {
+      logger.warn("FileCache", "\u68C0\u6D4B\u5230\u65E0\u6548\u72B6\u6001\u9519\u8BEF\uFF0C\u91CD\u7F6E\u8FDE\u63A5\u540E\u91CD\u8BD5", error);
+      closeDB();
+      const db = await openDB();
+      return await operation(db);
+    }
+    throw error;
+  }
+}
+async function saveFileToCache(fileHash, file) {
+  try {
+    const arrayBuffer = await file.arrayBuffer();
+    const record = {
+      fileHash,
+      fileName: file.name,
+      fileType: file.type,
+      fileSize: file.size,
+      data: arrayBuffer,
+      createdAt: Date.now(),
+      lastAccessedAt: Date.now()
+    };
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.put(record);
+        request.onsuccess = () => {
+          logger.debug("FileCache", `\u6587\u4EF6\u5DF2\u7F13\u5B58: ${file.name} (${formatFileSize(file.size)})`, {
+            fileHash,
+            fileSize: file.size
+          });
+          resolve();
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u4FDD\u5B58\u6587\u4EF6\u7F13\u5B58\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u4FDD\u5B58\u6587\u4EF6\u7F13\u5B58\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function restoreFileFromCache(fileHash) {
+  try {
+    return await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readonly");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(fileHash);
+        request.onsuccess = () => {
+          const record = request.result;
+          if (!record) {
+            logger.debug("FileCache", `\u672A\u627E\u5230\u7F13\u5B58\u6587\u4EF6: ${fileHash}`);
+            resolve(null);
+            return;
+          }
+          updateLastAccessedTime(fileHash);
+          const blob = new Blob([record.data], { type: record.fileType });
+          const file = new File([blob], record.fileName, { type: record.fileType });
+          logger.debug("FileCache", `\u6210\u529F\u6062\u590D\u7F13\u5B58\u6587\u4EF6: ${record.fileName}`, {
+            fileHash,
+            fileSize: record.fileSize
+          });
+          resolve(file);
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u6062\u590D\u6587\u4EF6\u7F13\u5B58\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u6062\u590D\u6587\u4EF6\u7F13\u5B58\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function removeFileFromCache(fileHash) {
+  try {
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.delete(fileHash);
+        request.onsuccess = () => {
+          logger.debug("FileCache", `\u5DF2\u5220\u9664\u6587\u4EF6\u7F13\u5B58: ${fileHash}`);
+          resolve();
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u5220\u9664\u6587\u4EF6\u7F13\u5B58\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u5220\u9664\u6587\u4EF6\u7F13\u5B58\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function clearAllFileCache() {
+  try {
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.clear();
+        request.onsuccess = () => {
+          logger.info("FileCache", "\u5DF2\u6E05\u7A7A\u6240\u6709\u6587\u4EF6\u7F13\u5B58");
+          resolve();
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u6E05\u7A7A\u6587\u4EF6\u7F13\u5B58\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u6E05\u7A7A\u6587\u4EF6\u7F13\u5B58\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function getCacheStats() {
+  try {
+    return await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readonly");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const records = request.result || [];
+          const totalSize = records.reduce((sum, record) => sum + record.fileSize, 0);
+          resolve({
+            count: records.length,
+            totalSize
+          });
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u83B7\u53D6\u7F13\u5B58\u7EDF\u8BA1\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u83B7\u53D6\u7F13\u5B58\u7EDF\u8BA1\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function cleanExpiredCache(days = 7) {
+  try {
+    const cutoffTime = Date.now() - days * 24 * 60 * 60 * 1e3;
+    return await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const index = store.index("lastAccessedAt");
+        const request = index.getAll();
+        request.onsuccess = () => {
+          const records = request.result || [];
+          const expiredRecords = records.filter(
+            (record) => record.lastAccessedAt < cutoffTime
+          );
+          let deletedCount = 0;
+          const deletePromises = expiredRecords.map((record) => {
+            return new Promise((resolveDelete, rejectDelete) => {
+              const deleteRequest = store.delete(record.fileHash);
+              deleteRequest.onsuccess = () => {
+                deletedCount++;
+                resolveDelete();
+              };
+              deleteRequest.onerror = () => {
+                logger.error("FileCache", `\u5220\u9664\u8FC7\u671F\u7F13\u5B58\u5931\u8D25: ${record.fileHash}`, deleteRequest.error);
+                resolveDelete();
+              };
+            });
+          });
+          Promise.all(deletePromises).then(() => {
+            if (deletedCount > 0) {
+              logger.info("FileCache", `\u5DF2\u6E05\u7406 ${deletedCount} \u4E2A\u8FC7\u671F\u7F13\u5B58`);
+            }
+            resolve(deletedCount);
+          });
+        };
+        request.onerror = () => {
+          logger.error("FileCache", "\u67E5\u8BE2\u8FC7\u671F\u7F13\u5B58\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.error("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.error("FileCache", "\u6E05\u7406\u8FC7\u671F\u7F13\u5B58\u5F02\u5E38", error);
+    throw error;
+  }
+}
+async function updateLastAccessedTime(fileHash) {
+  try {
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([STORE_NAME], "readwrite");
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(fileHash);
+        request.onsuccess = () => {
+          const record = request.result;
+          if (record) {
+            record.lastAccessedAt = Date.now();
+            const updateRequest = store.put(record);
+            updateRequest.onsuccess = () => resolve();
+            updateRequest.onerror = () => {
+              logger.warn("FileCache", "\u66F4\u65B0\u8BBF\u95EE\u65F6\u95F4\u5931\u8D25", updateRequest.error);
+              resolve();
+            };
+          } else {
+            resolve();
+          }
+        };
+        request.onerror = () => {
+          logger.warn("FileCache", "\u67E5\u8BE2\u8BB0\u5F55\u5931\u8D25", request.error);
+          resolve();
+        };
+        transaction.onerror = () => {
+          logger.warn("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          resolve();
+        };
+      });
+    });
+  } catch (error) {
+    logger.warn("FileCache", "\u66F4\u65B0\u8BBF\u95EE\u65F6\u95F4\u5F02\u5E38", error);
+  }
+}
+async function saveFileHandle(fileName, fileHandle) {
+  try {
+    const record = {
+      fileName,
+      fileHandle,
+      updatedAt: Date.now()
+    };
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([FILE_HANDLE_STORE], "readwrite");
+        const store = transaction.objectStore(FILE_HANDLE_STORE);
+        const request = store.put(record);
+        request.onsuccess = () => {
+          logger.debug("FileCache", `\u6587\u4EF6\u53E5\u67C4\u5DF2\u6301\u4E45\u5316: ${fileName}`);
+          resolve();
+        };
+        request.onerror = () => {
+          logger.warn("FileCache", "\u4FDD\u5B58\u6587\u4EF6\u53E5\u67C4\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.warn("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.warn("FileCache", "\u4FDD\u5B58\u6587\u4EF6\u53E5\u67C4\u5F02\u5E38", error);
+  }
+}
+async function loadFileHandle(fileName) {
+  try {
+    return await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([FILE_HANDLE_STORE], "readonly");
+        const store = transaction.objectStore(FILE_HANDLE_STORE);
+        const request = store.get(fileName);
+        request.onsuccess = () => {
+          const record = request.result;
+          if (!record) {
+            logger.debug("FileCache", `\u672A\u627E\u5230\u6301\u4E45\u5316\u6587\u4EF6\u53E5\u67C4: ${fileName}`);
+            resolve(null);
+            return;
+          }
+          try {
+            record.fileHandle.getFile().then(
+              () => {
+                logger.debug("FileCache", `\u6587\u4EF6\u53E5\u67C4\u6709\u6548: ${fileName}`);
+                resolve(record.fileHandle);
+              },
+              () => {
+                logger.warn("FileCache", `\u6587\u4EF6\u53E5\u67C4\u5DF2\u5931\u6548\uFF08\u6743\u9650\u64A4\u9500\uFF09: ${fileName}`);
+                removeFileHandle(fileName);
+                resolve(null);
+              }
+            );
+          } catch {
+            removeFileHandle(fileName);
+            resolve(null);
+          }
+        };
+        request.onerror = () => {
+          logger.warn("FileCache", "\u52A0\u8F7D\u6587\u4EF6\u53E5\u67C4\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.warn("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.warn("FileCache", "\u52A0\u8F7D\u6587\u4EF6\u53E5\u67C4\u5F02\u5E38", error);
+    return null;
+  }
+}
+async function removeFileHandle(fileName) {
+  try {
+    await executeTransaction(async (db) => {
+      return new Promise((resolve, reject) => {
+        const transaction = db.transaction([FILE_HANDLE_STORE], "readwrite");
+        const store = transaction.objectStore(FILE_HANDLE_STORE);
+        const request = store.delete(fileName);
+        request.onsuccess = () => {
+          logger.debug("FileCache", `\u5DF2\u5220\u9664\u6587\u4EF6\u53E5\u67C4: ${fileName}`);
+          resolve();
+        };
+        request.onerror = () => {
+          logger.warn("FileCache", "\u5220\u9664\u6587\u4EF6\u53E5\u67C4\u5931\u8D25", request.error);
+          reject(request.error);
+        };
+        transaction.onerror = () => {
+          logger.warn("FileCache", "\u4E8B\u52A1\u6267\u884C\u5931\u8D25", transaction.error);
+          reject(transaction.error);
+        };
+      });
+    });
+  } catch (error) {
+    logger.warn("FileCache", "\u5220\u9664\u6587\u4EF6\u53E5\u67C4\u5F02\u5E38", error);
+  }
+}
+
+// src/utils/upload-monitor/index.ts
+var UploadMonitor = class {
+  constructor() {
+    /** 上传记录列表 */
+    this.records = [];
+    /** 当前活跃的上传任务 */
+    this.activeUploads = /* @__PURE__ */ new Map();
+    /** 最大保留记录数 */
+    this.MAX_RECORDS = 1e3;
+    this.init();
+  }
+  /**
+   * 初始化日志收集器
+   */
+  init() {
+    addLogCollector((entry) => {
+      this.processLog(entry);
+    });
+  }
+  /**
+   * 处理日志条目
+   */
+  processLog(entry) {
+    if (entry.message.includes("\u4E0A\u4F20") || entry.message.includes("\u6587\u4EF6")) {
+      console.log("[Monitor Debug] \u6536\u5230\u65E5\u5FD7:", {
+        module: entry.module,
+        message: entry.message,
+        args: entry.args,
+        timestamp: entry.timestamp
+      });
+    }
+    if (entry.message.includes("\u5F00\u59CB\u4E0A\u4F20\u6587\u4EF6") && !entry.message.includes("\u5206\u7247")) {
+      const fileId = this.extractFileId(entry);
+      console.log("[Monitor Debug] \u5339\u914D\u5230\u5F00\u59CB\u4E0A\u4F20:", { fileId, hasFileId: !!fileId });
+      if (fileId && !this.activeUploads.has(fileId)) {
+        const record = {
+          fileId,
+          fileName: this.extractFileName(entry) || "unknown",
+          fileSize: this.extractFileSize(entry) || 0,
+          startTime: entry.timestamp,
+          success: false,
+          retryCount: 0
+        };
+        this.activeUploads.set(fileId, record);
+      }
+    }
+    if (entry.message.includes("\u6587\u4EF6\u4F20\u8F93\u6210\u529F")) {
+      const fileId = this.extractFileId(entry);
+      console.log("[Monitor Debug] \u5339\u914D\u5230\u4E0A\u4F20\u6210\u529F:", { fileId, hasFileId: !!fileId });
+      if (fileId) {
+        if (!this.activeUploads.has(fileId)) {
+          const record2 = {
+            fileId,
+            fileName: this.extractFileName(entry) || "unknown",
+            fileSize: this.extractFileSize(entry) || 0,
+            startTime: 0,
+            // ✅ 标记为未知，避免错误的耗时计算
+            endTime: entry.timestamp,
+            success: true,
+            retryCount: 0
+          };
+          this.finalizeRecord(record2);
+          return;
+        }
+        const record = this.activeUploads.get(fileId);
+        record.endTime = entry.timestamp;
+        record.success = true;
+        if (record.fileSize === 0) {
+          const extractedSize = this.extractFileSize(entry);
+          if (extractedSize) {
+            record.fileSize = extractedSize;
+          }
+        }
+        this.finalizeRecord(record);
+        this.activeUploads.delete(fileId);
+      }
+    }
+    if (entry.level === 3 /* ERROR */) {
+      const fileId = this.extractFileId(entry);
+      if (entry.module === "uploadChunkManager") {
+        if (fileId && this.activeUploads.has(fileId)) {
+          const record = this.activeUploads.get(fileId);
+          if (!record.errorModules) {
+            record.errorModules = /* @__PURE__ */ new Map();
+          }
+          record.errorModules.set("uploadChunkManager", (record.errorModules.get("uploadChunkManager") || 0) + 1);
+          if (entry.message.includes("\u5206\u7247") && entry.message.includes("\u5931\u8D25")) {
+            record.failedChunks = (record.failedChunks || 0) + 1;
+          }
+          if (entry.message.includes("\u6700\u7EC8\u5931\u8D25")) {
+            record.endTime = entry.timestamp;
+            record.success = false;
+            record.error = entry.message;
+            if (record.fileSize === 0) {
+              const extractedSize = this.extractFileSize(entry);
+              if (extractedSize) {
+                record.fileSize = extractedSize;
+              }
+            }
+            this.finalizeRecord(record);
+            this.activeUploads.delete(fileId);
+          }
+        }
+      }
+      if (entry.module === "UploadFile") {
+        if (fileId && this.activeUploads.has(fileId)) {
+          const record = this.activeUploads.get(fileId);
+          if (!record.errorModules) {
+            record.errorModules = /* @__PURE__ */ new Map();
+          }
+          record.errorModules.set("UploadFile", (record.errorModules.get("UploadFile") || 0) + 1);
+          record.endTime = entry.timestamp;
+          record.success = false;
+          record.error = entry.message;
+          if (record.fileSize === 0) {
+            const extractedSize = this.extractFileSize(entry);
+            if (extractedSize) {
+              record.fileSize = extractedSize;
+            }
+          }
+          this.finalizeRecord(record);
+          this.activeUploads.delete(fileId);
+        }
+      }
+    }
+    if (entry.message.includes("\u91CD\u8BD5")) {
+      const fileId = this.extractFileId(entry);
+      if (fileId && this.activeUploads.has(fileId)) {
+        const record = this.activeUploads.get(fileId);
+        record.retryCount++;
+      }
+    }
+    if (entry.module === "uploadChunkManager" && entry.message.includes("\u5206\u7247\u5207\u5272\u5B8C\u6210")) {
+      const fileId = this.extractFileId(entry);
+      if (fileId && this.activeUploads.has(fileId)) {
+        const record = this.activeUploads.get(fileId);
+        const totalChunks = this.extractTotalChunks(entry);
+        if (totalChunks) {
+          record.totalChunks = totalChunks;
+          record.chunks = 0;
+          record.failedChunks = 0;
+        }
+      }
+    }
+  }
+  /**
+   * 完成记录并添加到历史
+   */
+  finalizeRecord(record) {
+    if (record.totalChunks) {
+      record.chunks = record.totalChunks - (record.failedChunks || 0);
+    }
+    const existingIndex = this.records.findIndex((r) => r.fileId === record.fileId);
+    if (existingIndex !== -1) {
+      this.records[existingIndex] = record;
+    } else {
+      this.records.push(record);
+    }
+    if (this.records.length > this.MAX_RECORDS) {
+      this.records.shift();
+    }
+  }
+  /**
+   * 从日志条目中提取 fileId
+   */
+  extractFileId(entry) {
+    if (entry.args?.length) {
+      for (const arg of entry.args) {
+        if (arg && typeof arg === "object" && "fileId" in arg) {
+          return String(arg.fileId);
+        }
+      }
+    }
+    const match = entry.message.match(/fileId[=:]\s*(\w+)/);
+    if (match) {
+      return match[1];
+    }
+    return null;
+  }
+  /**
+   * 从日志条目中提取文件名
+   */
+  extractFileName(entry) {
+    if (entry.args?.length) {
+      for (const arg of entry.args) {
+        if (typeof arg === "string") {
+          return arg;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 从日志条目中提取文件大小
+   */
+  extractFileSize(entry) {
+    if (entry.args?.length) {
+      for (const arg of entry.args) {
+        if (arg && typeof arg === "object" && "size" in arg && typeof arg.size === "number") {
+          return arg.size;
+        }
+        if (arg && typeof arg === "object" && "fileSize" in arg && typeof arg.fileSize === "number") {
+          return arg.fileSize;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 从日志条目中提取分片总数
+   */
+  extractTotalChunks(entry) {
+    if (entry.args?.length) {
+      for (const arg of entry.args) {
+        if (arg && typeof arg === "object" && "totalChunks" in arg && typeof arg.totalChunks === "number") {
+          return arg.totalChunks;
+        }
+      }
+    }
+    const match = entry.message.match(/(\d+)\s*\/\s*\d+/);
+    if (match) {
+      return parseInt(match[1], 10);
+    }
+    return null;
+  }
+  /**
+   * 获取上传统计数据
+   */
+  getStats() {
+    const completedRecords = this.records.filter((r) => r.endTime);
+    if (completedRecords.length === 0) {
+      return {
+        totalUploads: 0,
+        successfulUploads: 0,
+        failedUploads: 0,
+        successRate: 0,
+        averageDuration: 0,
+        minDuration: 0,
+        maxDuration: 0,
+        medianDuration: 0,
+        averageFileSize: 0,
+        totalBytesUploaded: 0,
+        averageSpeed: 0,
+        errorsByType: /* @__PURE__ */ new Map(),
+        errorsByModule: /* @__PURE__ */ new Map(),
+        averageRetries: 0
+      };
+    }
+    const successful = completedRecords.filter((r) => r.success);
+    const failed = completedRecords.filter((r) => !r.success);
+    const durations = completedRecords.filter((r) => r.startTime > 0 && r.endTime).map((r) => r.endTime - r.startTime).filter((d) => d > 0);
+    const averageDuration = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+    const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+    const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+    const sortedDurations = [...durations].sort((a, b) => a - b);
+    const medianDuration = sortedDurations.length > 0 ? sortedDurations[Math.floor(sortedDurations.length / 2)] : 0;
+    const fileSizes = completedRecords.map((r) => r.fileSize).filter((s) => s > 0);
+    const averageFileSize = fileSizes.length > 0 ? Math.round(fileSizes.reduce((a, b) => a + b, 0) / fileSizes.length) : 0;
+    const totalBytesUploaded = successful.reduce((sum, r) => sum + r.fileSize, 0);
+    const totalDuration = durations.reduce((a, b) => a + b, 0);
+    const averageSpeed = totalDuration > 0 ? Math.round(totalBytesUploaded / (totalDuration / 1e3)) : 0;
+    const errorsByType = /* @__PURE__ */ new Map();
+    const errorsByModule = /* @__PURE__ */ new Map();
+    failed.forEach((record) => {
+      if (record.error) {
+        const errorType = this.classifyError(record.error);
+        errorsByType.set(errorType, (errorsByType.get(errorType) || 0) + 1);
+      }
+      if (record.errorModules) {
+        record.errorModules.forEach((count, module) => {
+          errorsByModule.set(module, (errorsByModule.get(module) || 0) + count);
+        });
+      }
+    });
+    const totalRetries = completedRecords.reduce((sum, r) => sum + r.retryCount, 0);
+    const averageRetries = completedRecords.length > 0 ? Math.round(totalRetries / completedRecords.length * 100) / 100 : 0;
+    const chunkRecords = completedRecords.filter((r) => r.totalChunks);
+    let chunkUploadStats;
+    if (chunkRecords.length > 0) {
+      const totalChunks = chunkRecords.reduce((sum, r) => sum + (r.totalChunks || 0), 0);
+      const successfulChunks = chunkRecords.reduce((sum, r) => sum + (r.chunks || 0), 0);
+      const failedChunks = chunkRecords.reduce((sum, r) => sum + (r.failedChunks || 0), 0);
+      chunkUploadStats = {
+        totalChunks,
+        successfulChunks,
+        failedChunks,
+        chunkSuccessRate: totalChunks > 0 ? Math.round(successfulChunks / totalChunks * 1e4) / 100 : 0
+      };
+    }
+    return {
+      totalUploads: completedRecords.length,
+      successfulUploads: successful.length,
+      failedUploads: failed.length,
+      successRate: Math.round(successful.length / completedRecords.length * 1e4) / 100,
+      averageDuration,
+      minDuration,
+      maxDuration,
+      medianDuration,
+      averageFileSize,
+      totalBytesUploaded,
+      averageSpeed,
+      errorsByType,
+      errorsByModule,
+      averageRetries,
+      chunkUploadStats
+    };
+  }
+  /**
+   * 分类错误类型
+   */
+  classifyError(errorMessage) {
+    if (errorMessage.includes("\u7F51\u7EDC") || errorMessage.includes("timeout")) {
+      return "NETWORK_ERROR";
+    }
+    if (errorMessage.includes("\u670D\u52A1\u5668") || errorMessage.includes("500")) {
+      return "SERVER_ERROR";
+    }
+    if (errorMessage.includes("\u672A\u6388\u6743") || errorMessage.includes("401")) {
+      return "AUTH_ERROR";
+    }
+    if (errorMessage.includes("\u5206\u7247")) {
+      return "CHUNK_ERROR";
+    }
+    if (errorMessage.includes("\u5408\u5E76")) {
+      return "MERGE_ERROR";
+    }
+    return "UNKNOWN_ERROR";
+  }
+  /**
+   * 获取最近 N 条上传记录
+   */
+  getRecentRecords(count = 10) {
+    return this.records.slice(-count).reverse();
+  }
+  /**
+   * 获取活跃上传任务
+   */
+  getActiveUploads() {
+    return new Map(this.activeUploads);
+  }
+  /**
+   * 重置所有统计数据
+   */
+  reset() {
+    this.records = [];
+    this.activeUploads.clear();
+  }
+  /**
+   * 导出统计数据为 JSON
+   */
+  exportToJSON() {
+    const stats = this.getStats();
+    const serializableStats = {
+      ...stats,
+      errorsByType: Object.fromEntries(stats.errorsByType),
+      errorsByModule: Object.fromEntries(stats.errorsByModule),
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return JSON.stringify(serializableStats, null, 2);
+  }
+  /**
+   * 打印统计报告到控制台
+   */
+  printReport() {
+    const stats = this.getStats();
+    console.group("\u{1F4CA} \u4E0A\u4F20\u6027\u80FD\u76D1\u63A7\u62A5\u544A");
+    console.log("\u603B\u4E0A\u4F20\u6570:", stats.totalUploads);
+    console.log("\u6210\u529F\u4E0A\u4F20:", stats.successfulUploads);
+    console.log("\u5931\u8D25\u4E0A\u4F20:", stats.failedUploads);
+    console.log("\u6210\u529F\u7387:", `${stats.successRate}%`);
+    console.log("\u5E73\u5747\u8017\u65F6:", `${stats.averageDuration}ms`);
+    console.log("\u6700\u77ED\u8017\u65F6:", `${stats.minDuration}ms`);
+    console.log("\u6700\u957F\u8017\u65F6:", `${stats.maxDuration}ms`);
+    console.log("\u4E2D\u4F4D\u6570\u8017\u65F6:", `${stats.medianDuration}ms`);
+    console.log("\u5E73\u5747\u6587\u4EF6\u5927\u5C0F:", `${stats.averageFileSize} bytes`);
+    console.log("\u603B\u4E0A\u4F20\u6570\u636E\u91CF:", `${stats.totalBytesUploaded} bytes`);
+    console.log("\u5E73\u5747\u4E0A\u4F20\u901F\u5EA6:", `${stats.averageSpeed} bytes/s`);
+    console.log("\u5E73\u5747\u91CD\u8BD5\u6B21\u6570:", stats.averageRetries);
+    if (stats.chunkUploadStats) {
+      console.group("\u5206\u7247\u4E0A\u4F20\u7EDF\u8BA1");
+      console.log("\u603B\u5206\u7247\u6570:", stats.chunkUploadStats.totalChunks);
+      console.log("\u6210\u529F\u5206\u7247:", stats.chunkUploadStats.successfulChunks);
+      console.log("\u5931\u8D25\u5206\u7247:", stats.chunkUploadStats.failedChunks);
+      console.log("\u5206\u7247\u6210\u529F\u7387:", `${stats.chunkUploadStats.chunkSuccessRate}%`);
+      console.groupEnd();
+    }
+    if (stats.errorsByType.size > 0) {
+      console.group("\u9519\u8BEF\u7C7B\u578B\u5206\u5E03");
+      stats.errorsByType.forEach((count, type) => {
+        console.log(`${type}:`, count);
+      });
+      console.groupEnd();
+    }
+    if (stats.errorsByModule.size > 0) {
+      console.group("\u9519\u8BEF\u6A21\u5757\u5206\u5E03");
+      stats.errorsByModule.forEach((count, module) => {
+        console.log(`${module}:`, count);
+      });
+      console.groupEnd();
+    }
+    console.groupEnd();
+  }
+};
+var uploadMonitor = new UploadMonitor();
+
+// src/utils/network.ts
+function checkNetworkStatus() {
+  const result = {
+    online: navigator.onLine,
+    timestamp: Date.now()
+  };
+  if (!result.online) {
+    result.error = "\u7F51\u7EDC\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8BBE\u7F6E\u540E\u91CD\u8BD5";
+  }
+  return result;
+}
+async function checkNetworkConnectivity(testUrl, timeout = 5e3) {
+  const basicCheck = checkNetworkStatus();
+  if (!basicCheck.online) {
+    return basicCheck;
+  }
+  const url = testUrl || window.location.origin;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    await fetch(url, {
+      method: "HEAD",
+      signal: controller.signal,
+      cache: "no-cache"
+    });
+    clearTimeout(timeoutId);
+    return {
+      online: true,
+      timestamp: Date.now()
+    };
+  } catch (error) {
+    return {
+      online: false,
+      timestamp: Date.now(),
+      error: error instanceof Error ? error.message : "\u7F51\u7EDC\u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25"
+    };
+  }
+}
+function watchNetworkStatus(callback) {
+  const handleOnline = () => callback(true);
+  const handleOffline = () => callback(false);
+  window.addEventListener("online", handleOnline);
+  window.addEventListener("offline", handleOffline);
+  return () => {
+    window.removeEventListener("online", handleOnline);
+    window.removeEventListener("offline", handleOffline);
+  };
+}
+
+// src/utils/index.ts
+init_md5Worker();
+function generateFileId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `file_${timestamp}_${random}`;
+}
+function mergeObjects(target, source) {
+  if (!target || typeof target !== "object" || Array.isArray(target)) {
+    throw new TypeError("Target must be a valid object");
+  }
+  if (source && (typeof source !== "object" || Array.isArray(source))) {
+    throw new TypeError("Source must be an object, undefined, or null");
+  }
+  if (!source) {
+    return { ...target };
+  }
+  return { ...target, ...source };
+}
+function handleFile(file) {
+  return new Promise((resolve, reject) => {
+    if (file.size > 10 * 1024 * 1024) {
+      try {
+        resolve(URL.createObjectURL(file));
+      } catch (error) {
+        reject(new Error(`\u521B\u5EFAObject URL\u5931\u8D25: ${error.message}`));
+      }
+    } else {
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        resolve(e.target?.result);
+      };
+      reader.onerror = () => {
+        reject(new Error("\u6587\u4EF6\u8BFB\u53D6\u9519\u8BEF"));
+      };
+      reader.onabort = () => {
+        reject(new Error("\u6587\u4EF6\u8BFB\u53D6\u88AB\u4E2D\u6B62"));
+      };
+      reader.readAsDataURL(file);
+    }
+  });
+}
+function computeTransferTime(transferTime) {
+  return {
+    start() {
+      const now = Date.now();
+      transferTime.startTime = now;
+      transferTime.endTime = 0;
+      transferTime.duration = 0;
+      transferTime.durationFormatted = "0s";
+    },
+    end() {
+      const endTime = Date.now();
+      const duration = endTime - transferTime.startTime;
+      transferTime.endTime = endTime;
+      transferTime.duration = duration;
+      transferTime.durationFormatted = formatDuration(duration);
+    }
+  };
+}
+function getFileExtension(filename) {
+  const parts = filename && filename?.split(".");
+  return parts && parts.length > 1 ? parts[parts.length - 1] : "";
+}
+function isFileActive(file) {
+  return ["UDLoading", "paused", "fail", "merging"].includes(file.status);
+}
+function formatFileSize(bytes, decimals = 2) {
+  if (bytes === null || bytes === void 0 || isNaN(Number(bytes))) {
+    return "0 B";
+  }
+  bytes = Number(bytes);
+  if (isNaN(bytes))
+    return "0 B";
+  if (bytes === 0)
+    return "0 B";
+  if (bytes < 0) {
+    console.warn("formatFileSize: \u63A5\u6536\u5230\u8D1F\u6570\u503C", bytes);
+    return "0 B";
+  }
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return (bytes / Math.pow(k, i)).toFixed(decimals) + " " + sizes[i];
+}
+var validator = {
+  limit(limit, length) {
+    return length < limit;
+  },
+  size(fileSize, maxSize) {
+    return fileSize <= maxSize;
+  },
+  type(accept, file) {
+    if (accept.length > 0) {
+      return accept.some((acceptType) => {
+        if (acceptType.endsWith("/*")) {
+          const category = acceptType.split("/")[0];
+          return file.File?.type.startsWith(category);
+        }
+        if (acceptType.startsWith(".")) {
+          return file.fileName.toLowerCase().endsWith(acceptType.toLowerCase());
+        }
+        return file.File?.type === acceptType;
+      });
+    }
+    return true;
+  }
+};
+function createReactiveFile(file, manager) {
+  Object.defineProperty(file, "transfer", {
+    value: manager,
+    enumerable: false,
+    // 不可枚举，避免循环引用
+    writable: false,
+    configurable: true
+  });
+  return new Proxy(file, {
+    get(target, prop, _receiver) {
+      const value = Reflect.get(target, prop);
+      if (typeof value === "function") {
+        return function(...args) {
+          const result = value.apply(target, args);
+          return result;
+        };
+      }
+      return value;
+    },
+    set(target, prop, value, _receiver) {
+      const oldValue = Reflect.get(target, prop);
+      const result = Reflect.set(target, prop, value);
+      if (oldValue !== value) {
+        manager.triggerUpdate();
+      }
+      return result;
+    },
+    // 添加 deleteProperty 陷阱，支持删除操作
+    deleteProperty(target, prop) {
+      const result = Reflect.deleteProperty(target, prop);
+      manager.triggerUpdate();
+      return result;
+    }
+  });
+}
+function createReactiveUploadFile(file, uploader) {
+  return createReactiveFile(file, uploader);
+}
+function createReactiveDownloadFile(file, downloader) {
+  return createReactiveFile(file, downloader);
+}
+function extractPathFromFunction(str) {
+  const pattern = /['"`](\/[^'"`]*)['"`]/;
+  const match = str.match(pattern);
+  return match ? match[1] : null;
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function formatSpeed(bytesPerSecond) {
+  if (bytesPerSecond === 0) {
+    return "0 B/s";
+  }
+  const units = ["B/s", "KB/s", "MB/s", "GB/s"];
+  let value = bytesPerSecond;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${value.toFixed(2)} ${units[unitIndex]}`;
+}
+function formatDuration(milliseconds) {
+  if (milliseconds === 0) {
+    return "0s";
+  }
+  const seconds = Math.floor(milliseconds / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    const remainingSeconds = seconds % 60;
+    return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+  } else if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var _md5WorkerModule = null;
+async function getMD5WorkerModule() {
+  if (!_md5WorkerModule) {
+    _md5WorkerModule = await Promise.resolve().then(() => (init_md5Worker(), md5Worker_exports));
+  }
+  return _md5WorkerModule;
+}
+async function calculateFileMD5(file, onProgress, signal) {
+  const WORKER_MIN_SIZE = 5 * 1024 * 1024;
+  const useWorker = !onProgress && // 有进度回调时不用 Worker（Worker 不提供分片进度）
+  typeof Worker !== "undefined" && file.size >= WORKER_MIN_SIZE;
+  if (useWorker) {
+    try {
+      const { calculateFileMD5InWorker: calculateFileMD5InWorker2 } = await getMD5WorkerModule();
+      return await calculateFileMD5InWorker2(file, signal);
+    } catch (workerErr) {
+      console.warn("[calculateFileMD5] Worker \u8DEF\u5F84\u5931\u8D25\uFF0C\u56DE\u9000\u5230\u4E3B\u7EBF\u7A0B:", workerErr);
+    }
+  }
+  return new Promise(async (resolve, reject) => {
+    try {
+      let loadNext2 = function() {
+        if (signal?.aborted) {
+          reject(new Error("MD5 \u8BA1\u7B97\u5DF2\u53D6\u6D88"));
+          return;
+        }
+        const start = currentChunk * chunkSize;
+        const end = Math.min(start + chunkSize, file.size);
+        fileReader.readAsArrayBuffer(file.slice(start, end));
+      };
+      var loadNext = loadNext2;
+      const chunkSize = 2 * 1024 * 1024;
+      const chunks = Math.ceil(file.size / chunkSize);
+      let currentChunk = 0;
+      const spark = new SparkMD5__default.default.ArrayBuffer();
+      const fileReader = new FileReader();
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          fileReader.abort();
+          reject(new Error("MD5 \u8BA1\u7B97\u5DF2\u53D6\u6D88"));
+        });
+      }
+      fileReader.onload = (e) => {
+        if (signal?.aborted) {
+          fileReader.abort();
+          reject(new Error("MD5 \u8BA1\u7B97\u5DF2\u53D6\u6D88"));
+          return;
+        }
+        if (e.target?.result) {
+          spark.append(e.target.result);
+          currentChunk++;
+          if (onProgress) {
+            const percent = Math.round(currentChunk / chunks * 100);
+            onProgress(percent);
+          }
+          if (currentChunk < chunks) {
+            loadNext2();
+          } else {
+            resolve(spark.end());
+          }
+        }
+      };
+      fileReader.onerror = () => {
+        reject(new Error("\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25"));
+      };
+      loadNext2();
+    } catch (error) {
+      console.error("MD5 \u8BA1\u7B97\u5E93\u52A0\u8F7D\u5931\u8D25:", error);
+      reject(new Error("MD5 \u8BA1\u7B97\u5E93\u52A0\u8F7D\u5931\u8D25"));
+    }
+  });
+}
+
+exports.LogLevel = LogLevel;
+exports.addLogCollector = addLogCollector;
+exports.calculateFileMD5 = calculateFileMD5;
+exports.calculateFileMD5InWorker = calculateFileMD5InWorker;
+exports.checkNetworkConnectivity = checkNetworkConnectivity;
+exports.checkNetworkStatus = checkNetworkStatus;
+exports.cleanExpiredCache = cleanExpiredCache;
+exports.clearAllFileCache = clearAllFileCache;
+exports.clearLogCollectors = clearLogCollectors;
+exports.computeTransferTime = computeTransferTime;
+exports.createReactiveDownloadFile = createReactiveDownloadFile;
+exports.createReactiveUploadFile = createReactiveUploadFile;
+exports.disposeMD5Worker = disposeMD5Worker;
+exports.extractPathFromFunction = extractPathFromFunction;
+exports.formatDuration = formatDuration;
+exports.formatFileSize = formatFileSize;
+exports.formatSpeed = formatSpeed;
+exports.generateFileId = generateFileId;
+exports.getCacheStats = getCacheStats;
+exports.getFileExtension = getFileExtension;
+exports.handleFile = handleFile;
+exports.initLogger = initLogger;
+exports.isFileActive = isFileActive;
+exports.isPlainObject = isPlainObject;
+exports.loadFileHandle = loadFileHandle;
+exports.logger = logger;
+exports.mergeObjects = mergeObjects;
+exports.removeFileFromCache = removeFileFromCache;
+exports.removeFileHandle = removeFileHandle;
+exports.restoreFileFromCache = restoreFileFromCache;
+exports.saveFileHandle = saveFileHandle;
+exports.saveFileToCache = saveFileToCache;
+exports.setLogLevel = setLogLevel;
+exports.sleep = sleep;
+exports.uploadMonitor = uploadMonitor;
+exports.validator = validator;
+exports.watchNetworkStatus = watchNetworkStatus;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map