@alibarbar/common 1.0.9 → 1.1.0

package/dist/upload.js

@@ -1,22 +1,404 @@
-'use strict';
+// src/browser/file/index.ts
+async function calculateBlobMD5(blob) {
+  return new Promise((resolve, reject) => {
+    if (typeof FileReader === "undefined") {
+      reject(new Error("FileReader is not supported in this environment"));
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = async (e) => {
+      try {
+        const arrayBuffer = e.target?.result;
+        if (!arrayBuffer) {
+          reject(new Error("Failed to read blob"));
+          return;
+        }
+        const hashBuffer = await crypto.subtle.digest("SHA-256", arrayBuffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        resolve(hashHex);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function splitFileIntoChunks(file, chunkSize) {
+  const chunks = [];
+  let start = 0;
+  while (start < file.size) {
+    const end = Math.min(start + chunkSize, file.size);
+    chunks.push(file.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
 
-var chunkFEBKPX5A_js = require('./chunk-FEBKPX5A.js');
-require('./chunk-7V5UQXIO.js');
-require('./chunk-PR4QN5HX.js');
+// src/browser/upload/index.ts
+var ChunkUploader = class {
+  constructor(file, options = {}) {
+    this.taskId = null;
+    this.chunks = [];
+    this.uploadedChunks = /* @__PURE__ */ new Set();
+    this.status = "pending" /* PENDING */;
+    this.abortController = null;
+    this.file = file;
+    this.options = {
+      chunkSize: options.chunkSize || 2 * 1024 * 1024,
+      // 默认2MB
+      concurrency: options.concurrency || 3,
+      retryCount: options.retryCount || 3,
+      retryDelay: options.retryDelay || 1e3,
+      baseURL: options.baseURL || "",
+      headers: options.headers || {},
+      onProgress: options.onProgress || (() => {
+      }),
+      onComplete: options.onComplete || (() => {
+      }),
+      onError: options.onError || (() => {
+      })
+    };
+  }
+  /**
+   * 初始化上传
+   */
+  async initUpload() {
+    const fileMd5 = await this.calculateFileMD5();
+    const request = {
+      fileName: this.file.name,
+      fileSize: this.file.size,
+      fileMd5,
+      chunkSize: this.options.chunkSize
+    };
+    const response = await this.request("/api/files/common/init", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.options.headers
+      },
+      body: JSON.stringify(request)
+    });
+    if (response.code !== 200) {
+      throw new Error(response.message || "\u521D\u59CB\u5316\u4E0A\u4F20\u5931\u8D25");
+    }
+    return response.data;
+  }
+  /**
+   * 计算文件MD5
+   */
+  async calculateFileMD5() {
+    const chunks = splitFileIntoChunks(this.file, this.options.chunkSize);
+    const md5Promises = chunks.map(
+      (chunk, index) => calculateBlobMD5(chunk).then((md5) => ({ index, md5 }))
+    );
+    const md5Results = await Promise.all(md5Promises);
+    return md5Results.map((r) => r.md5).join("");
+  }
+  /**
+   * 准备分片
+   */
+  prepareChunks() {
+    const blobChunks = splitFileIntoChunks(this.file, this.options.chunkSize);
+    this.chunks = blobChunks.map((blob, index) => ({
+      index,
+      start: index * this.options.chunkSize,
+      end: Math.min((index + 1) * this.options.chunkSize, this.file.size),
+      blob
+    }));
+  }
+  /**
+   * 获取已上传的分片列表（用于断点续传）
+   */
+  async getUploadedChunks() {
+    if (!this.taskId) return [];
+    try {
+      const response = await this.request(
+        `/api/files/common/chunks/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200) {
+        return response.data || [];
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u5DF2\u4E0A\u4F20\u5206\u7247\u5931\u8D25:", error);
+    }
+    return [];
+  }
+  /**
+   * 上传单个分片
+   */
+  async uploadChunk(chunkInfo, retryCount = 0) {
+    if (!this.taskId) {
+      throw new Error("\u4EFB\u52A1ID\u4E0D\u5B58\u5728");
+    }
+    if (this.uploadedChunks.has(chunkInfo.index)) {
+      return;
+    }
+    try {
+      const chunkMd5 = await calculateBlobMD5(chunkInfo.blob);
+      const formData = new FormData();
+      formData.append("file", chunkInfo.blob, this.file.name);
+      const url = `/api/files/common/chunk?taskId=${this.taskId}&chunkIndex=${chunkInfo.index}&chunkMd5=${chunkMd5}`;
+      const response = await this.request(url, {
+        method: "POST",
+        headers: this.options.headers,
+        body: formData
+      });
+      if (response.code === 200 && response.data.success) {
+        this.uploadedChunks.add(chunkInfo.index);
+        await this.updateProgress();
+      } else {
+        throw new Error(response.message || "\u5206\u7247\u4E0A\u4F20\u5931\u8D25");
+      }
+    } catch (error) {
+      if (retryCount < this.options.retryCount) {
+        await this.delay(this.options.retryDelay);
+        return this.uploadChunk(chunkInfo, retryCount + 1);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 并发上传分片
+   */
+  async uploadChunksConcurrently() {
+    const chunksToUpload = this.chunks.filter((chunk) => !this.uploadedChunks.has(chunk.index));
+    if (chunksToUpload.length === 0) {
+      return;
+    }
+    let currentIndex = 0;
+    const uploadNext = async () => {
+      while (this.status === "uploading" /* UPLOADING */) {
+        const chunkIndex = currentIndex++;
+        if (chunkIndex >= chunksToUpload.length) {
+          break;
+        }
+        const chunk = chunksToUpload[chunkIndex];
+        await this.uploadChunk(chunk);
+      }
+    };
+    const tasks = Array(this.options.concurrency).fill(null).map(() => uploadNext());
+    await Promise.all(tasks);
+  }
+  /**
+   * 更新上传进度（仅用于回调前端显示）
+   */
+  async updateProgress() {
+    if (!this.taskId) return;
+    try {
+      const response = await this.request(
+        `/api/files/common/progress/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200 && response.data) {
+        this.options.onProgress(response.data);
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 获取上传进度
+   */
+  async getUploadProgress() {
+    if (!this.taskId) {
+      return null;
+    }
+    try {
+      const response = await this.request(
+        `/api/files/common/progress/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200 && response.data) {
+        console.log("[\u83B7\u53D6\u8FDB\u5EA6]", response.data);
+        return response.data;
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25:", error);
+    }
+    return null;
+  }
+  /**
+   * 完成上传（调用后端合并分片接口）
+   */
+  async completeUpload() {
+    if (!this.taskId) {
+      throw new Error("\u4EFB\u52A1ID\u4E0D\u5B58\u5728");
+    }
+    console.log("[\u5B8C\u6210\u4E0A\u4F20] \u8C03\u7528\u5B8C\u6210\u63A5\u53E3:", `/api/files/common/complete/${this.taskId}`);
+    const response = await this.request(
+      `/api/files/common/complete/${this.taskId}`,
+      {
+        method: "POST",
+        headers: this.options.headers
+      }
+    );
+    console.log("[\u5B8C\u6210\u4E0A\u4F20] \u63A5\u53E3\u54CD\u5E94:", response);
+    if (response.code !== 200) {
+      throw new Error(response.message || "\u5B8C\u6210\u4E0A\u4F20\u5931\u8D25");
+    }
+    return response.data;
+  }
+  /**
+   * 开始上传
+   */
+  async upload() {
+    try {
+      this.status = "uploading" /* UPLOADING */;
+      this.abortController = new AbortController();
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 1. \u521D\u59CB\u5316\u4E0A\u4F20");
+      const initResponse = await this.initUpload();
+      this.taskId = initResponse.taskId;
+      if (initResponse.instantUpload && initResponse.fileUrl) {
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u79D2\u4F20\u6210\u529F");
+        this.status = "completed" /* COMPLETED */;
+        const result = {
+          taskId: this.taskId,
+          fileUrl: initResponse.fileUrl,
+          fileName: this.file.name,
+          fileSize: this.file.size,
+          fileMd5: "",
+          success: true,
+          message: "\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u79D2\u4F20\u6210\u529F"
+        };
+        this.options.onComplete(result);
+        return result;
+      }
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 2. \u51C6\u5907\u5206\u7247");
+      this.prepareChunks();
+      const totalChunks = this.chunks.length;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u5171 ${totalChunks} \u4E2A\u5206\u7247`);
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 3. \u68C0\u67E5\u5DF2\u4E0A\u4F20\u5206\u7247");
+      const existingChunks = await this.getUploadedChunks();
+      existingChunks.forEach((index) => this.uploadedChunks.add(index));
+      console.log(
+        `[\u4E0A\u4F20\u6D41\u7A0B] \u5DF2\u4E0A\u4F20 ${existingChunks.length} \u4E2A\u5206\u7247\uFF0C\u8FD8\u9700\u4E0A\u4F20 ${totalChunks - existingChunks.length} \u4E2A`
+      );
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 4. \u5F00\u59CB\u4E0A\u4F20\u5206\u7247");
+      await this.uploadChunksConcurrently();
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 5. \u6240\u6709\u5206\u7247\u4E0A\u4F20\u5B8C\u6210");
+      const uploadedCount = this.uploadedChunks.size;
+      if (uploadedCount < totalChunks) {
+        throw new Error(`\u4E0A\u4F20\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5DF2\u4E0A\u4F20 ${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247`);
+      }
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 6. \u9A8C\u8BC1\u901A\u8FC7\uFF1A${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247\u5DF2\u4E0A\u4F20`);
+      const localPercentage = Math.round(uploadedCount / totalChunks * 100);
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 7. \u672C\u5730\u8FDB\u5EA6\uFF1A${localPercentage}%`);
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 8. \u83B7\u53D6\u670D\u52A1\u7AEF\u8FDB\u5EA6");
+      const serverProgress = await this.getUploadProgress();
+      const serverPercentage = serverProgress?.percentage ?? 0;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u670D\u52A1\u7AEF\u8FDB\u5EA6\uFF1A${serverPercentage}%`);
+      const finalPercentage = serverProgress?.percentage ?? localPercentage;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 9. \u6700\u7EC8\u8FDB\u5EA6\uFF1A${finalPercentage}%`);
+      if (finalPercentage >= 100) {
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] 10. \u2705 \u8FDB\u5EA6\u8FBE\u5230100%\uFF0C\u8C03\u7528\u5B8C\u6210\u63A5\u53E3");
+        const result = await this.completeUpload();
+        this.status = "completed" /* COMPLETED */;
+        this.options.onComplete(result);
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u2705 \u4E0A\u4F20\u5B8C\u6210");
+        return result;
+      } else {
+        console.error(`[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u8FDB\u5EA6\u4E0D\u8DB3100%\uFF1A${finalPercentage}%`);
+        throw new Error(`\u4E0A\u4F20\u672A\u5B8C\u6210\uFF1A\u5F53\u524D\u8FDB\u5EA6 ${finalPercentage.toFixed(2)}%`);
+      }
+    } catch (error) {
+      this.status = "failed" /* FAILED */;
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.options.onError(err);
+      console.error("[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u4E0A\u4F20\u5931\u8D25:", err);
+      throw err;
+    }
+  }
+  /**
+   * 暂停上传
+   */
+  pause() {
+    if (this.status === "uploading" /* UPLOADING */) {
+      this.status = "paused" /* PAUSED */;
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+    }
+  }
+  /**
+   * 恢复上传
+   */
+  async resume() {
+    if (this.status === "paused" /* PAUSED */) {
+      return this.upload();
+    }
+    throw new Error("\u5F53\u524D\u72B6\u6001\u65E0\u6CD5\u6062\u590D\u4E0A\u4F20");
+  }
+  /**
+   * 取消上传
+   */
+  async cancel() {
+    if (this.taskId && this.status === "uploading" /* UPLOADING */) {
+      try {
+        await this.request(`/api/files/common/cancel/${this.taskId}`, {
+          method: "POST",
+          headers: this.options.headers
+        });
+      } catch (error) {
+        console.warn("\u53D6\u6D88\u4E0A\u4F20\u5931\u8D25:", error);
+      }
+    }
+    this.status = "cancelled" /* CANCELLED */;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 获取任务ID
+   */
+  getTaskId() {
+    return this.taskId;
+  }
+  /**
+   * HTTP请求封装
+   */
+  async request(url, options = {}) {
+    const fullUrl = `${this.options.baseURL}${url}`;
+    const signal = this.abortController?.signal;
+    const response = await fetch(fullUrl, {
+      ...options,
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP\u9519\u8BEF: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * 延迟函数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createUploader(file, options) {
+  return new ChunkUploader(file, options);
+}
+async function uploadFile(file, options) {
+  const uploader = createUploader(file, options);
+  return uploader.upload();
+}
 
-
-
-Object.defineProperty(exports, "ChunkUploader", {
-  enumerable: true,
-  get: function () { return chunkFEBKPX5A_js.ChunkUploader; }
-});
-Object.defineProperty(exports, "createUploader", {
-  enumerable: true,
-  get: function () { return chunkFEBKPX5A_js.createUploader; }
-});
-Object.defineProperty(exports, "uploadFile", {
-  enumerable: true,
-  get: function () { return chunkFEBKPX5A_js.uploadFile; }
-});
-//# sourceMappingURL=upload.js.map
-//# sourceMappingURL=upload.js.map
+export { ChunkUploader, createUploader, uploadFile };

package/dist/{chunk-KGFTD255.js → url.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/format/url.ts
+// src/format/url/index.ts
 function parseUrl(url) {
   try {
     const urlObj = new URL(url);
@@ -100,5 +100,3 @@ exports.parseUrl = parseUrl;
 exports.removeQueryParams = removeQueryParams;
 exports.setQueryParams = setQueryParams;
 exports.updateQueryParams = updateQueryParams;
-//# sourceMappingURL=chunk-KGFTD255.js.map
-//# sourceMappingURL=chunk-KGFTD255.js.map

package/dist/url.js

@@ -1,45 +1,92 @@
-'use strict';
+// src/format/url/index.ts
+function parseUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return {
+      protocol: urlObj.protocol,
+      host: urlObj.host,
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      pathname: urlObj.pathname,
+      search: urlObj.search,
+      hash: urlObj.hash,
+      origin: urlObj.origin
+    };
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function buildUrl(parts) {
+  const { protocol = "https:", host = "", pathname = "/", search = "", hash = "" } = parts;
+  return `${protocol}//${host}${pathname}${search}${hash}`;
+}
+function getQueryParams(url) {
+  const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+  const params = {};
+  searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+function setQueryParams(url, params) {
+  try {
+    const urlObj = new URL(url);
+    Object.keys(params).forEach((key) => {
+      urlObj.searchParams.set(key, String(params[key]));
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function removeQueryParams(url, keys) {
+  try {
+    const urlObj = new URL(url);
+    keys.forEach((key) => {
+      urlObj.searchParams.delete(key);
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function updateQueryParams(url, params) {
+  try {
+    const urlObj = new URL(url);
+    Object.keys(params).forEach((key) => {
+      const value = params[key];
+      if (value === null) {
+        urlObj.searchParams.delete(key);
+      } else {
+        urlObj.searchParams.set(key, String(value));
+      }
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function isAbsoluteUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return /^https?:\/\//i.test(url);
+  }
+}
+function joinUrl(baseUrl, ...paths) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const joinedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, "")).filter((path) => path.length > 0).join("/");
+  return `${base}/${joinedPaths}`;
+}
+function normalizeUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    urlObj.pathname = urlObj.pathname.replace(/\/+/g, "/");
+    return urlObj.toString();
+  } catch {
+    return url;
+  }
+}
 
-var chunkKGFTD255_js = require('./chunk-KGFTD255.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "buildUrl", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.buildUrl; }
-});
-Object.defineProperty(exports, "getQueryParams", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.getQueryParams; }
-});
-Object.defineProperty(exports, "isAbsoluteUrl", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.isAbsoluteUrl; }
-});
-Object.defineProperty(exports, "joinUrl", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.joinUrl; }
-});
-Object.defineProperty(exports, "normalizeUrl", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.normalizeUrl; }
-});
-Object.defineProperty(exports, "parseUrl", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.parseUrl; }
-});
-Object.defineProperty(exports, "removeQueryParams", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.removeQueryParams; }
-});
-Object.defineProperty(exports, "setQueryParams", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.setQueryParams; }
-});
-Object.defineProperty(exports, "updateQueryParams", {
-  enumerable: true,
-  get: function () { return chunkKGFTD255_js.updateQueryParams; }
-});
-//# sourceMappingURL=url.js.map
-//# sourceMappingURL=url.js.map
+export { buildUrl, getQueryParams, isAbsoluteUrl, joinUrl, normalizeUrl, parseUrl, removeQueryParams, setQueryParams, updateQueryParams };

package/dist/{chunk-TQN37HIN.js → validation.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/core/validation.ts
+// src/core/validation/index.ts
 function isValidEmail(email) {
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   return emailRegex.test(email);
@@ -90,5 +90,3 @@ exports.isValidJSON = isValidJSON;
 exports.isValidPhone = isValidPhone;
 exports.isValidUUID = isValidUUID;
 exports.isValidUrl = isValidUrl;
-//# sourceMappingURL=chunk-TQN37HIN.js.map
-//# sourceMappingURL=chunk-TQN37HIN.js.map