@alibarbar/common 1.0.9 → 1.0.10

package/dist/performance.js

@@ -1,41 +1,146 @@
-'use strict';
+// src/helper/performance.ts
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn.apply(this, args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+function throttle(fn, delay) {
+  let lastCall = 0;
+  let timeoutId = null;
+  return function(...args) {
+    const now = Date.now();
+    const timeSinceLastCall = now - lastCall;
+    if (timeSinceLastCall >= delay) {
+      lastCall = now;
+      fn.apply(this, args);
+    } else {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        fn.apply(this, args);
+        timeoutId = null;
+      }, delay - timeSinceLastCall);
+    }
+  };
+}
+function memoize(fn, keyFn) {
+  const cache = /* @__PURE__ */ new Map();
+  return ((...args) => {
+    const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  });
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+async function retry(fn, retryCount = 3, retryDelay = 1e3) {
+  let lastError = null;
+  for (let i = 0; i <= retryCount; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+async function timeout(fn, timeout2) {
+  return Promise.race([
+    fn(),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Operation timeout after ${timeout2}ms`)), timeout2);
+    })
+  ]);
+}
+async function batch(items, fn, batchSize = 10) {
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch2 = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch2.map(fn));
+    results.push(...batchResults);
+  }
+  return results;
+}
+var Queue = class {
+  constructor() {
+    this.items = [];
+    this.processing = false;
+  }
+  /**
+   * 添加项到队列
+   * @param item - 要添加的项
+   */
+  enqueue(item) {
+    this.items.push(item);
+    if (!this.processing && this.processor) {
+      this.processItems();
+    }
+  }
+  /**
+   * 设置处理函数并开始处理
+   * @param processor - 处理函数
+   */
+  async start(processor) {
+    this.processor = processor;
+    if (!this.processing) {
+      await this.processItems();
+    }
+  }
+  /**
+   * 处理队列
+   */
+  async processItems() {
+    if (!this.processor || this.processing) return;
+    this.processing = true;
+    while (this.items.length > 0) {
+      const item = this.items.shift();
+      if (item && this.processor) {
+        try {
+          await this.processor(item);
+        } catch (error) {
+          console.error("Queue processing error:", error);
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 获取队列长度
+   */
+  get length() {
+    return this.items.length;
+  }
+};
 
-var chunkJQZBPAPO_js = require('./chunk-JQZBPAPO.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "Queue", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.Queue; }
-});
-Object.defineProperty(exports, "batch", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.batch; }
-});
-Object.defineProperty(exports, "debounce", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.debounce; }
-});
-Object.defineProperty(exports, "memoize", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.memoize; }
-});
-Object.defineProperty(exports, "once", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.once; }
-});
-Object.defineProperty(exports, "retry", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.retry; }
-});
-Object.defineProperty(exports, "throttle", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.throttle; }
-});
-Object.defineProperty(exports, "timeout", {
-  enumerable: true,
-  get: function () { return chunkJQZBPAPO_js.timeout; }
-});
-//# sourceMappingURL=performance.js.map
-//# sourceMappingURL=performance.js.map
+export { Queue, batch, debounce, memoize, once, retry, throttle, timeout };

package/dist/services.cjs

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Qs = require('qs');
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Qs__default = /*#__PURE__*/_interopDefault(Qs);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/services/index.ts
+var serviceEventHandlers = {
+  message: null
+};
+function setServiceEventHandlers(handlers = {}) {
+  Object.assign(serviceEventHandlers, handlers);
+}
+function emitMessageEvent(payload) {
+  const handler = serviceEventHandlers.message;
+  if (typeof handler === "function") {
+    handler(payload);
+    return;
+  }
+  const { type = "error", message, code, status } = payload;
+  const prefix = `[service][${type}]`;
+  const extra = [];
+  if (typeof code !== "undefined") extra.push(`code=${code}`);
+  if (typeof status !== "undefined") extra.push(`status=${status}`);
+  const suffix = extra.length ? ` (${extra.join(", ")})` : "";
+  if (type === "info" || type === "success") {
+    console.info(`${prefix} ${message}${suffix}`);
+  } else if (type === "warn" || type === "warning") {
+    console.warn(`${prefix} ${message}${suffix}`);
+  } else {
+    console.error(`${prefix} ${message}${suffix}`);
+  }
+}
+function filterEmptyKey(params, emptyString) {
+  Object.keys(params).forEach((key) => {
+    if (params[key] === null || emptyString && params[key] === "" || emptyString && Array.isArray(params[key]) && params[key].length <= 0) {
+      delete params[key];
+    }
+  });
+}
+function getTransformRequest(contentType) {
+  if (!contentType) {
+    return (data) => Qs__default.default.stringify(data);
+  }
+  const normalizedType = contentType.toLowerCase().trim();
+  if (normalizedType.startsWith("application/json")) {
+    return (data) => JSON.stringify(data);
+  }
+  if (normalizedType.startsWith("application/x-www-form-urlencoded")) {
+    return (data) => Qs__default.default.stringify(data);
+  }
+  return void 0;
+}
+var service = axios__default.default.create({
+  baseURL: "",
+  timeout: 6e4,
+  // 不设置默认 transformRequest，根据 Content-Type 自动选择
+  headers: {
+    "Cache-Control": "no-cache",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "X-Requested-With": "XMLHttpRequest"
+  }
+});
+service.interceptors.request.use(
+  async (config) => {
+    const contentType = config.headers?.["Content-Type"] || config.headers?.["content-type"];
+    if (!config.transformRequest && contentType) {
+      const transformRequest = getTransformRequest(
+        typeof contentType === "string" ? contentType : void 0
+      );
+      if (transformRequest) {
+        config.transformRequest = transformRequest;
+      }
+    } else if (!config.transformRequest) {
+      config.transformRequest = (data) => Qs__default.default.stringify(data);
+    }
+    if (config.method === "post" || config.method === "put" || config.method === "patch") {
+      const params = { ...config.data || {} };
+      filterEmptyKey(params, config.emptyParams ?? false);
+      config.data = params;
+    } else if (config.method === "get" || config.method === "delete") {
+      if (!config.disableTimestamp) {
+        config.params = {
+          _t: Math.floor(Date.now() / 1e3),
+          ...config.params || {}
+        };
+      }
+      filterEmptyKey(config.params, true);
+    }
+    return config;
+  },
+  (error) => Promise.reject(error)
+);
+function extractErrorMessage(responseData) {
+  return responseData?.errorMessage || responseData?.message || responseData?.msg || "Unknown server error";
+}
+function handle401Error(config, error) {
+  emitMessageEvent({
+    type: "info",
+    message: "Authentication required",
+    status: 401,
+    config,
+    error
+  });
+}
+function isServiceResponseData(data) {
+  return typeof data === "object" && data !== null && !(data instanceof Blob) && ("success" in data || "code" in data || "data" in data || "message" in data || "msg" in data);
+}
+function hasDataField(responseData) {
+  return "data" in responseData && responseData.data !== void 0;
+}
+function extractResponseData(response) {
+  const { data } = response;
+  if (data instanceof Blob) {
+    return data;
+  }
+  if (!isServiceResponseData(data)) {
+    return data;
+  }
+  if (hasDataField(data)) {
+    return data.data;
+  }
+  return data;
+}
+service.interceptors.response.use(
+  (res) => {
+    const { data, config } = res;
+    const extendedConfig = config;
+    if (extendedConfig.file && res.status === 200 && data instanceof Blob) {
+      convertRes2Blob(res);
+      return void 0;
+    }
+    if (!isServiceResponseData(data)) {
+      return data;
+    }
+    const responseData = data;
+    if ((!responseData.success || responseData.success === "false") && responseData.code !== 200 && responseData.code !== 0) {
+      const msg = extractErrorMessage(responseData);
+      const code = responseData.errorCode || responseData.code || -1e3;
+      if (!extendedConfig.hidden) {
+        emitMessageEvent({
+          type: code === 401 ? "info" : "error",
+          message: `${extendedConfig.action || "Request"} failed: ${msg}`,
+          code,
+          status: res.status,
+          config: extendedConfig
+        });
+      }
+      return Promise.reject({ code, message: msg });
+    }
+    const extractedData = extractResponseData(res);
+    return extractedData;
+  },
+  (error) => {
+    try {
+      const axiosError = error;
+      const config = axiosError.config || {};
+      const status = axiosError.response?.status;
+      const messageText = String(axiosError?.message || "");
+      const isAborted = axiosError.code === "ECONNABORTED";
+      if (status === 401) {
+        handle401Error(config, error);
+      }
+      if (isAborted && config && !config._noAutoRetry) {
+        config._retryCount = config._retryCount || 0;
+        if (config._retryCount < 2) {
+          config._retryCount++;
+          console.debug(
+            `[request] aborted, retry attempt #${config._retryCount} -> ${config.url || ""}`
+          );
+          return new Promise((resolve) => setTimeout(resolve, 300)).then(
+            () => service.request(config)
+          );
+        }
+      }
+      if (!config?.hidden && !isAborted) {
+        let friendly = messageText;
+        if (status === 403) friendly = "No permission";
+        else if (status === 502) friendly = "System is upgrading or unavailable";
+        else if (status === 504) friendly = "System timeout";
+        emitMessageEvent({
+          type: status === 401 ? "info" : "error",
+          message: `${config.action || "Request"} failed: ${friendly}`,
+          status,
+          config,
+          error
+        });
+      }
+    } catch (e) {
+      console.error("error in response error handler", e);
+    }
+    return Promise.reject(error);
+  }
+);
+service.json = function(url, params, config) {
+  const newConfig = {
+    headers: { "Content-Type": "application/json", ...config?.headers },
+    ...config
+  };
+  return service.post(
+    url,
+    Array.isArray(params) ? params : params,
+    newConfig
+  );
+};
+service.put = function(url, params, config) {
+  const newConfig = {
+    headers: { "Content-Type": "application/json", ...config?.headers },
+    ...config
+  };
+  return service.put(url, Array.isArray(params) ? params : params, newConfig).then((res) => res);
+};
+service.arrayGet = function(url, config) {
+  if (config) {
+    config.paramsSerializer = (params) => Qs__default.default.stringify(params, { arrayFormat: "repeat" });
+  }
+  return service.get(url, config);
+};
+service.download = function(url, config = {}) {
+  const { type = "get", params } = config;
+  const newConfig = {
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json; charset=utf-8",
+      ...config.headers
+    },
+    withCredentials: true,
+    file: true,
+    responseType: "blob",
+    ...config
+  };
+  if (type === "get") {
+    newConfig.params = params;
+    return service.get(url, newConfig);
+  } else {
+    newConfig.params = {};
+    return service.post(url, params, newConfig).then(() => void 0);
+  }
+};
+function convertRes2Blob(response) {
+  const contentDisposition = response.headers["content-disposition"];
+  let fileName = "file.xlsx";
+  if (contentDisposition) {
+    const rfc5987Match = contentDisposition.match(/filename\*=UTF-8''([^;]+)/i);
+    if (rfc5987Match) {
+      fileName = decodeURIComponent(rfc5987Match[1]);
+    } else {
+      const standardMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/i);
+      if (standardMatch) {
+        fileName = standardMatch[1];
+        fileName = fileName.replace(/^['"]|['"]$/g, "");
+        try {
+          fileName = decodeURIComponent(fileName);
+        } catch (e) {
+          try {
+            fileName = decodeURI(fileName);
+          } catch (e2) {
+          }
+        }
+      }
+    }
+    fileName = fileName.trim().replace(/^_+|_+$/g, "");
+  }
+  const blob = new Blob([response.data], { type: "application/vnd.ms-excel;charset=utf-8" });
+  if (typeof window.navigator.msSaveBlob !== "undefined") {
+    window.navigator.msSaveBlob(blob, fileName);
+  } else {
+    const blobURL = window.URL.createObjectURL(blob);
+    const tempLink = document.createElement("a");
+    tempLink.style.display = "none";
+    tempLink.href = blobURL;
+    tempLink.setAttribute("download", fileName);
+    if (typeof tempLink.download === "undefined") {
+      tempLink.setAttribute("target", "_blank");
+    }
+    document.body.appendChild(tempLink);
+    tempLink.click();
+    document.body.removeChild(tempLink);
+    window.URL.revokeObjectURL(blobURL);
+  }
+}
+var services_default = service;
+
+exports.default = services_default;
+exports.setServiceEventHandlers = setServiceEventHandlers;

package/dist/services.d.mts

@@ -0,0 +1,161 @@
+import { AxiosRequestConfig, AxiosInstance } from 'axios';
+
+/**
+ * 扩展 Navigator 接口以支持 msSaveBlob
+ */
+declare global {
+    interface Navigator {
+        msSaveBlob?: (blob: Blob, fileName: string) => boolean;
+    }
+}
+/**
+ * 消息事件类型
+ */
+type MessageEventType = 'info' | 'success' | 'warn' | 'warning' | 'error';
+/**
+ * 消息事件载荷
+ */
+interface MessageEventPayload {
+    /** 消息类型 */
+    type: MessageEventType;
+    /** 消息内容 */
+    message: string;
+    /** 错误代码（可选） */
+    code?: number;
+    /** HTTP 状态码（可选） */
+    status?: number;
+    /** 请求配置（可选） */
+    config?: AxiosRequestConfig;
+    /** 错误对象（可选） */
+    error?: unknown;
+}
+/**
+ * 消息事件处理器
+ */
+type MessageEventHandler = (payload: MessageEventPayload) => void;
+/**
+ * 服务事件处理器配置
+ */
+interface ServiceEventHandlers {
+    /** 统一消息/错误事件处理器 */
+    message?: MessageEventHandler | null;
+}
+/**
+ * 扩展的 Axios 请求配置
+ * 只声明扩展的属性，继承的属性不需要重复声明
+ */
+interface ExtendedAxiosRequestConfig extends AxiosRequestConfig {
+    /** 是否隐藏错误提示 */
+    hidden?: boolean;
+    /** 操作名称（用于错误提示） */
+    action?: string;
+    /** 是否清空空参数 */
+    emptyParams?: boolean;
+    /** 是否为文件下载 */
+    file?: boolean;
+    /** 重试计数（内部使用） */
+    _retryCount?: number;
+    /** 是否禁用自动重试 */
+    _noAutoRetry?: boolean;
+    /** 是否禁用自动添加时间戳（仅对 GET 请求有效） */
+    disableTimestamp?: boolean;
+}
+/**
+ * 服务响应数据类型
+ */
+interface ServiceResponseData<T = unknown> {
+    success?: boolean | string;
+    code?: number;
+    errorCode?: number;
+    errorMessage?: string;
+    message?: string;
+    msg?: string;
+    data?: T;
+}
+/**
+ * 错误响应类型
+ */
+interface ServiceError {
+    code: number;
+    message: string;
+}
+/**
+ * 设置 service 的事件处理函数
+ * @param handlers - 事件处理器配置
+ */
+declare function setServiceEventHandlers(handlers?: Partial<ServiceEventHandlers>): void;
+declare const service: AxiosInstance & ServiceInstance;
+/**
+ * Service 实例扩展接口
+ */
+interface ServiceInstance extends AxiosInstance {
+    /**
+     * GET 请求
+     * @param url - 请求 URL
+     * @param config - 请求配置
+     */
+    get<TResponse = unknown>(url: string, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * POST 请求
+     * @param url - 请求 URL
+     * @param data - 请求数据
+     * @param config - 请求配置
+     */
+    post<TResponse = unknown, TData = unknown>(url: string, data?: TData, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * DELETE 请求
+     * @param url - 请求 URL
+     * @param config - 请求配置
+     */
+    delete<TResponse = unknown>(url: string, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * PATCH 请求
+     * @param url - 请求 URL
+     * @param data - 请求数据
+     * @param config - 请求配置
+     */
+    patch<TResponse = unknown, TData = unknown>(url: string, data?: TData, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * HEAD 请求
+     * @param url - 请求 URL
+     * @param config - 请求配置
+     */
+    head<TResponse = unknown>(url: string, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * OPTIONS 请求
+     * @param url - 请求 URL
+     * @param config - 请求配置
+     */
+    options<TResponse = unknown>(url: string, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * JSON 格式 POST 请求
+     * @param url - 请求 URL
+     * @param params - 请求参数
+     * @param config - 请求配置
+     */
+    json<TResponse = unknown, TParams = unknown>(url: string, params?: TParams | TParams[], config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * PUT 请求（JSON 格式）
+     * @param url - 请求 URL
+     * @param params - 请求参数
+     * @param config - 请求配置
+     */
+    put<TResponse = unknown, TParams = unknown>(url: string, params?: TParams | TParams[], config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * 数组格式 GET 请求
+     * @param url - 请求 URL
+     * @param config - 请求配置
+     */
+    arrayGet<TResponse = unknown>(url: string, config?: ExtendedAxiosRequestConfig): Promise<TResponse>;
+    /**
+     * 文件下载
+     * @param url - 下载 URL
+     * @param config - 下载配置
+     */
+    download<TParams = unknown>(url: string, config?: {
+        type?: 'get' | 'json';
+        params?: TParams;
+    } & ExtendedAxiosRequestConfig): Promise<void>;
+}
+
+export { type ExtendedAxiosRequestConfig, type MessageEventHandler, type MessageEventPayload, type MessageEventType, type ServiceError, type ServiceEventHandlers, type ServiceInstance, type ServiceResponseData, service as default, setServiceEventHandlers };