sa2kit 3.0.0 → 3.2.0

package/dist/chunk-RST2T54Y.js

@@ -0,0 +1,836 @@
+'use strict';
+
+var chunkF2BZIU67_js = require('./chunk-F2BZIU67.js');
+
+// src/common/universalFile/constants.ts
+var UNIVERSAL_FILE_VERSION = "1.0.0";
+var UNIVERSAL_FILE_NAME = "@qhr123/sa2kit/universalFile";
+var DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024;
+var DEFAULT_MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_VIDEO_SIZE = 500 * 1024 * 1024;
+var DEFAULT_MAX_AUDIO_SIZE = 50 * 1024 * 1024;
+var DEFAULT_MAX_DOCUMENT_SIZE = 20 * 1024 * 1024;
+var IMAGE_MIME_TYPES = [
+  "image/jpeg",
+  "image/jpg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml"
+];
+var VIDEO_MIME_TYPES = [
+  "video/mp4",
+  "video/mpeg",
+  "video/quicktime",
+  "video/x-msvideo",
+  "video/webm"
+];
+var AUDIO_MIME_TYPES = ["audio/mpeg", "audio/mp3", "audio/wav", "audio/ogg", "audio/aac"];
+var DOCUMENT_MIME_TYPES = [
+  "application/pdf",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "text/plain"
+];
+var ALL_SUPPORTED_MIME_TYPES = [
+  ...IMAGE_MIME_TYPES,
+  ...VIDEO_MIME_TYPES,
+  ...AUDIO_MIME_TYPES,
+  ...DOCUMENT_MIME_TYPES
+];
+var IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"];
+var VIDEO_EXTENSIONS = [".mp4", ".mpeg", ".mov", ".avi", ".webm"];
+var AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".aac"];
+var DOCUMENT_EXTENSIONS = [
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".txt"
+];
+var API_BASE_PATH = "/api/universal-file";
+var API_ENDPOINTS = {
+  /** 上传文件 */
+  UPLOAD: API_BASE_PATH + "/upload",
+  /** 获取文件URL */
+  GET_URL: (fileId) => API_BASE_PATH + "/files/" + fileId + "/url",
+  /** 获取文件元数据 */
+  GET_METADATA: (fileId) => API_BASE_PATH + "/files/" + fileId,
+  /** 删除文件 */
+  DELETE: (fileId) => API_BASE_PATH + "/files/" + fileId,
+  /** 查询文件列表 */
+  QUERY: API_BASE_PATH + "/files",
+  /** 批量删除 */
+  BATCH_DELETE: API_BASE_PATH + "/files/batch-delete",
+  /** 获取上传进度 */
+  GET_PROGRESS: (fileId) => API_BASE_PATH + "/upload/" + fileId + "/progress"
+};
+var ERROR_CODES = {
+  /** 文件上传错误 */
+  FILE_UPLOAD_ERROR: "FILE_UPLOAD_ERROR",
+  /** 文件大小超限 */
+  FILE_SIZE_EXCEEDED: "FILE_SIZE_EXCEEDED",
+  /** 文件类型不支持 */
+  FILE_TYPE_NOT_SUPPORTED: "FILE_TYPE_NOT_SUPPORTED",
+  /** 文件不存在 */
+  FILE_NOT_FOUND: "FILE_NOT_FOUND",
+  /** 文件处理错误 */
+  FILE_PROCESSING_ERROR: "FILE_PROCESSING_ERROR",
+  /** 存储提供者错误 */
+  STORAGE_PROVIDER_ERROR: "STORAGE_PROVIDER_ERROR",
+  /** CDN提供者错误 */
+  CDN_PROVIDER_ERROR: "CDN_PROVIDER_ERROR",
+  /** 网络错误 */
+  NETWORK_ERROR: "NETWORK_ERROR",
+  /** 超时错误 */
+  TIMEOUT_ERROR: "TIMEOUT_ERROR",
+  /** 未授权 */
+  UNAUTHORIZED: "UNAUTHORIZED",
+  /** 权限不足 */
+  FORBIDDEN: "FORBIDDEN",
+  /** 服务器错误 */
+  SERVER_ERROR: "SERVER_ERROR"
+};
+var DEFAULT_PAGE_SIZE = 20;
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var DEFAULT_UPLOAD_TIMEOUT = 3e5;
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+
+// src/common/universalFile/utils.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 (bytes / Math.pow(k, i)).toFixed(2) + " " + units[i];
+}
+function parseFileSize(sizeStr) {
+  const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*([KMGT]?B)$/i);
+  if (!match || !match[1] || !match[2]) return 0;
+  const value = parseFloat(match[1]);
+  const unit = match[2].toUpperCase();
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+    TB: 1024 * 1024 * 1024 * 1024
+  };
+  return value * (units[unit] || 1);
+}
+function getFileExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  if (lastDot === -1) return "";
+  return fileName.substring(lastDot).toLowerCase();
+}
+function getMimeTypeFromFileName(fileName) {
+  const ext = getFileExtension(fileName);
+  const mimeMap = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".mp4": "video/mp4",
+    ".avi": "video/x-msvideo",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  };
+  return mimeMap[ext] || "application/octet-stream";
+}
+function isMimeTypeSupported(mimeType, allowedTypes) {
+  if (allowedTypes && allowedTypes.length > 0) {
+    return allowedTypes.includes(mimeType);
+  }
+  return IMAGE_MIME_TYPES.includes(mimeType) || VIDEO_MIME_TYPES.includes(mimeType) || AUDIO_MIME_TYPES.includes(mimeType) || DOCUMENT_MIME_TYPES.includes(mimeType);
+}
+function isImageFile(mimeType) {
+  return IMAGE_MIME_TYPES.includes(mimeType);
+}
+function isVideoFile(mimeType) {
+  return VIDEO_MIME_TYPES.includes(mimeType);
+}
+function isAudioFile(mimeType) {
+  return AUDIO_MIME_TYPES.includes(mimeType);
+}
+function isDocumentFile(mimeType) {
+  return DOCUMENT_MIME_TYPES.includes(mimeType);
+}
+function getFileCategory(mimeType) {
+  if (isImageFile(mimeType)) return "image";
+  if (isVideoFile(mimeType)) return "video";
+  if (isAudioFile(mimeType)) return "audio";
+  if (isDocumentFile(mimeType)) return "document";
+  return "other";
+}
+function validateFileName(fileName) {
+  const invalidChars = /[<>:"|?*\/\\]/;
+  if (invalidChars.test(fileName)) {
+    return false;
+  }
+  if (fileName.length === 0 || fileName.length > 255) {
+    return false;
+  }
+  if (fileName.startsWith(".")) {
+    return false;
+  }
+  return true;
+}
+function sanitizeFileName(fileName) {
+  return fileName.replace(/[<>:"|?*\/\\]/g, "_").replace(/^\.+/, "").substring(0, 255);
+}
+function generateUniqueFileName(originalName, fileId) {
+  const ext = getFileExtension(originalName);
+  return fileId + ext;
+}
+function generateStoragePath(moduleId, fileName, options) {
+  const parts = [];
+  if (options?.customPrefix) {
+    parts.push(options.customPrefix);
+  }
+  parts.push(moduleId);
+  if (options?.businessId) {
+    parts.push(options.businessId);
+  }
+  if (options?.useDate !== false) {
+    const date = /* @__PURE__ */ new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    parts.push(String(year), month, day);
+  }
+  parts.push(fileName);
+  return parts.join("/");
+}
+function parseStoragePath(path) {
+  const parts = path.split("/");
+  const fileName = parts[parts.length - 1] || "";
+  return {
+    moduleId: parts[0] || void 0,
+    businessId: parts.length > 5 ? parts[1] : void 0,
+    year: parts.length > 3 ? parts[parts.length - 4] : void 0,
+    month: parts.length > 2 ? parts[parts.length - 3] : void 0,
+    day: parts.length > 1 ? parts[parts.length - 2] : void 0,
+    fileName
+  };
+}
+function validateFileSize(file, maxSize) {
+  if (file.size > maxSize) {
+    return {
+      valid: false,
+      error: "\u6587\u4EF6\u5927\u5C0F\u8D85\u8FC7\u9650\u5236: " + formatFileSize(file.size) + " > " + formatFileSize(maxSize)
+    };
+  }
+  return { valid: true };
+}
+function validateFileType(file, allowedTypes) {
+  const mimeType = file.type || getMimeTypeFromFileName(file.name);
+  if (!isMimeTypeSupported(mimeType, allowedTypes)) {
+    return {
+      valid: false,
+      error: "\u4E0D\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B: " + mimeType
+    };
+  }
+  return { valid: true };
+}
+function validateFile(file, options) {
+  const errors = [];
+  if (!validateFileName(file.name)) {
+    errors.push("\u6587\u4EF6\u540D\u5305\u542B\u975E\u6CD5\u5B57\u7B26\u6216\u957F\u5EA6\u4E0D\u5408\u6CD5");
+  }
+  if (options?.maxSize) {
+    const sizeResult = validateFileSize(file, options.maxSize);
+    if (!sizeResult.valid && sizeResult.error) {
+      errors.push(sizeResult.error);
+    }
+  }
+  if (options?.allowedTypes) {
+    const typeResult = validateFileType(file, options.allowedTypes);
+    if (!typeResult.valid && typeResult.error) {
+      errors.push(typeResult.error);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => searchParams.append(key, String(v)));
+      } else {
+        searchParams.append(key, String(value));
+      }
+    }
+  });
+  const queryString = searchParams.toString();
+  return queryString ? "?" + queryString : "";
+}
+function parseQueryString(url) {
+  const params = {};
+  const urlObj = new URL(url, window.location.origin);
+  urlObj.searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+function calculateProgress(uploadedBytes, totalBytes) {
+  if (totalBytes === 0) return 0;
+  return Math.min(Math.round(uploadedBytes / totalBytes * 100), 100);
+}
+function calculateSpeed(uploadedBytes, elapsedTime) {
+  if (elapsedTime === 0) return 0;
+  return uploadedBytes / (elapsedTime / 1e3);
+}
+function calculateRemainingTime(uploadedBytes, totalBytes, speed) {
+  if (speed === 0) return 0;
+  const remainingBytes = totalBytes - uploadedBytes;
+  return Math.round(remainingBytes / speed);
+}
+function createFileError(code, message, details) {
+  return {
+    code,
+    message,
+    details,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return "\u672A\u77E5\u9519\u8BEF";
+}
+function readFileAsBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      const base64 = result.split(",")[1] || "";
+      resolve(base64);
+    };
+    reader.onerror = () => {
+      reject(new Error("\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25"));
+    };
+    reader.readAsDataURL(file);
+  });
+}
+function readFileAsArrayBuffer(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      resolve(reader.result);
+    };
+    reader.onerror = () => {
+      reject(new Error("\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25"));
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}
+function readFileAsText(file, encoding = "UTF-8") {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      resolve(reader.result);
+    };
+    reader.onerror = () => {
+      reject(new Error("\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25"));
+    };
+    reader.readAsText(file, encoding);
+  });
+}
+
+// src/common/universalFile/client.ts
+var clientLogger = chunkF2BZIU67_js.createLogger("UniversalFileClient");
+var UniversalFileClient = class {
+  constructor(config = {}) {
+    this.config = {
+      baseUrl: config.baseUrl || "",
+      timeout: config.timeout || DEFAULT_REQUEST_TIMEOUT,
+      uploadTimeout: config.uploadTimeout || DEFAULT_UPLOAD_TIMEOUT,
+      headers: config.headers || {}
+    };
+  }
+  // ============= 文件上传API =============
+  /**
+   * 上传文件
+   */
+  async uploadFile(fileInfo, onProgress) {
+    const url = this.config.baseUrl + API_ENDPOINTS.UPLOAD;
+    const startTime = Date.now();
+    const formData = new FormData();
+    formData.append("file", fileInfo.file);
+    formData.append("moduleId", fileInfo.moduleId);
+    if (fileInfo.businessId) {
+      formData.append("businessId", fileInfo.businessId);
+    }
+    if (fileInfo.permission) {
+      formData.append("permission", fileInfo.permission);
+    }
+    if (fileInfo.customPath) {
+      formData.append("customPath", fileInfo.customPath);
+    }
+    if (fileInfo.metadata) {
+      formData.append("metadata", JSON.stringify(fileInfo.metadata));
+    }
+    if (fileInfo.needsProcessing !== void 0) {
+      formData.append("needsProcessing", String(fileInfo.needsProcessing));
+    }
+    if (fileInfo.processingOptions) {
+      formData.append("processingOptions", JSON.stringify(fileInfo.processingOptions));
+    }
+    try {
+      clientLogger.debug("\u5F00\u59CB\u4E0A\u4F20\u6587\u4EF6", {
+        url,
+        fileName: fileInfo.file.name,
+        fileSize: fileInfo.file.size,
+        moduleId: fileInfo.moduleId,
+        businessId: fileInfo.businessId
+      });
+      return await new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.withCredentials = true;
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable && onProgress) {
+            const elapsedTime = Date.now() - startTime;
+            const speed = event.loaded / (elapsedTime / 1e3);
+            const remainingBytes = event.total - event.loaded;
+            const remainingTime = speed > 0 ? remainingBytes / speed : 0;
+            const progress = {
+              fileId: "",
+              // 暂时为空，上传完成后会有
+              status: "uploading",
+              progress: Math.round(event.loaded / event.total * 100),
+              uploadedBytes: event.loaded,
+              totalBytes: event.total,
+              speed,
+              remainingTime
+            };
+            onProgress(progress);
+          }
+        });
+        xhr.addEventListener("load", () => {
+          clientLogger.debug("\u4E0A\u4F20\u54CD\u5E94", {
+            status: xhr.status,
+            statusText: xhr.statusText,
+            responseLength: xhr.responseText?.length
+          });
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              const response = JSON.parse(xhr.responseText);
+              clientLogger.debug("\u89E3\u6790\u54CD\u5E94\u6210\u529F", response);
+              const fileData = response.file || response.data || response;
+              const fileMetadata = this.transformFileMetadataFromAPI(fileData);
+              if (onProgress) {
+                onProgress({
+                  fileId: fileMetadata.id,
+                  status: "completed",
+                  progress: 100,
+                  uploadedBytes: fileInfo.file.size,
+                  totalBytes: fileInfo.file.size,
+                  speed: 0,
+                  remainingTime: 0
+                });
+              }
+              resolve(fileMetadata);
+            } catch (error) {
+              clientLogger.error("\u89E3\u6790\u54CD\u5E94\u5931\u8D25", { error, responseText: xhr.responseText });
+              reject(new Error("\u89E3\u6790\u54CD\u5E94\u5931\u8D25"));
+            }
+          } else {
+            clientLogger.error("\u4E0A\u4F20\u5931\u8D25", {
+              status: xhr.status,
+              statusText: xhr.statusText,
+              responseText: xhr.responseText
+            });
+            reject(new Error("\u4E0A\u4F20\u5931\u8D25: " + xhr.statusText));
+          }
+        });
+        xhr.addEventListener("error", (event) => {
+          clientLogger.error("\u7F51\u7EDC\u9519\u8BEF", event);
+          if (onProgress) {
+            onProgress({
+              fileId: "",
+              status: "failed",
+              progress: 0,
+              uploadedBytes: 0,
+              totalBytes: fileInfo.file.size,
+              speed: 0,
+              remainingTime: 0,
+              error: "\u7F51\u7EDC\u9519\u8BEF"
+            });
+          }
+          reject(new Error("\u4E0A\u4F20\u5931\u8D25: \u7F51\u7EDC\u9519\u8BEF"));
+        });
+        xhr.addEventListener("timeout", () => {
+          if (onProgress) {
+            onProgress({
+              fileId: "",
+              status: "failed",
+              progress: 0,
+              uploadedBytes: 0,
+              totalBytes: fileInfo.file.size,
+              speed: 0,
+              remainingTime: 0,
+              error: "\u4E0A\u4F20\u8D85\u65F6"
+            });
+          }
+          reject(new Error("\u4E0A\u4F20\u8D85\u65F6"));
+        });
+        xhr.open("POST", url);
+        xhr.timeout = this.config.uploadTimeout;
+        Object.entries(this.config.headers).forEach(([key, value]) => {
+          xhr.setRequestHeader(key, value);
+        });
+        xhr.send(formData);
+      });
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.FILE_UPLOAD_ERROR,
+        "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25: " + formatErrorMessage(error),
+        { fileInfo, originalError: error }
+      );
+    }
+  }
+  // ============= 文件查询API =============
+  /**
+   * 获取文件访问URL
+   */
+  async getFileUrl(fileId, expiresIn) {
+    const url = this.config.baseUrl + API_ENDPOINTS.GET_URL(fileId) + (expiresIn ? `?expiresIn=${expiresIn}` : "");
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error("\u83B7\u53D6\u6587\u4EF6URL\u5931\u8D25: " + response.statusText);
+      }
+      const data = await response.json();
+      return data.url;
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u83B7\u53D6\u6587\u4EF6URL\u5931\u8D25: " + formatErrorMessage(error),
+        { fileId, expiresIn, originalError: error }
+      );
+    }
+  }
+  /**
+   * 获取文件元数据
+   */
+  async getFileMetadata(fileId) {
+    const url = this.config.baseUrl + API_ENDPOINTS.GET_METADATA(fileId);
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          throw createFileError(ERROR_CODES.FILE_NOT_FOUND, "\u6587\u4EF6\u4E0D\u5B58\u5728", { fileId });
+        }
+        throw new Error("\u83B7\u53D6\u6587\u4EF6\u5143\u6570\u636E\u5931\u8D25: " + response.statusText);
+      }
+      const data = await response.json();
+      return this.transformFileMetadataFromAPI(data.file);
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u83B7\u53D6\u6587\u4EF6\u5143\u6570\u636E\u5931\u8D25: " + formatErrorMessage(error),
+        { fileId, originalError: error }
+      );
+    }
+  }
+  /**
+   * 查询文件列表
+   */
+  async queryFiles(options) {
+    const queryString = buildQueryString({
+      moduleId: options.moduleId,
+      businessId: options.businessId,
+      uploaderId: options.uploaderId,
+      mimeType: options.mimeType,
+      minSize: options.minSize,
+      maxSize: options.maxSize,
+      startTime: options.startTime?.toISOString(),
+      endTime: options.endTime?.toISOString(),
+      keyword: options.keyword,
+      tags: options.tags,
+      sortBy: options.sortBy,
+      sortOrder: options.sortOrder,
+      page: options.page,
+      pageSize: options.pageSize
+    });
+    const url = this.config.baseUrl + API_ENDPOINTS.QUERY + queryString;
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        clientLogger.error("\u67E5\u8BE2\u6587\u4EF6\u5217\u8868\u5931\u8D25", {
+          status: response.status,
+          statusText: response.statusText
+        });
+        throw new Error("\u67E5\u8BE2\u6587\u4EF6\u5217\u8868\u5931\u8D25: " + response.statusText);
+      }
+      const data = await response.json();
+      clientLogger.debug("\u67E5\u8BE2\u6587\u4EF6\u5217\u8868\u54CD\u5E94", {
+        itemsCount: data.items?.length,
+        total: data.total,
+        page: data.page
+      });
+      if (!data.items || !Array.isArray(data.items)) {
+        clientLogger.error("\u54CD\u5E94\u683C\u5F0F\u9519\u8BEF: items \u4E0D\u662F\u6570\u7EC4", data);
+        return {
+          items: [],
+          total: 0,
+          page: 1,
+          pageSize: 20,
+          totalPages: 0,
+          hasNext: false,
+          hasPrev: false
+        };
+      }
+      return {
+        items: data.items.map((item) => this.transformFileMetadataFromAPI(item)),
+        total: data.total,
+        page: data.page,
+        pageSize: data.pageSize,
+        totalPages: data.totalPages,
+        hasNext: data.hasNext,
+        hasPrev: data.hasPrev
+      };
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u67E5\u8BE2\u6587\u4EF6\u5217\u8868\u5931\u8D25: " + formatErrorMessage(error),
+        { options, originalError: error }
+      );
+    }
+  }
+  // ============= 文件删除API =============
+  /**
+   * 删除文件
+   */
+  async deleteFile(fileId) {
+    const url = this.config.baseUrl + API_ENDPOINTS.DELETE(fileId);
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "DELETE",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          throw createFileError(ERROR_CODES.FILE_NOT_FOUND, "\u6587\u4EF6\u4E0D\u5B58\u5728", { fileId });
+        }
+        throw new Error("\u5220\u9664\u6587\u4EF6\u5931\u8D25: " + response.statusText);
+      }
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u5220\u9664\u6587\u4EF6\u5931\u8D25: " + formatErrorMessage(error),
+        { fileId, originalError: error }
+      );
+    }
+  }
+  /**
+   * 批量删除文件
+   */
+  async batchDeleteFiles(fileIds) {
+    const url = this.config.baseUrl + API_ENDPOINTS.BATCH_DELETE;
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: {
+          ...this.getHeaders(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ fileIds })
+      });
+      if (!response.ok) {
+        throw new Error("\u6279\u91CF\u5220\u9664\u6587\u4EF6\u5931\u8D25: " + response.statusText);
+      }
+      const data = await response.json();
+      return data.result;
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u6279\u91CF\u5220\u9664\u6587\u4EF6\u5931\u8D25: " + formatErrorMessage(error),
+        { fileIds, originalError: error }
+      );
+    }
+  }
+  // ============= 上传进度API =============
+  /**
+   * 获取上传进度
+   */
+  async getUploadProgress(fileId) {
+    const url = this.config.baseUrl + API_ENDPOINTS.GET_PROGRESS(fileId);
+    try {
+      const response = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw new Error("\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25: " + response.statusText);
+      }
+      const data = await response.json();
+      return data.progress;
+    } catch (error) {
+      throw createFileError(
+        ERROR_CODES.NETWORK_ERROR,
+        "\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25: " + formatErrorMessage(error),
+        { fileId, originalError: error }
+      );
+    }
+  }
+  // ============= 私有辅助方法 =============
+  /**
+   * 获取请求头
+   */
+  getHeaders() {
+    return {
+      ...this.config.headers
+    };
+  }
+  /**
+   * 带超时的fetch请求
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+        credentials: "include"
+        // 携带 cookie 用于授权
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw createFileError(ERROR_CODES.TIMEOUT_ERROR, "\u8BF7\u6C42\u8D85\u65F6", {
+          url,
+          timeout: this.config.timeout
+        });
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * 转换API返回的文件元数据
+   */
+  transformFileMetadataFromAPI(apiData) {
+    return {
+      id: apiData.id,
+      originalName: apiData.originalName,
+      storageName: apiData.storageName || apiData.storedName,
+      size: apiData.size,
+      mimeType: apiData.mimeType,
+      extension: apiData.extension,
+      hash: apiData.hash || apiData.md5Hash || apiData.sha256Hash,
+      uploadTime: new Date(apiData.uploadTime),
+      permission: apiData.permission || "public",
+      uploaderId: apiData.uploaderId,
+      moduleId: apiData.moduleId,
+      businessId: apiData.businessId,
+      storageProvider: apiData.storageProvider || "local",
+      storagePath: apiData.storagePath,
+      cdnUrl: apiData.cdnUrl,
+      accessCount: apiData.accessCount,
+      lastAccessTime: apiData.lastAccessTime ? new Date(apiData.lastAccessTime) : void 0,
+      expiresAt: apiData.expiresAt ? new Date(apiData.expiresAt) : void 0,
+      metadata: apiData.metadata
+    };
+  }
+};
+var universalFileClient = new UniversalFileClient();
+function createFileClient(config) {
+  return new UniversalFileClient(config);
+}
+
+exports.ALL_SUPPORTED_MIME_TYPES = ALL_SUPPORTED_MIME_TYPES;
+exports.API_BASE_PATH = API_BASE_PATH;
+exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.AUDIO_EXTENSIONS = AUDIO_EXTENSIONS;
+exports.AUDIO_MIME_TYPES = AUDIO_MIME_TYPES;
+exports.DEFAULT_CHUNK_SIZE = DEFAULT_CHUNK_SIZE;
+exports.DEFAULT_MAX_AUDIO_SIZE = DEFAULT_MAX_AUDIO_SIZE;
+exports.DEFAULT_MAX_DOCUMENT_SIZE = DEFAULT_MAX_DOCUMENT_SIZE;
+exports.DEFAULT_MAX_FILE_SIZE = DEFAULT_MAX_FILE_SIZE;
+exports.DEFAULT_MAX_IMAGE_SIZE = DEFAULT_MAX_IMAGE_SIZE;
+exports.DEFAULT_MAX_VIDEO_SIZE = DEFAULT_MAX_VIDEO_SIZE;
+exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
+exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT;
+exports.DEFAULT_UPLOAD_TIMEOUT = DEFAULT_UPLOAD_TIMEOUT;
+exports.DOCUMENT_EXTENSIONS = DOCUMENT_EXTENSIONS;
+exports.DOCUMENT_MIME_TYPES = DOCUMENT_MIME_TYPES;
+exports.ERROR_CODES = ERROR_CODES;
+exports.IMAGE_EXTENSIONS = IMAGE_EXTENSIONS;
+exports.IMAGE_MIME_TYPES = IMAGE_MIME_TYPES;
+exports.UNIVERSAL_FILE_NAME = UNIVERSAL_FILE_NAME;
+exports.UNIVERSAL_FILE_VERSION = UNIVERSAL_FILE_VERSION;
+exports.UniversalFileClient = UniversalFileClient;
+exports.VIDEO_EXTENSIONS = VIDEO_EXTENSIONS;
+exports.VIDEO_MIME_TYPES = VIDEO_MIME_TYPES;
+exports.buildQueryString = buildQueryString;
+exports.calculateProgress = calculateProgress;
+exports.calculateRemainingTime = calculateRemainingTime;
+exports.calculateSpeed = calculateSpeed;
+exports.createFileClient = createFileClient;
+exports.createFileError = createFileError;
+exports.formatErrorMessage = formatErrorMessage;
+exports.formatFileSize = formatFileSize;
+exports.generateStoragePath = generateStoragePath;
+exports.generateUniqueFileName = generateUniqueFileName;
+exports.getFileCategory = getFileCategory;
+exports.getFileExtension = getFileExtension;
+exports.getMimeTypeFromFileName = getMimeTypeFromFileName;
+exports.isAudioFile = isAudioFile;
+exports.isDocumentFile = isDocumentFile;
+exports.isImageFile = isImageFile;
+exports.isMimeTypeSupported = isMimeTypeSupported;
+exports.isVideoFile = isVideoFile;
+exports.parseFileSize = parseFileSize;
+exports.parseQueryString = parseQueryString;
+exports.parseStoragePath = parseStoragePath;
+exports.readFileAsArrayBuffer = readFileAsArrayBuffer;
+exports.readFileAsBase64 = readFileAsBase64;
+exports.readFileAsText = readFileAsText;
+exports.sanitizeFileName = sanitizeFileName;
+exports.universalFileClient = universalFileClient;
+exports.validateFile = validateFile;
+exports.validateFileName = validateFileName;
+exports.validateFileSize = validateFileSize;
+exports.validateFileType = validateFileType;
+//# sourceMappingURL=chunk-RST2T54Y.js.map
+//# sourceMappingURL=chunk-RST2T54Y.js.map