@minson1994/ms-utils 1.0.0

package/dist/index.js

@@ -0,0 +1,1753 @@
+import {
+  ApiAdapter,
+  ApiResponse
+} from "./chunk-PV2X54HI.js";
+
+// src/api/ApiConfig.ts
+var ApiGlobalConfig = class {
+  constructor(options = {}) {
+    /** 超时时间，单位秒。 */
+    this.timeout = 30;
+    /** 默认请求头。 */
+    this.headers = {};
+    /** 是否携带 Cookie。 */
+    this.withCredentials = false;
+    Object.assign(this, options);
+  }
+};
+var ApiConfig = class _ApiConfig extends ApiGlobalConfig {
+  constructor(options = {}) {
+    super(options);
+    /** 基础地址，由 ApiRequest 根据当前可用 base url 写入。 */
+    this.baseUrl = "";
+    /** 请求路径。 */
+    this.url = "";
+    /** 请求方法。 */
+    this.method = "GET";
+    /** 请求数据。 */
+    this.data = {};
+    /** 是否需要认证。 */
+    this.auth = false;
+    /** 是否为上传请求。 */
+    this.isUpload = false;
+    /** 是否以 JSON body 发送。 */
+    this.isJsonBody = false;
+    /** 是否需要签名。 */
+    this.isSign = false;
+    /** 是否显示 loading。 */
+    this.loading = false;
+    /** 是否显示错误消息。 */
+    this.showErrorMessage = true;
+    /** 是否检查 HTTP 状态码。 */
+    this.checkHttpStatus = false;
+    /** 业务失败时是否返回原结果。 */
+    this.backFailResult = false;
+    /** 成功时是否只返回业务 data 字段。 */
+    this.backOnlyData = true;
+    /** 是否启用缓存。 */
+    this.cache = false;
+    this.options = options;
+    Object.assign(this, options);
+  }
+  /** 设置是否需要认证。 */
+  useAuth(auth = true) {
+    this.auth = auth;
+    return this;
+  }
+  /** 设置超时时间，单位秒。 */
+  useTimeout(timeout) {
+    this.timeout = timeout;
+    return this;
+  }
+  /** 设置请求头。 */
+  useHeaders(headers) {
+    this.headers = headers;
+    return this;
+  }
+  /** 设置是否携带 Cookie。 */
+  useWithCredentials(withCredentials = true) {
+    this.withCredentials = withCredentials;
+    return this;
+  }
+  /** 设置取消请求注册回调。 */
+  useCancel(onCancel) {
+    this.onCancel = onCancel;
+    return this;
+  }
+  /** 设置上传进度回调。 */
+  useUploadProgress(onUploadProgress) {
+    this.onUploadProgress = onUploadProgress;
+    return this;
+  }
+  /** 设置下载进度回调。 */
+  useDownloadProgress(onDownloadProgress) {
+    this.onDownloadProgress = onDownloadProgress;
+    return this;
+  }
+  /** 同时设置上传和下载进度回调。 */
+  useProgress(onProgress) {
+    this.onUploadProgress = onProgress;
+    this.onDownloadProgress = onProgress;
+    return this;
+  }
+  /** 设置是否为上传请求。 */
+  useUpload(isUpload = true) {
+    this.isUpload = isUpload;
+    return this;
+  }
+  /** 设置是否以 JSON body 发送。 */
+  useJsonBody(isJsonBody = true) {
+    this.isJsonBody = isJsonBody;
+    return this;
+  }
+  /** 设置是否需要签名。 */
+  useSign(isSign = true) {
+    this.isSign = isSign;
+    return this;
+  }
+  /** 设置是否显示 loading。 */
+  useLoading(loading = true) {
+    this.loading = loading;
+    return this;
+  }
+  /** 设置是否显示错误消息。 */
+  useShowErrorMessage(showErrorMessage = false) {
+    this.showErrorMessage = showErrorMessage;
+    return this;
+  }
+  /** 设置是否检查 HTTP 状态码。 */
+  useCheckHttpStatus(checkHttpStatus = true) {
+    this.checkHttpStatus = checkHttpStatus;
+    return this;
+  }
+  /** 设置业务失败时是否返回原结果。 */
+  useBackFailResult(backFailResult = true) {
+    this.backFailResult = backFailResult;
+    return this;
+  }
+  /** 设置成功时是否只返回业务 data 字段。 */
+  useBackOnlyData(backOnlyData = false) {
+    this.backOnlyData = backOnlyData;
+    return this;
+  }
+  /** 设置是否启用缓存。 */
+  useCache(cache = true) {
+    this.cache = cache;
+    return this;
+  }
+  /**
+   * 使用指定请求对象执行当前配置。
+   */
+  request(request) {
+    return request.exec(this);
+  }
+  /**
+   * 使用绑定的请求对象执行当前配置。
+   */
+  emit() {
+    if (!this.apiRequest) {
+      throw new Error(
+        "\u6CA1\u6709\u7ED1\u5B9A ApiRequest\uFF0C\u8BF7\u4F7F\u7528 api.use(...).emit() \u6216 config.request(api)"
+      );
+    }
+    return this.apiRequest.exec(this);
+  }
+  /**
+   * exec 是 emit 的语义化别名。
+   */
+  exec() {
+    return this.emit();
+  }
+  /**
+   * 创建 ApiConfig。
+   */
+  static use(options = {}) {
+    return new _ApiConfig(options);
+  }
+};
+var useApiConfig = ApiConfig.use;
+
+// src/api/interceptor/ApiInterceptor.ts
+var ApiInterceptor = class {
+};
+
+// src/api/interceptor/ApiUIInterceptor.ts
+var ApiUIInterceptor = class extends ApiInterceptor {
+  /** 请求前显示 loading。 */
+  async before(config) {
+    if (config.loading && this.loading) await this.loading();
+  }
+  /** 请求结束后隐藏 loading。 */
+  async after(config, _response) {
+    if (config.loading && this.loadingHide) await this.loadingHide();
+  }
+  /** 按请求配置显示错误消息。 */
+  async showErrorMessage(config, message) {
+    if (config.showErrorMessage && this.errorMessage) {
+      await this.errorMessage(message, config);
+    }
+  }
+  /** 设置显示 loading 回调。 */
+  useLoading(loading) {
+    this.loading = loading;
+    return this;
+  }
+  /** 设置隐藏 loading 回调。 */
+  useLoadingHide(loadingHide) {
+    this.loadingHide = loadingHide;
+    return this;
+  }
+  /** 设置错误消息回调。 */
+  useErrorMessage(errorMessage) {
+    this.errorMessage = errorMessage;
+    return this;
+  }
+};
+
+// src/api/interceptor/ApiStatusInterceptor.ts
+var ApiStatusInterceptor = class extends ApiInterceptor {
+  constructor(options = {}) {
+    super();
+    /** 业务状态码字段名。 */
+    this.status = "code";
+    /** 业务消息字段名。 */
+    this.message = "message";
+    /** 业务数据字段名。 */
+    this.data = "data";
+    /** 成功业务状态码。 */
+    this.success = 200;
+    this.useConfig(options);
+  }
+  /**
+   * 状态拦截器不需要请求前处理。
+   */
+  async before(_config) {
+    return void 0;
+  }
+  /**
+   * 检查响应状态，并按配置改写 response.data。
+   */
+  async after(config, response) {
+    if (config.checkHttpStatus && (response.status < 200 || response.status >= 300)) {
+      throw new Error(`http request status ${response.status}`);
+    }
+    const body = response.data ?? {};
+    const businessCode = body[this.status];
+    const businessMessage = String(body[this.message] ?? "\u8BF7\u6C42\u5931\u8D25");
+    if ((businessCode === 401 || businessCode === 403) && !config.backFailResult) {
+      await this.onUnauthorized?.(businessMessage, response, config);
+    }
+    if (businessCode !== this.success && !config.backFailResult) {
+      throw new Error(businessMessage);
+    }
+    if (config.backOnlyData) {
+      response.data = body[this.data];
+    }
+  }
+  /**
+   * 更新业务字段映射和回调配置。
+   */
+  useConfig(options) {
+    if (options.status !== void 0) this.status = options.status;
+    if (options.message !== void 0) this.message = options.message;
+    if (options.data !== void 0) this.data = options.data;
+    if (options.success !== void 0) this.success = options.success;
+    if (options.onUnauthorized !== void 0) this.onUnauthorized = options.onUnauthorized;
+    return this;
+  }
+};
+
+// src/api/interceptor/ApiCacheInterceptor.ts
+var defaultCacheKey = (config) => JSON.stringify({
+  baseUrl: config.baseUrl,
+  url: config.url,
+  method: config.method,
+  data: config.data
+});
+var ApiCacheInterceptor = class extends ApiInterceptor {
+  constructor(getKey = defaultCacheKey) {
+    super();
+    this.getKey = getKey;
+    /** 缓存数据映射。 */
+    this.cacheMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 请求前命中缓存则直接返回缓存值。
+   */
+  async before(config) {
+    const key = this.getKey(config);
+    if (config.cache && this.cacheMap.has(key)) return this.cacheMap.get(key);
+    return void 0;
+  }
+  /**
+   * 请求后按 key 写入缓存。
+   */
+  async after(config, response) {
+    if (config.cache) this.cacheMap.set(this.getKey(config), response.data);
+  }
+};
+
+// src/api/ApiError.ts
+var ApiError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = new.target.name;
+  }
+};
+var ApiCancelError = class extends ApiError {
+  constructor(message = "\u8BF7\u6C42\u5DF2\u53D6\u6D88", cause) {
+    super(message, cause);
+  }
+};
+var ApiTimeoutError = class extends ApiError {
+  constructor(message = "\u8BF7\u6C42\u8D85\u65F6", cause) {
+    super(message, cause);
+  }
+};
+var ApiNetworkError = class extends ApiError {
+  constructor(message = "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25", cause) {
+    super(message, cause);
+  }
+};
+function isApiCancelError(error) {
+  if (error instanceof ApiCancelError) return true;
+  if (error instanceof DOMException && error.name === "AbortError") return true;
+  const source = error;
+  const message = String(source?.message ?? "").toLowerCase();
+  return source?.name === "AbortError" || source?.code === "ERR_CANCELED" || message.includes("aborted") || message.includes("cancel");
+}
+
+// src/api/adapter/FetchHttpAdapter.ts
+var FetchHttpAdapter = class extends ApiAdapter {
+  constructor(options = {}) {
+    super(
+      options.formDataFactory ? { formDataFactory: options.formDataFactory } : {}
+    );
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl)
+      throw new Error("fetch is not available; pass fetch to FetchHttpAdapter");
+    this.fetchImpl = fetchImpl.bind(globalThis);
+  }
+  /**
+   * 将 ApiConfig 转换为 fetch 配置并发起请求。
+   */
+  async request(config) {
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const method = (config.method || "GET").toUpperCase();
+    const headers = { ...config.headers };
+    const requestConfig = {
+      method,
+      headers,
+      credentials: config.withCredentials ? "include" : "same-origin"
+    };
+    if (controller) requestConfig.signal = controller.signal;
+    const onCancel = config.onCancel ?? config.cancelCallback;
+    if (onCancel && controller) {
+      onCancel((message) => {
+        controller.abort(new ApiCancelError(message));
+      });
+    }
+    let timer;
+    if (controller && config.timeout > 0) {
+      timer = setTimeout(
+        () => controller.abort(new ApiTimeoutError()),
+        config.timeout * 1e3
+      );
+    }
+    try {
+      let url = this.resolveUrl(config.baseUrl, config.url);
+      if (config.isUpload) {
+        const uploadTarget = {
+          headers,
+          method
+        };
+        this.formData(config, uploadTarget);
+        requestConfig.body = uploadTarget.data;
+        if (uploadTarget.method) requestConfig.method = uploadTarget.method;
+        delete headers["Content-Type"];
+        delete headers["content-type"];
+      } else if (method === "GET" || method === "HEAD" || method === "DELETE") {
+        url = this.appendQuery(url, config.data);
+      } else if (config.isJsonBody) {
+        headers["Content-Type"] ?? (headers["Content-Type"] = "application/json");
+        requestConfig.body = JSON.stringify(config.data ?? {});
+      } else {
+        headers["Content-Type"] ?? (headers["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8");
+        requestConfig.body = this.toSearchParams(config.data).toString();
+      }
+      let response;
+      try {
+        response = await this.fetchImpl(url, requestConfig);
+      } catch (error) {
+        if (controller?.signal.reason) throw controller.signal.reason;
+        throw error;
+      }
+      return new ApiResponse(
+        response.status,
+        await this.parseResponse(response, config)
+      );
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  /**
+   * 拼接 baseUrl 和 url。
+   */
+  resolveUrl(baseUrl, url) {
+    if (/^https?:\/\//i.test(url)) return url;
+    return `${baseUrl}${url}`;
+  }
+  /**
+   * 给 URL 追加查询参数。
+   */
+  appendQuery(url, data) {
+    const query = this.toSearchParams(data).toString();
+    if (!query) return url;
+    return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+  }
+  /**
+   * 转换为 URLSearchParams。
+   */
+  toSearchParams(data) {
+    const params = new URLSearchParams();
+    if (!data || typeof data !== "object") return params;
+    for (const [key, value] of Object.entries(
+      data
+    )) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) params.append(key, String(item));
+      } else {
+        params.append(key, String(value));
+      }
+    }
+    return params;
+  }
+  /**
+   * 按响应 Content-Type 解析响应体。
+   */
+  async parseResponse(response, config) {
+    if (response.status === 204) return void 0;
+    const contentType = response.headers.get("content-type") ?? "";
+    const text = config.onDownloadProgress ? await this.readTextWithProgress(response, config) : await response.text();
+    if (!text) return void 0;
+    if (contentType.includes("application/json")) return JSON.parse(text);
+    return text;
+  }
+  /**
+   * 读取响应文本并触发下载进度。
+   */
+  async readTextWithProgress(response, config) {
+    if (!response.body) {
+      const text = await response.text();
+      this.emitProgress(config.onDownloadProgress, text.length, text.length);
+      return text;
+    }
+    const totalHeader = response.headers.get("content-length");
+    const total = totalHeader ? Number(totalHeader) : void 0;
+    const reader = response.body.getReader();
+    const chunks = [];
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      chunks.push(value);
+      loaded += value.byteLength;
+      this.emitProgress(config.onDownloadProgress, loaded, total);
+    }
+    const bytes = new Uint8Array(loaded);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(bytes);
+  }
+};
+
+// src/api/adapter/XhrHttpAdapter.ts
+var XhrHttpAdapter = class extends ApiAdapter {
+  constructor(options = {}) {
+    super(
+      options.formDataFactory ? { formDataFactory: options.formDataFactory } : {}
+    );
+    this.xhrFactory = options.xhrFactory ?? (() => {
+      if (typeof XMLHttpRequest === "undefined") {
+        throw new Error(
+          "XMLHttpRequest is not available; pass xhrFactory to XhrHttpAdapter"
+        );
+      }
+      return new XMLHttpRequest();
+    });
+  }
+  /**
+   * 将 ApiConfig 转换为 XMLHttpRequest 并发起请求。
+   */
+  request(config) {
+    return new Promise((resolve, reject) => {
+      const xhr = this.xhrFactory();
+      const method = (config.method || "GET").toUpperCase();
+      let url = this.resolveUrl(config.baseUrl, config.url);
+      let body;
+      const headers = { ...config.headers };
+      if (config.isUpload) {
+        const uploadTarget = {
+          headers,
+          method
+        };
+        this.formData(config, uploadTarget);
+        body = uploadTarget.data;
+        delete headers["Content-Type"];
+        delete headers["content-type"];
+      } else if (method === "GET" || method === "HEAD" || method === "DELETE") {
+        url = this.appendQuery(url, config.data);
+      } else if (config.isJsonBody) {
+        headers["Content-Type"] ?? (headers["Content-Type"] = "application/json");
+        body = JSON.stringify(config.data ?? {});
+      } else {
+        headers["Content-Type"] ?? (headers["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8");
+        body = this.toSearchParams(config.data).toString();
+      }
+      xhr.open(method, url, true);
+      xhr.timeout = config.timeout * 1e3;
+      xhr.withCredentials = config.withCredentials;
+      for (const [key, value] of Object.entries(headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+      if (config.onUploadProgress) {
+        xhr.upload.onprogress = (event) => this.emitProgressEvent(config.onUploadProgress, event);
+      }
+      if (config.onDownloadProgress) {
+        xhr.onprogress = (event) => this.emitProgressEvent(config.onDownloadProgress, event);
+      }
+      xhr.onload = () => {
+        resolve(new ApiResponse(xhr.status, this.parseResponse(xhr)));
+      };
+      xhr.onerror = () => reject(new Error("XMLHttpRequest error"));
+      xhr.ontimeout = () => reject(new ApiTimeoutError("XMLHttpRequest timeout"));
+      xhr.onabort = () => reject(new ApiCancelError("XMLHttpRequest aborted"));
+      const onCancel = config.onCancel ?? config.cancelCallback;
+      if (onCancel) onCancel(() => xhr.abort());
+      xhr.send(body);
+    });
+  }
+  /**
+   * 拼接 baseUrl 和 url。
+   */
+  resolveUrl(baseUrl, url) {
+    if (/^https?:\/\//i.test(url)) return url;
+    return `${baseUrl}${url}`;
+  }
+  /**
+   * 给 URL 追加查询参数。
+   */
+  appendQuery(url, data) {
+    const query = this.toSearchParams(data).toString();
+    if (!query) return url;
+    return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+  }
+  /**
+   * 转换为 URLSearchParams。
+   */
+  toSearchParams(data) {
+    const params = new URLSearchParams();
+    if (!data || typeof data !== "object") return params;
+    for (const [key, value] of Object.entries(
+      data
+    )) {
+      if (value === void 0 || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) params.append(key, String(item));
+      } else {
+        params.append(key, String(value));
+      }
+    }
+    return params;
+  }
+  /**
+   * 按响应 Content-Type 解析响应体。
+   */
+  parseResponse(xhr) {
+    const contentType = xhr.getResponseHeader("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      if (!xhr.responseText) return void 0;
+      return JSON.parse(xhr.responseText);
+    }
+    return xhr.responseText;
+  }
+};
+
+// src/api/ApiRequest.ts
+var _ApiRequest = class _ApiRequest {
+  constructor(options) {
+    /** 自定义业务拦截器。 */
+    this.interceptor = [];
+    /** 当前使用的 base url 下标。 */
+    this.currentUrlIndex = 0;
+    /** 响应状态拦截器。 */
+    this.statusInterceptor = new ApiStatusInterceptor();
+    /** 缓存拦截器。 */
+    this.cacheInterceptor = new ApiCacheInterceptor();
+    /** 多 base url 失败重试间隔，单位毫秒。 */
+    this.retryDelay = 1e3;
+    this.urls = Array.isArray(options.url) ? options.url : [options.url];
+    this.adapter = options.adapter ?? _ApiRequest.createDefaultAdapter();
+    this.config = options.config ?? options.appConfig;
+    if (options.interceptor) this.interceptor = options.interceptor;
+    if (options.statusInterceptor)
+      this.statusInterceptor = options.statusInterceptor;
+    if (options.cacheInterceptor)
+      this.cacheInterceptor = options.cacheInterceptor;
+    if (options.retryDelay !== void 0) this.retryDelay = options.retryDelay;
+  }
+  /**
+   * 创建默认适配器。
+   *
+   * 浏览器环境优先使用 XHR，以支持上传/下载进度；没有 XMLHttpRequest 时使用 fetch。
+   */
+  static createDefaultAdapter() {
+    if (typeof XMLHttpRequest !== "undefined") return new XhrHttpAdapter();
+    return new FetchHttpAdapter();
+  }
+  /** 当前 base url。 */
+  get uri() {
+    return this.urls[this.currentUrlIndex] ?? "";
+  }
+  /** 添加自定义拦截器。 */
+  pushInterceptor(interceptor) {
+    this.interceptor.push(interceptor);
+    return this;
+  }
+  /** 执行请求并返回业务结果。 */
+  async exec(config) {
+    this.applyGlobalConfig(config);
+    config.baseUrl = this.uri;
+    try {
+      await _ApiRequest.apiUIInterceptor.before(config);
+      const cached = await this.before(config);
+      if (cached !== void 0) return cached;
+      const response = await this.request(config);
+      await this.after(config, response);
+      return response.data;
+    } catch (error) {
+      await _ApiRequest.apiUIInterceptor.showErrorMessage(
+        config,
+        error instanceof Error ? error.message : String(error)
+      );
+      throw error;
+    } finally {
+      await _ApiRequest.apiUIInterceptor.after(config);
+    }
+  }
+  /**
+   * 执行前置拦截器。
+   *
+   * 任意拦截器返回非 undefined 数据时，作为请求结果直接返回。
+   */
+  async before(config) {
+    for (const interceptor of this.interceptor) {
+      const result = await interceptor.before(config);
+      if (result !== void 0) return result;
+    }
+    return this.cacheInterceptor.before(config);
+  }
+  /** 执行后置拦截器。 */
+  async after(config, response) {
+    await this.statusInterceptor.after(config, response);
+    for (const interceptor of this.interceptor)
+      await interceptor.after(config, response);
+    await this.cacheInterceptor.after(config, response);
+  }
+  /**
+   * 调用底层 adapter 发起请求。
+   *
+   * 多 base url 场景下，请求失败会切换到下一个 base url 重试。
+   */
+  async request(config) {
+    let triedUrls = 0;
+    let lastError;
+    while (triedUrls < this.urls.length) {
+      config.baseUrl = this.uri;
+      try {
+        return await this.adapter.request(config);
+      } catch (error) {
+        if (isApiCancelError(error)) throw error;
+        this.currentUrlIndex = (this.currentUrlIndex + 1) % this.urls.length;
+        triedUrls += 1;
+        lastError = error;
+        if (triedUrls < this.urls.length) await this.delay(this.retryDelay);
+      }
+    }
+    throw lastError;
+  }
+  /** 延迟指定毫秒。 */
+  delay(time = 1e3) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, time);
+    });
+  }
+  /**
+   * 创建 ApiConfig。
+   */
+  use(options = {}) {
+    const cf = new ApiConfig(options);
+    cf.apiRequest = this;
+    return cf;
+  }
+  /** 将全局配置合并到单次请求配置。 */
+  applyGlobalConfig(config) {
+    if (!this.config) return;
+    if (config.options.timeout === void 0) config.timeout = this.config.timeout;
+    config.headers = { ...this.config.headers, ...config.headers };
+    if (config.options.withCredentials === void 0) {
+      config.withCredentials = this.config.withCredentials;
+    }
+  }
+};
+/** 全局 UI 拦截器，所有 ApiRequest 实例共享。 */
+_ApiRequest.apiUIInterceptor = new ApiUIInterceptor();
+var ApiRequest = _ApiRequest;
+
+// src/utils/Concurrency.ts
+var _Concurrency = class _Concurrency {
+  /**
+   * 创建一个带并发去重能力的异步函数。
+   *
+   * @param fn 原始异步函数
+   * @param name 调用名称，用于隔离不同业务
+   * @param getKey 参数转 key 方法，默认会对对象 key 排序后序列化
+   */
+  static createConcurrentCall(fn, name, getKey = (...args) => _Concurrency.defaultKey(...args)) {
+    return async (...args) => {
+      const key = `${name}-${getKey(...args)}`;
+      const pending = this.pendingRequests.get(key);
+      if (pending) return pending;
+      const promise = (async () => {
+        try {
+          return await fn(...args);
+        } finally {
+          setTimeout(() => {
+            this.pendingRequests.delete(key);
+          }, 0);
+        }
+      })();
+      this.pendingRequests.set(key, promise);
+      return promise;
+    };
+  }
+  /**
+   * 默认 key 生成逻辑。
+   */
+  static defaultKey(...args) {
+    return args.map((arg) => {
+      if (arg && typeof arg === "object" && !Array.isArray(arg)) {
+        const sorted = Object.fromEntries(Object.entries(arg).sort(([a], [b]) => a.localeCompare(b)));
+        return JSON.stringify(sorted);
+      }
+      return String(arg);
+    }).join("-");
+  }
+};
+/**
+ * 正在执行中的请求映射。
+ */
+_Concurrency.pendingRequests = /* @__PURE__ */ new Map();
+var Concurrency = _Concurrency;
+
+// src/utils/AlgorithmUtils.ts
+import CryptoJS from "crypto-js";
+var AlgorithmUtils = class {
+  /** Base64 ?? UTF-8 ??? */
+  static base64Encode(text) {
+    return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(text));
+  }
+  /** Base64 ??? UTF-8 ??? */
+  static base64Decode(base64) {
+    return CryptoJS.enc.Base64.parse(base64).toString(CryptoJS.enc.Utf8);
+  }
+  /**
+   * ?? MD5?
+   *
+   * @param length 16 ??? 32 ? MD5 ??? 16 ??
+   * @param upper ??????
+   */
+  static md5(text, length = 32, upper = false) {
+    const value = CryptoJS.MD5(text).toString();
+    const result = length === 16 ? value.slice(8, 24) : value;
+    return upper ? result.toUpperCase() : result;
+  }
+  /** ?? 16 ? MD5? */
+  static md5_16(text, upper = false) {
+    return this.md5(text, 16, upper);
+  }
+  /** ?? 32 ? MD5? */
+  static md5_32(text, upper = false) {
+    return this.md5(text, 32, upper);
+  }
+  /** AES ????? iv ??? crypto-js passphrase ???? iv ??? CBC + PKCS7? */
+  static aesEncrypt(text, options) {
+    const aesOptions = this.normalizeAesOptions(options);
+    if (!aesOptions.iv)
+      return CryptoJS.AES.encrypt(text, aesOptions.key).toString();
+    return CryptoJS.AES.encrypt(text, CryptoJS.enc.Utf8.parse(aesOptions.key), {
+      iv: CryptoJS.enc.Utf8.parse(aesOptions.iv),
+      mode: CryptoJS.mode.CBC,
+      padding: CryptoJS.pad.Pkcs7
+    }).toString();
+  }
+  /** AES ??? */
+  static aesDecrypt(ciphertext, options) {
+    const aesOptions = this.normalizeAesOptions(options);
+    const bytes = aesOptions.iv ? CryptoJS.AES.decrypt(
+      ciphertext,
+      CryptoJS.enc.Utf8.parse(aesOptions.key),
+      {
+        iv: CryptoJS.enc.Utf8.parse(aesOptions.iv),
+        mode: CryptoJS.mode.CBC,
+        padding: CryptoJS.pad.Pkcs7
+      }
+    ) : CryptoJS.AES.decrypt(ciphertext, aesOptions.key);
+    return bytes.toString(CryptoJS.enc.Utf8);
+  }
+  /** ?? SHA256? */
+  static sha256(text, upper = false) {
+    const value = CryptoJS.SHA256(text).toString();
+    return upper ? value.toUpperCase() : value;
+  }
+  /** ?? HMAC? */
+  static hmac(text, key, algorithm = "SHA256", upper = false) {
+    const value = {
+      SHA256: () => CryptoJS.HmacSHA256(text, key),
+      SHA1: () => CryptoJS.HmacSHA1(text, key),
+      MD5: () => CryptoJS.HmacMD5(text, key)
+    }[algorithm]().toString();
+    return upper ? value.toUpperCase() : value;
+  }
+  /** ?? HMAC-SHA256? */
+  static hmacSha256(text, key, upper = false) {
+    return this.hmac(text, key, "SHA256", upper);
+  }
+  /** ?? UUID v4? */
+  static uuid() {
+    const bytes = this.randomBytes(16);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(
+      bytes,
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  /** ??????????????? min ? max? */
+  static randomInt(min, max) {
+    const lower = Math.ceil(min);
+    const upper = Math.floor(max);
+    if (upper < lower)
+      throw new Error("max must be greater than or equal to min");
+    return lower + Math.floor(this.randomFloat() * (upper - lower + 1));
+  }
+  /** ?? 0 <= n < 1 ?????? */
+  static randomFloat() {
+    const bytes = this.randomBytes(4);
+    const value = (bytes[0] << 24 >>> 0) + (bytes[1] << 16) + (bytes[2] << 8) + bytes[3];
+    return value / 4294967296;
+  }
+  /** ???????? */
+  static randomString(length = 16, chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+    if (length < 0)
+      throw new Error("length must be greater than or equal to 0");
+    if (!chars) throw new Error("chars must not be empty");
+    let result = "";
+    for (let i = 0; i < length; i += 1) {
+      result += chars[this.randomInt(0, chars.length - 1)];
+    }
+    return result;
+  }
+  /** ?? RSA-OAEP ???? */
+  static async rsaGenerateKeyPair(modulusLength = 2048) {
+    const keyPair = await this.subtle().generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: "SHA-256"
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    return {
+      publicKey: keyPair.publicKey,
+      privateKey: keyPair.privateKey
+    };
+  }
+  /** ?? RSA-OAEP PEM ???? */
+  static async rsaGeneratePemKeyPair(modulusLength = 2048) {
+    const keyPair = await this.rsaGenerateKeyPair(modulusLength);
+    return {
+      publicKey: await this.rsaExportPublicKey(keyPair.publicKey),
+      privateKey: await this.rsaExportPrivateKey(keyPair.privateKey)
+    };
+  }
+  /** RSA-OAEP ??????? Base64 ??? */
+  static async rsaEncrypt(text, publicKey) {
+    const key = typeof publicKey === "string" ? await this.rsaImportPublicKey(publicKey) : publicKey;
+    const encrypted = await this.subtle().encrypt(
+      { name: "RSA-OAEP" },
+      key,
+      new TextEncoder().encode(text)
+    );
+    return this.arrayBufferToBase64(encrypted);
+  }
+  /** RSA-OAEP ???? Base64 ??? */
+  static async rsaDecrypt(ciphertext, privateKey) {
+    const key = typeof privateKey === "string" ? await this.rsaImportPrivateKey(privateKey) : privateKey;
+    const decrypted = await this.subtle().decrypt(
+      { name: "RSA-OAEP" },
+      key,
+      this.base64ToArrayBuffer(ciphertext)
+    );
+    return new TextDecoder().decode(decrypted);
+  }
+  /** ?? RSA ??? PEM? */
+  static async rsaExportPublicKey(publicKey) {
+    const buffer = await this.subtle().exportKey("spki", publicKey);
+    return this.arrayBufferToPem(buffer, "PUBLIC KEY");
+  }
+  /** ?? RSA ??? PEM? */
+  static async rsaExportPrivateKey(privateKey) {
+    const buffer = await this.subtle().exportKey("pkcs8", privateKey);
+    return this.arrayBufferToPem(buffer, "PRIVATE KEY");
+  }
+  /** ? PEM ?? RSA ??? */
+  static async rsaImportPublicKey(pem) {
+    return this.subtle().importKey(
+      "spki",
+      this.pemToArrayBuffer(pem),
+      { name: "RSA-OAEP", hash: "SHA-256" },
+      true,
+      ["encrypt"]
+    );
+  }
+  /** ? PEM ?? RSA ??? */
+  static async rsaImportPrivateKey(pem) {
+    return this.subtle().importKey(
+      "pkcs8",
+      this.pemToArrayBuffer(pem),
+      { name: "RSA-OAEP", hash: "SHA-256" },
+      true,
+      ["decrypt"]
+    );
+  }
+  /** ??? AES ??? */
+  static normalizeAesOptions(options) {
+    return typeof options === "string" ? { key: options } : options;
+  }
+  /** ??????? */
+  static randomBytes(length) {
+    const crypto = globalThis.crypto;
+    if (crypto?.getRandomValues)
+      return crypto.getRandomValues(new Uint8Array(length));
+    const words = CryptoJS.lib.WordArray.random(length);
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i += 1) {
+      bytes[i] = words.words[Math.floor(i / 4)] >> 24 - i % 4 * 8 & 255;
+    }
+    return bytes;
+  }
+  /** ?? SubtleCrypto? */
+  static subtle() {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle)
+      throw new Error("SubtleCrypto is not available in current runtime");
+    return subtle;
+  }
+  /** ArrayBuffer ? Base64? */
+  static arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return this.binaryToBase64(binary);
+  }
+  /** Base64 ? ArrayBuffer? */
+  static base64ToArrayBuffer(base64) {
+    const binary = this.base64ToBinary(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+  }
+  /** ArrayBuffer ? PEM? */
+  static arrayBufferToPem(buffer, label) {
+    const base64 = this.arrayBufferToBase64(buffer).replace(/(.{64})/g, "$1\n");
+    return `-----BEGIN ${label}-----
+${base64}
+-----END ${label}-----`;
+  }
+  /** PEM ? ArrayBuffer? */
+  static pemToArrayBuffer(pem) {
+    const base64 = pem.replace(/-----BEGIN [^-]+-----/g, "").replace(/-----END [^-]+-----/g, "").replace(/\s+/g, "");
+    return this.base64ToArrayBuffer(base64);
+  }
+  /** ??????? Base64? */
+  static binaryToBase64(binary) {
+    if (typeof btoa === "function") return btoa(binary);
+    return Buffer.from(binary, "binary").toString("base64");
+  }
+  /** Base64 ???????? */
+  static base64ToBinary(base64) {
+    if (typeof atob === "function") return atob(base64);
+    return Buffer.from(base64, "base64").toString("binary");
+  }
+};
+
+// src/utils/Hook.ts
+var hookMap = /* @__PURE__ */ new Map();
+var Hook = class _Hook {
+  /**
+   * @param no Hook 编号，默认随机生成
+   * @param timeout 超时时间，单位秒
+   */
+  constructor(no = randomText(16, 32), timeout) {
+    /**
+     * 超时时间，单位秒。
+     */
+    this.timeout = 30;
+    this.no = no;
+    if (timeout !== void 0) this.timeout = timeout;
+  }
+  /**
+   * 回调
+   * @param data
+   */
+  call(data) {
+    _Hook.call(this, data);
+  }
+  /**
+   * 注册一个 Hook，并返回等待外部唤醒的 Promise。
+   */
+  static on(hook) {
+    return new Promise((resolve, reject) => {
+      const instance = hook instanceof _Hook ? hook : new _Hook(hook);
+      _Hook.clear(instance.no);
+      instance.resolve = resolve;
+      instance.reject = reject;
+      if (instance.timeout) {
+        instance.timer = setTimeout(() => {
+          _Hook.clear(instance);
+          reject(new Error("\u8D85\u65F6..."));
+        }, instance.timeout * 1e3);
+      }
+      hookMap.set(instance.no.toString(), instance);
+    });
+  }
+  /**
+   * 唤醒指定 Hook。
+   *
+   * data 为 Error 时 reject，否则 resolve。
+   */
+  static call(hook, data) {
+    const instance = hook instanceof _Hook ? hook : hookMap.get(hook.toString());
+    if (!instance) return;
+    if (data instanceof Error) instance.reject?.(data);
+    else instance.resolve?.(data);
+    _Hook.clear(instance);
+  }
+  /**
+   * 清理指定 Hook。
+   */
+  static clear(hook) {
+    const instance = hook instanceof _Hook ? hook : hookMap.get(hook.toString());
+    if (!instance) return;
+    if (instance.timer) clearTimeout(instance.timer);
+    hookMap.delete(instance.no.toString());
+  }
+  /**
+   * 自动生成 Hook 编号并执行回调，随后等待外部通过编号 call。
+   */
+  static async no(fn, timeout) {
+    const hook = new _Hook(void 0, timeout);
+    await fn(hook.no);
+    return _Hook.on(hook);
+  }
+};
+function randomText(min = 12, max = 16) {
+  const num = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+  const lower = "abcdefghijklmnopqrstuvwxyz".split("");
+  const upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+  const special = ["-", "_", "#", "@", "%", "&", "*", "$"];
+  const config = [...num, ...lower, ...upper, ...special];
+  const result = [pick(num), pick(lower), pick(upper), pick(special)];
+  const len = min + Math.floor(Math.random() * (max - min + 1));
+  for (let i = 4; i < len; i += 1) result.push(pick(config));
+  return shuffle(result).join("");
+}
+function pick(values) {
+  return values[Math.floor(Math.random() * values.length)] ?? "";
+}
+function shuffle(values) {
+  const copy = [...values];
+  for (let i = copy.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [copy[i], copy[j]] = [copy[j], copy[i]];
+  }
+  return copy;
+}
+
+// src/utils/TaskQueue.ts
+var TaskQueue = class _TaskQueue {
+  constructor(options = {}) {
+    /**
+     * 当前运行中的任务数。
+     */
+    this.running = 0;
+    /**
+     * 等待执行的任务队列。
+     */
+    this.queue = [];
+    /**
+     * 是否暂停。
+     */
+    this.paused = false;
+    /**
+     * 是否停止。
+     */
+    this.stopped = false;
+    /**
+     * waitForIdle 等待回调。
+     */
+    this.idleResolvers = [];
+    const { concurrency = 1, timeout = 3e4, taskDelayMs = 0 } = options;
+    this.concurrency = normalizeConcurrency(concurrency);
+    this.timeout = normalizeTimeout(timeout);
+    this.taskDelayMs = normalizeTimeout(taskDelayMs);
+  }
+  /**
+   * 延迟指定毫秒后返回 value。
+   */
+  static delay(ms, value) {
+    return new Promise((resolve) => {
+      setTimeout(() => resolve(value), ms);
+    });
+  }
+  /**
+   * 设置最大并发数。
+   */
+  setConcurrency(concurrency) {
+    this.concurrency = normalizeConcurrency(concurrency);
+    this.next();
+  }
+  /**
+   * 设置默认任务超时时间，单位毫秒。
+   */
+  setTimeout(timeout) {
+    this.timeout = normalizeTimeout(timeout);
+  }
+  /**
+   * 设置任务间隔时间，单位毫秒。
+   */
+  setTaskDelay(delayMs) {
+    this.taskDelayMs = normalizeTimeout(delayMs);
+  }
+  /**
+   * 添加单个任务。
+   *
+   * @param task 要执行的任务函数
+   * @param timeout 当前任务的超时时间，单位毫秒。不传则使用默认超时时间
+   */
+  add(task, timeout) {
+    if (typeof task !== "function") {
+      return Promise.reject(new TypeError("TaskQueue.add requires a task function"));
+    }
+    if (this.stopped) {
+      return Promise.reject(new Error("TaskQueue stopped"));
+    }
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        task,
+        resolve,
+        reject,
+        timeout: timeout == null ? this.timeout : normalizeTimeout(timeout),
+        settled: false
+      });
+      this.next();
+    });
+  }
+  /**
+   * 批量添加任务。
+   */
+  addMany(tasks = []) {
+    return Promise.all(tasks.map((task) => this.add(task)));
+  }
+  /**
+   * 暂停队列。
+   *
+   * 已经运行的任务不会被取消，但不会启动新任务。
+   */
+  pause() {
+    this.paused = true;
+  }
+  /**
+   * 恢复队列。
+   */
+  resume() {
+    if (!this.paused) return;
+    this.paused = false;
+    this.next();
+  }
+  /**
+   * 清空等待队列。
+   *
+   * 运行中的任务不受影响。
+   */
+  clear(reason = new Error("TaskQueue cleared")) {
+    this.rejectQueued(reason);
+    this.queue = [];
+    this.resolveIdleIfNeeded();
+  }
+  /**
+   * 停止队列。
+   *
+   * 会拒绝所有等待中的任务，并禁止继续添加新任务。
+   */
+  stop(reason = new Error("TaskQueue stopped")) {
+    this.stopped = true;
+    this.paused = false;
+    this.clear(reason);
+  }
+  /**
+   * 重置队列状态。
+   *
+   * 会清空等待队列和运行计数，不会取消已经运行的异步函数本身。
+   */
+  reset() {
+    this.stopped = false;
+    this.paused = false;
+    this.queue = [];
+    this.running = 0;
+    this.resolveIdleIfNeeded();
+  }
+  /**
+   * 等待队列空闲。
+   *
+   * 当没有等待任务且没有运行中任务时 resolve。
+   */
+  waitForIdle() {
+    if (!this.queue.length && !this.running) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+  /**
+   * 等待中的任务数。
+   */
+  get size() {
+    return this.queue.length;
+  }
+  /**
+   * 当前运行中的任务数。
+   */
+  get activeCount() {
+    return this.running;
+  }
+  /**
+   * 尝试启动队列中的任务。
+   */
+  next() {
+    if (this.paused || this.stopped) return;
+    while (this.canRunMore() && this.queue.length) {
+      const entry = this.queue.shift();
+      if (entry) void this.runTask(entry);
+    }
+    this.resolveIdleIfNeeded();
+  }
+  /**
+   * 判断是否还能启动更多任务。
+   */
+  canRunMore() {
+    if (!this.concurrency) return true;
+    return this.running < this.concurrency;
+  }
+  /**
+   * 执行单个任务。
+   */
+  async runTask(entry) {
+    this.running += 1;
+    let timer;
+    if (entry.timeout > 0) {
+      timer = setTimeout(() => {
+        this.rejectEntry(entry, new Error("Task timeout"));
+      }, entry.timeout);
+    }
+    try {
+      const result = await entry.task();
+      this.resolveEntry(entry, result);
+    } catch (error) {
+      this.rejectEntry(entry, error);
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (this.taskDelayMs > 0 && !this.stopped) {
+        await _TaskQueue.delay(this.taskDelayMs);
+      }
+      this.running = Math.max(this.running - 1, 0);
+      this.next();
+    }
+  }
+  /**
+   * resolve 指定任务，避免重复 settle。
+   */
+  resolveEntry(entry, value) {
+    if (entry.settled) return;
+    entry.settled = true;
+    entry.resolve(value);
+  }
+  /**
+   * reject 指定任务，避免重复 settle。
+   */
+  rejectEntry(entry, error) {
+    if (entry.settled) return;
+    entry.settled = true;
+    entry.reject(error);
+  }
+  /**
+   * reject 所有等待中的任务。
+   */
+  rejectQueued(reason) {
+    for (const entry of this.queue) {
+      this.rejectEntry(entry, reason);
+    }
+  }
+  /**
+   * 如果队列空闲，唤醒所有 waitForIdle。
+   */
+  resolveIdleIfNeeded() {
+    if (this.queue.length || this.running) return;
+    const resolvers = this.idleResolvers.splice(0);
+    for (const resolve of resolvers) resolve();
+  }
+};
+function normalizeConcurrency(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return 1;
+  return Math.floor(number);
+}
+function normalizeTimeout(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 0;
+  return Math.max(Math.floor(number), 0);
+}
+
+// src/utils/TimeUtils.ts
+var TimeUtils = class {
+  /**
+   * 获取当前时间。
+   */
+  static now() {
+    return /* @__PURE__ */ new Date();
+  }
+  /**
+   * 获取时间戳。
+   *
+   * @param date 时间输入，默认当前时间
+   * @param unit 返回毫秒或秒
+   */
+  static timestamp(date = /* @__PURE__ */ new Date(), unit = "millisecond") {
+    const time = this.toDate(date).getTime();
+    return unit === "second" ? Math.floor(time / 1e3) : time;
+  }
+  /**
+   * 将 Date、时间戳、时间字符串转换为新的 Date 实例。
+   *
+   * 字符串中的 `-` 会替换成 `/`，兼容部分浏览器对 `yyyy-MM-dd` 的解析差异。
+   */
+  static toDate(value) {
+    if (value instanceof Date) return new Date(value.getTime());
+    if (typeof value === "number") return new Date(value);
+    return new Date(value.replace(/-/g, "/"));
+  }
+  /**
+   * 判断输入是否可转换为有效时间。
+   */
+  static isValid(value) {
+    if (!(value instanceof Date) && typeof value !== "number" && typeof value !== "string") return false;
+    return !Number.isNaN(this.toDate(value).getTime());
+  }
+  /**
+   * 格式化时间。
+   *
+   * 支持 token：yyyy、MM、dd、HH、mm、ss、SSS。
+   */
+  static format(date = /* @__PURE__ */ new Date(), pattern = "yyyy-MM-dd HH:mm:ss") {
+    const target = this.toDate(date);
+    const values = {
+      yyyy: String(target.getFullYear()),
+      MM: this.pad(target.getMonth() + 1),
+      dd: this.pad(target.getDate()),
+      HH: this.pad(target.getHours()),
+      mm: this.pad(target.getMinutes()),
+      ss: this.pad(target.getSeconds()),
+      SSS: this.pad(target.getMilliseconds(), 3)
+    };
+    return pattern.replace(/yyyy|MM|dd|HH|mm|ss|SSS/g, (token) => values[token] ?? token);
+  }
+  /**
+   * 给时间增加指定单位的数量。
+   */
+  static add(date, amount, unit) {
+    const target = this.toDate(date);
+    switch (unit) {
+      case "millisecond":
+        target.setMilliseconds(target.getMilliseconds() + amount);
+        break;
+      case "second":
+        target.setSeconds(target.getSeconds() + amount);
+        break;
+      case "minute":
+        target.setMinutes(target.getMinutes() + amount);
+        break;
+      case "hour":
+        target.setHours(target.getHours() + amount);
+        break;
+      case "day":
+        target.setDate(target.getDate() + amount);
+        break;
+      case "week":
+        target.setDate(target.getDate() + amount * 7);
+        break;
+      case "month":
+        target.setMonth(target.getMonth() + amount);
+        break;
+      case "year":
+        target.setFullYear(target.getFullYear() + amount);
+        break;
+    }
+    return target;
+  }
+  /**
+   * 给时间减少指定单位的数量。
+   */
+  static subtract(date, amount, unit) {
+    return this.add(date, -amount, unit);
+  }
+  /**
+   * 计算两个时间的差值。
+   *
+   * month/year 当前按 30/365 天近似计算，适合轻量工具场景。
+   */
+  static diff(start, end, unit = "millisecond") {
+    const value = this.toDate(end).getTime() - this.toDate(start).getTime();
+    const divisors = {
+      millisecond: 1,
+      second: 1e3,
+      minute: 60 * 1e3,
+      hour: 60 * 60 * 1e3,
+      day: 24 * 60 * 60 * 1e3,
+      week: 7 * 24 * 60 * 60 * 1e3,
+      month: 30 * 24 * 60 * 60 * 1e3,
+      year: 365 * 24 * 60 * 60 * 1e3
+    };
+    return Math.floor(value / divisors[unit]);
+  }
+  /**
+   * 格式化为相对当前时间的描述。
+   *
+   * 默认返回中文短语，例如：刚刚、3 分钟前、2 小时后。
+   *
+   * @param date 目标时间
+   * @param base 基准时间，默认当前时间
+   */
+  static fromNow(date, base = /* @__PURE__ */ new Date()) {
+    const diff = this.toDate(base).getTime() - this.toDate(date).getTime();
+    const abs = Math.abs(diff);
+    const suffix = diff >= 0 ? "\u524D" : "\u540E";
+    if (abs < 5 * 1e3) return "\u521A\u521A";
+    const units = [
+      ["\u5E74", 365 * 24 * 60 * 60 * 1e3],
+      ["\u6708", 30 * 24 * 60 * 60 * 1e3],
+      ["\u5929", 24 * 60 * 60 * 1e3],
+      ["\u5C0F\u65F6", 60 * 60 * 1e3],
+      ["\u5206\u949F", 60 * 1e3],
+      ["\u79D2", 1e3]
+    ];
+    for (const [unit, milliseconds] of units) {
+      const value = Math.floor(abs / milliseconds);
+      if (value >= 1) return `${value} ${unit}${suffix}`;
+    }
+    return "\u521A\u521A";
+  }
+  /**
+   * 获取当天开始时间：00:00:00.000。
+   */
+  static startOfDay(date = /* @__PURE__ */ new Date()) {
+    const target = this.toDate(date);
+    target.setHours(0, 0, 0, 0);
+    return target;
+  }
+  /**
+   * 获取当天结束时间：23:59:59.999。
+   */
+  static endOfDay(date = /* @__PURE__ */ new Date()) {
+    const target = this.toDate(date);
+    target.setHours(23, 59, 59, 999);
+    return target;
+  }
+  /**
+   * 延迟指定毫秒数。
+   */
+  static wait(time) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, time);
+    });
+  }
+  /**
+   * 数字左侧补零。
+   */
+  static pad(value, length = 2) {
+    return String(value).padStart(length, "0");
+  }
+};
+
+// src/utils/ValidateUtils.ts
+var ValidateUtils = class {
+  /**
+   * 判断是否为 null 或 undefined。
+   */
+  static isNil(value) {
+    return value === null || value === void 0;
+  }
+  /**
+   * 判断是否为空。
+   *
+   * 空字符串、空数组、空对象、null、undefined 都视为空。
+   */
+  static isEmpty(value) {
+    if (this.isNil(value)) return true;
+    if (typeof value === "string") return value.trim().length === 0;
+    if (Array.isArray(value)) return value.length === 0;
+    if (value instanceof Map || value instanceof Set) return value.size === 0;
+    if (typeof value === "object") return Object.keys(value).length === 0;
+    return false;
+  }
+  /**
+   * 判断是否非空。
+   */
+  static isNotEmpty(value) {
+    return !this.isEmpty(value);
+  }
+  /**
+   * 判断是否为字符串。
+   */
+  static isString(value) {
+    return typeof value === "string";
+  }
+  /**
+   * 判断是否为数字且非 NaN。
+   */
+  static isNumber(value) {
+    return typeof value === "number" && !Number.isNaN(value);
+  }
+  /**
+   * 判断是否为整数。
+   */
+  static isInteger(value) {
+    return Number.isInteger(value);
+  }
+  /**
+   * 判断是否为布尔值。
+   */
+  static isBoolean(value) {
+    return typeof value === "boolean";
+  }
+  /**
+   * 判断是否为数组。
+   */
+  static isArray(value) {
+    return Array.isArray(value);
+  }
+  /**
+   * 判断是否为普通对象。
+   */
+  static isPlainObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  }
+  /**
+   * 判断字符串长度是否在指定范围内。
+   */
+  static lengthBetween(value, min, max) {
+    const length = [...value].length;
+    return length >= min && length <= max;
+  }
+  /**
+   * 判断数字是否在指定范围内。
+   */
+  static numberBetween(value, min, max) {
+    return this.isNumber(value) && value >= min && value <= max;
+  }
+  /**
+   * 正则校验。
+   */
+  static match(value, pattern) {
+    return pattern.test(value);
+  }
+  /**
+   * 校验邮箱。
+   */
+  static isEmail(value) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+  }
+  /**
+   * 校验中国大陆手机号。
+   */
+  static isMobileCN(value) {
+    return /^1[3-9]\d{9}$/.test(value);
+  }
+  /**
+   * 校验 URL。
+   */
+  static isUrl(value) {
+    try {
+      const url = new URL(value);
+      return ["http:", "https:"].includes(url.protocol);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 校验 IPv4。
+   */
+  static isIPv4(value) {
+    const parts = value.split(".");
+    if (parts.length !== 4) return false;
+    return parts.every((part) => /^\d+$/.test(part) && Number(part) >= 0 && Number(part) <= 255);
+  }
+  /**
+   * 校验 IPv6。
+   */
+  static isIPv6(value) {
+    return /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::1|::)$/.test(value);
+  }
+  /**
+   * 校验是否为合法 JSON 字符串。
+   */
+  static isJSON(value) {
+    try {
+      JSON.parse(value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 校验中国邮政编码。
+   */
+  static isPostalCodeCN(value) {
+    return /^\d{6}$/.test(value);
+  }
+  /**
+   * 校验中国车牌号，覆盖普通车牌与新能源车牌。
+   */
+  static isPlateNumberCN(value) {
+    return /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼][A-Z][A-Z0-9挂学警港澳]{5,6}$/.test(
+      value
+    );
+  }
+  /**
+   * 校验银行卡号。
+   *
+   * 使用 Luhn 算法。
+   */
+  static isBankCard(value) {
+    if (!/^\d{12,19}$/.test(value)) return false;
+    let sum = 0;
+    let shouldDouble = false;
+    for (let i = value.length - 1; i >= 0; i -= 1) {
+      let digit = Number(value[i]);
+      if (shouldDouble) {
+        digit *= 2;
+        if (digit > 9) digit -= 9;
+      }
+      sum += digit;
+      shouldDouble = !shouldDouble;
+    }
+    return sum % 10 === 0;
+  }
+  /**
+   * 校验中国居民身份证号。
+   */
+  static isIdCardCN(value) {
+    return this.validateIdCardCN(value).valid;
+  }
+  /**
+   * 校验中国居民身份证号，并返回生日、性别等信息。
+   */
+  static validateIdCardCN(value) {
+    const id = value.toUpperCase();
+    if (!/^\d{17}[\dX]$/.test(id)) return { valid: false, reason: "format" };
+    const birthday = `${id.slice(6, 10)}-${id.slice(10, 12)}-${id.slice(12, 14)}`;
+    const date = new Date(birthday.replace(/-/g, "/"));
+    if (Number.isNaN(date.getTime()) || date.getFullYear() !== Number(id.slice(6, 10)) || date.getMonth() + 1 !== Number(id.slice(10, 12)) || date.getDate() !== Number(id.slice(12, 14))) {
+      return { valid: false, reason: "birthday" };
+    }
+    const factors = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const codes = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+    const sum = factors.reduce((total, factor, index) => total + Number(id[index]) * factor, 0);
+    if (codes[sum % 11] !== id[17]) return { valid: false, reason: "checksum" };
+    return {
+      valid: true,
+      birthday,
+      gender: Number(id[16]) % 2 === 1 ? "male" : "female"
+    };
+  }
+  /**
+   * 判断密码强度。
+   *
+   * weak：长度不足或类型单一；
+   * medium：长度 >= 8 且至少两类字符；
+   * strong：长度 >= 10 且至少三类字符。
+   */
+  static passwordStrength(value) {
+    let types = 0;
+    if (/[a-z]/.test(value)) types += 1;
+    if (/[A-Z]/.test(value)) types += 1;
+    if (/\d/.test(value)) types += 1;
+    if (/[^a-zA-Z\d]/.test(value)) types += 1;
+    if (value.length >= 10 && types >= 3) return "strong";
+    if (value.length >= 8 && types >= 2) return "medium";
+    return "weak";
+  }
+  /**
+   * 判断是否为强密码。
+   */
+  static isStrongPassword(value) {
+    return this.passwordStrength(value) === "strong";
+  }
+};
+export {
+  useApiConfig as $Api,
+  useApiConfig as $Use,
+  AlgorithmUtils,
+  ApiAdapter,
+  ApiCacheInterceptor,
+  ApiCancelError,
+  ApiConfig,
+  ApiError,
+  ApiGlobalConfig,
+  ApiInterceptor,
+  ApiNetworkError,
+  ApiRequest,
+  ApiResponse,
+  ApiStatusInterceptor,
+  ApiTimeoutError,
+  ApiUIInterceptor,
+  Concurrency,
+  FetchHttpAdapter,
+  Hook,
+  TaskQueue,
+  TimeUtils,
+  ValidateUtils,
+  XhrHttpAdapter,
+  isApiCancelError,
+  useApiConfig
+};