enhance-axios 1.0.2

package/dist/umd/index.global.js

@@ -0,0 +1,670 @@
+"use strict";
+var EnhanceAxios = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    createEnhanceInstance: () => createEnhanceInstance,
+    defaultRetryCondition: () => defaultRetryCondition,
+    getFormData: () => getFormData,
+    hash: () => hash,
+    version: () => version
+  });
+
+  // src/axios-shim.ts
+  var axios_shim_default = window.axios;
+
+  // src/core/requestManager.ts
+  var RequestManager = class {
+    constructor() {
+      this.preventPending = /* @__PURE__ */ new Map();
+      this.cancelPending = /* @__PURE__ */ new Map();
+    }
+    /**
+     * 注册一个新请求
+     */
+    registerRequest(key, type, controller, promise, config) {
+      const pending = {
+        key,
+        config: config || {},
+        controller,
+        promise,
+        timestamp: Date.now()
+      };
+      (type === "prevent" ? this.preventPending : this.cancelPending).set(key, pending);
+    }
+    /**
+     * 移除请求记录
+     */
+    unregisterRequest(key, type) {
+      (type === "prevent" ? this.preventPending : this.cancelPending).delete(key);
+    }
+    /**
+     * 取消并移除请求，同时检查两个 Map
+     */
+    cancelRequest(key) {
+      let cancelled = false;
+      const abort = (map) => {
+        const req = map.get(key);
+        if (req) {
+          try {
+            req.controller.abort("Cancelled by cancelRequest");
+          } catch {
+          }
+          map.delete(key);
+          cancelled = true;
+        }
+      };
+      abort(this.preventPending);
+      abort(this.cancelPending);
+      return cancelled;
+    }
+    /**
+     * 获取请求状态（优先返回 preventPending）
+     */
+    getRequestStatus(key) {
+      return this.preventPending.get(key) ?? this.cancelPending.get(key);
+    }
+    getPreventPending(key) {
+      return this.preventPending.get(key);
+    }
+    getCancelPending(key) {
+      return this.cancelPending.get(key);
+    }
+    /**
+     * 清空所有 pending 请求
+     */
+    clearAll() {
+      const abortAll = (map, reason) => {
+        for (const req of map.values()) {
+          try {
+            req.controller.abort(reason);
+          } catch {
+          }
+        }
+        map.clear();
+      };
+      abortAll(this.preventPending, "Cleared by clearAll");
+      abortAll(this.cancelPending, "Cleared by clearAll");
+    }
+    /**
+     * 获取 pending 数量（注意两 Map 独立，合计可能重复计数）
+     */
+    getPendingCount() {
+      return {
+        prevent: this.preventPending.size,
+        cancel: this.cancelPending.size,
+        total: this.preventPending.size + this.cancelPending.size
+      };
+    }
+    /**
+     * 获取所有 pending 的 key
+     */
+    getPendingKeys() {
+      return {
+        prevent: Array.from(this.preventPending.keys()),
+        cancel: Array.from(this.cancelPending.keys())
+      };
+    }
+  };
+
+  // src/utils/common.ts
+  function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) return false;
+    if (Array.isArray(value)) return false;
+    if (value instanceof Blob) return false;
+    if (value instanceof Date) return false;
+    if (typeof FormData !== "undefined" && value instanceof FormData) return false;
+    if (typeof Map !== "undefined" && value instanceof Map) return false;
+    if (typeof Set !== "undefined" && value instanceof Set) return false;
+    return true;
+  }
+
+  // src/utils/keyGenerator.ts
+  function toPlain(value) {
+    if (value == null) return value;
+    if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) {
+      return Object.fromEntries(value);
+    }
+    return value;
+  }
+  function getNestedValue(obj, path) {
+    if (!path) return obj;
+    const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+    return normalized.split(".").reduce(
+      (o, k) => o == null ? void 0 : o[k],
+      obj
+    );
+  }
+  function resolveTemplate(template, config) {
+    const context = {
+      method: config.method?.toUpperCase() || "GET",
+      url: config.url || "",
+      params: toPlain(config.params),
+      data: toPlain(config.data)
+    };
+    return template.replace(/\$\{([^}]+)\}/g, (_match, path) => {
+      const value = getNestedValue(context, path);
+      if (value == null) return "";
+      if (typeof value === "object") return JSON.stringify(value);
+      return String(value);
+    });
+  }
+  function generateDefaultKey(config) {
+    const parts = [
+      config.method?.toUpperCase() || "GET",
+      config.url || "",
+      config.params != null ? JSON.stringify(sortObject(stripCacheParam(toPlain(config.params)))) : "",
+      config.data != null ? JSON.stringify(sortObject(stripCacheParam(toPlain(config.data)))) : ""
+    ];
+    return hash(parts.join("|"));
+  }
+  function hash(str) {
+    let h = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      h ^= str.charCodeAt(i);
+      h = h * 16777619 >>> 0;
+    }
+    return h.toString(16).padStart(8, "0");
+  }
+  function resolveRequestKey(config, keyTemplate) {
+    if (!keyTemplate) return generateDefaultKey(config);
+    if (typeof keyTemplate === "function") {
+      return keyTemplate(config, hash);
+    }
+    if (typeof keyTemplate === "string" && keyTemplate.includes("${")) {
+      return hash(resolveTemplate(keyTemplate, config));
+    }
+    return keyTemplate;
+  }
+  function stripCacheParam(obj) {
+    if (obj == null || typeof obj !== "object") return obj;
+    if (Array.isArray(obj)) return obj;
+    if (!isPlainObject(obj)) return obj;
+    const { _, ...rest } = obj;
+    return rest;
+  }
+  function sortObject(obj) {
+    if (obj == null || typeof obj !== "object") return obj;
+    if (Array.isArray(obj)) return obj.map(sortObject);
+    if (!isPlainObject(obj)) return obj;
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sorted[key] = sortObject(obj[key]);
+    }
+    return sorted;
+  }
+
+  // src/utils/formData.ts
+  function appendValue(fd, key, value) {
+    if (value == null) return;
+    if (value instanceof File) {
+      fd.append(key, value);
+    } else if (value instanceof Blob) {
+      fd.append(key, value);
+    } else if (value instanceof Date) {
+      fd.append(key, value.toISOString());
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        appendValue(fd, key, item);
+      }
+    } else if (isPlainObject(value)) {
+      for (const [subKey, subValue] of Object.entries(value)) {
+        appendValue(fd, `${key}.${subKey}`, subValue);
+      }
+    } else {
+      fd.append(key, String(value));
+    }
+  }
+  function getFormData(data, fieldName) {
+    const fd = new FormData();
+    if (data == null) return fd;
+    if (typeof FileList !== "undefined" && data instanceof FileList) {
+      const key = fieldName || "file";
+      for (let i = 0; i < data.length; i++) fd.append(key, data[i]);
+      return fd;
+    }
+    if (isPlainObject(data)) {
+      for (const [key, value] of Object.entries(data)) {
+        appendValue(fd, key, value);
+      }
+      return fd;
+    }
+    appendValue(fd, fieldName || "file", data);
+    return fd;
+  }
+
+  // src/types/index.ts
+  var CONTENT_TYPE_MAP = {
+    json: "application/json;charset=UTF-8",
+    form: "application/x-www-form-urlencoded"
+  };
+
+  // src/core/index.ts
+  var DEFAULT_PREVENT_CONFIG = {
+    enabled: true,
+    methods: ["POST", "PUT", "PATCH", "DELETE"],
+    intervalMs: 1e3
+  };
+  var DEFAULT_CANCEL_CONFIG = {
+    enabled: true,
+    methods: ["GET"]
+  };
+  function defaultRetryCondition(error) {
+    if (!error.response) {
+      return true;
+    }
+    const status = error.response.status;
+    if (status === 408 || status === 429) {
+      return true;
+    }
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    return false;
+  }
+  var DEFAULT_RETRY_CONFIG = {
+    enabled: true,
+    retries: 3,
+    retryDelay: 1e3,
+    retryCondition: defaultRetryCondition,
+    exponential: true,
+    maxDelay: 3e4
+  };
+  function shouldApply(method, methods) {
+    if (methods == null) return true;
+    if (methods.length === 0) return false;
+    return methods.includes(method?.toUpperCase() || "GET");
+  }
+  function calculateRetryDelay(retryConfig, retryCount) {
+    let delay = retryConfig.retryDelay;
+    if (retryConfig.exponential) {
+      delay = Math.min(
+        retryConfig.retryDelay * Math.pow(2, retryCount),
+        retryConfig.maxDelay
+      );
+    }
+    return delay;
+  }
+  function getDataFormat(config) {
+    const headers = config.headers || {};
+    const ctKey = Object.keys(headers).find((k) => k.toLowerCase() === "content-type");
+    if (ctKey) {
+      const ct = String(headers[ctKey]).toLowerCase();
+      if (ct.includes("multipart/form-data")) return "file";
+      if (ct.includes("application/x-www-form-urlencoded")) return "form";
+      if (ct.includes("application/json") || ct.includes("+json")) return "json";
+    }
+    return config.contentType;
+  }
+  function injectDataTransform(config, format, instance) {
+    if (config.__dataTransformInjected) return;
+    config.__dataTransformInjected = true;
+    const ourTransform = (data) => {
+      if (data == null || data instanceof FormData || data instanceof URLSearchParams) return data;
+      if (typeof data !== "object") return data;
+      if (format === "file") return getFormData(data);
+      return new URLSearchParams(data);
+    };
+    const existing = config.transformRequest;
+    const defaults = instance.defaults.transformRequest;
+    const source = existing != null ? existing : defaults;
+    let chain = [];
+    if (source != null) {
+      chain = Array.isArray(source) ? [...source] : [source];
+    }
+    config.transformRequest = [ourTransform, ...chain];
+  }
+  function isConfigSet(config) {
+    return config != null;
+  }
+  function normalizePreventConfig(config, defaults) {
+    if (!isConfigSet(config)) {
+      return defaults;
+    }
+    if (typeof config === "boolean") {
+      return { ...defaults, enabled: config };
+    }
+    if (typeof config === "string") {
+      return { ...defaults, enabled: true, requestKey: config };
+    }
+    if (typeof config === "function") {
+      return { ...defaults, enabled: true, requestKey: config };
+    }
+    if (typeof config === "number") {
+      return { ...defaults, enabled: true, intervalMs: config };
+    }
+    if (Array.isArray(config)) {
+      return { ...defaults, enabled: true, methods: [...config] };
+    }
+    return {
+      enabled: config.enabled ?? true,
+      requestKey: config.requestKey ?? defaults.requestKey,
+      methods: config.methods != null ? config.methods : defaults.methods,
+      intervalMs: config.intervalMs ?? defaults.intervalMs
+    };
+  }
+  function normalizeCancelConfig(config, defaults) {
+    if (!isConfigSet(config)) {
+      return defaults;
+    }
+    if (typeof config === "boolean") {
+      return { ...defaults, enabled: config };
+    }
+    if (typeof config === "string") {
+      return { ...defaults, enabled: true, requestKey: config };
+    }
+    if (typeof config === "function") {
+      return { ...defaults, enabled: true, requestKey: config };
+    }
+    if (Array.isArray(config)) {
+      return { ...defaults, enabled: true, methods: [...config] };
+    }
+    return {
+      enabled: config.enabled ?? true,
+      requestKey: config.requestKey ?? defaults.requestKey,
+      methods: config.methods != null ? config.methods : defaults.methods
+    };
+  }
+  function normalizeRetryConfig(config, defaults) {
+    if (!isConfigSet(config)) {
+      return defaults;
+    }
+    if (typeof config === "boolean") {
+      return { ...defaults, enabled: config };
+    }
+    if (typeof config === "number") {
+      return { ...defaults, enabled: true, retries: config };
+    }
+    if (typeof config === "function") {
+      return { ...defaults, enabled: true, retryCondition: config };
+    }
+    if (Array.isArray(config)) {
+      const codes = config;
+      return {
+        ...defaults,
+        enabled: true,
+        retryCondition: (error) => {
+          if (!error.response) return true;
+          return codes.includes(error.response.status);
+        }
+      };
+    }
+    return {
+      enabled: config.enabled ?? true,
+      retries: config.retries ?? defaults.retries,
+      retryDelay: config.retryDelay ?? defaults.retryDelay,
+      retryCondition: config.retryCondition ?? defaults.retryCondition,
+      exponential: config.exponential ?? defaults.exponential,
+      maxDelay: config.maxDelay ?? defaults.maxDelay,
+      methods: config.methods != null ? config.methods : defaults.methods
+    };
+  }
+  function getEffectiveConfig(config, instanceDefaults) {
+    const prevent = isConfigSet(config.preventDuplicate) ? normalizePreventConfig(config.preventDuplicate, instanceDefaults.prevent) : { ...instanceDefaults.prevent };
+    const cancel = isConfigSet(config.cancelRequest) ? normalizeCancelConfig(config.cancelRequest, instanceDefaults.cancel) : { ...instanceDefaults.cancel };
+    return { prevent, cancel };
+  }
+  function getPendingKey(config) {
+    return config.__pendingKey;
+  }
+  function getCancelKey(config) {
+    return config.__cancelKey;
+  }
+  function cleanupRegistered(config, rm) {
+    const pk = getPendingKey(config);
+    const ck = getCancelKey(config);
+    if (pk) rm.unregisterRequest(pk, "prevent");
+    if (ck && ck !== pk) rm.unregisterRequest(ck, "cancel");
+  }
+  function rejectAndCleanup(config, rm, pr, reason) {
+    const pk = getPendingKey(config);
+    const ck = getCancelKey(config);
+    if (pk) {
+      const df = pr.get(pk);
+      if (df) {
+        df.reject(reason);
+        pr.delete(pk);
+      }
+      rm.unregisterRequest(pk, "prevent");
+    }
+    if (ck && ck !== pk) rm.unregisterRequest(ck, "cancel");
+  }
+  function resolveAndCleanup(config, rm, pr, data) {
+    const pk = getPendingKey(config);
+    const ck = getCancelKey(config);
+    if (pk) {
+      const df = pr.get(pk);
+      if (df) {
+        df.resolve(data);
+        pr.delete(pk);
+      }
+      rm.unregisterRequest(pk, "prevent");
+    }
+    if (ck && ck !== pk) rm.unregisterRequest(ck, "cancel");
+  }
+  function createEnhanceInstance(options = {}) {
+    const instance = axios_shim_default.create(options);
+    const defaultPrevent = { ...DEFAULT_PREVENT_CONFIG };
+    const defaultCancel = { ...DEFAULT_CANCEL_CONFIG };
+    const defaultRetry = { ...DEFAULT_RETRY_CONFIG };
+    if (isConfigSet(options.preventDuplicate)) {
+      const normalized = normalizePreventConfig(options.preventDuplicate, DEFAULT_PREVENT_CONFIG);
+      Object.assign(defaultPrevent, normalized);
+    }
+    if (isConfigSet(options.cancelRequest)) {
+      const normalized = normalizeCancelConfig(options.cancelRequest, DEFAULT_CANCEL_CONFIG);
+      Object.assign(defaultCancel, normalized);
+    }
+    if (isConfigSet(options.retry)) {
+      const normalized = normalizeRetryConfig(options.retry, DEFAULT_RETRY_CONFIG);
+      Object.assign(defaultRetry, normalized);
+    }
+    const needCacheBust = options.needCacheBust ?? true;
+    const requestManager = new RequestManager();
+    const pendingReturns = /* @__PURE__ */ new Map();
+    const enhanceInstance = {
+      requestManager,
+      clearAll: () => {
+        for (const [_key, deferred] of pendingReturns) {
+          try {
+            deferred.reject(new Error("All requests cleared"));
+          } catch {
+          }
+        }
+        pendingReturns.clear();
+        requestManager.clearAll();
+      },
+      cancelRequest: (key) => requestManager.cancelRequest(key),
+      getRequestStatus: (key) => requestManager.getRequestStatus(key)
+    };
+    instance.interceptors.request.use(
+      (config) => {
+        const method = config.method?.toUpperCase() || "GET";
+        const { prevent, cancel } = getEffectiveConfig(config, { prevent: defaultPrevent, cancel: defaultCancel });
+        const headers = config.headers || {};
+        const hasContentType = typeof headers === "object" && Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
+        if (!hasContentType) {
+          const contentType = config.contentType;
+          if (contentType !== "file") {
+            config.headers = config.headers || {};
+            const value = contentType != null ? CONTENT_TYPE_MAP[contentType] || contentType : CONTENT_TYPE_MAP.json;
+            config.headers["Content-Type"] = value;
+          }
+        }
+        if (cancel.enabled && shouldApply(method, cancel.methods)) {
+          const key = resolveRequestKey(config, cancel.requestKey);
+          const existing = requestManager.getRequestStatus(key);
+          if (existing?.config) {
+            existing.config.__cancelKey = void 0;
+            existing.config.__pendingKey = void 0;
+          }
+          requestManager.cancelRequest(key);
+        }
+        if (prevent.enabled && shouldApply(method, prevent.methods)) {
+          const key = resolveRequestKey(config, prevent.requestKey);
+          const existing = requestManager.getRequestStatus(key);
+          if (existing) {
+            const now = Date.now();
+            if (now - existing.timestamp < prevent.intervalMs) {
+              const deferred = pendingReturns.get(key);
+              if (deferred) {
+                const controller = new AbortController();
+                config.signal = controller.signal;
+                controller.abort("Request prevented by duplicate");
+                config.__pendingKey = key;
+                const error = new Error("Request prevented by duplicate");
+                error.__preventReturn = true;
+                error.__pendingPromise = deferred.promise;
+                error.__pendingKey = key;
+                error.config = config;
+                return Promise.reject(error);
+              }
+            }
+          }
+        }
+        const needsPrevent = prevent.enabled && shouldApply(method, prevent.methods);
+        const needsCancel = cancel.enabled && shouldApply(method, cancel.methods);
+        if (needsPrevent || needsCancel) {
+          const controller = new AbortController();
+          config.signal = controller.signal;
+          config.__controller = controller;
+          if (needsCancel) {
+            const cancelKey = resolveRequestKey(config, cancel.requestKey);
+            config.__cancelKey = cancelKey;
+            requestManager.registerRequest(cancelKey, "cancel", controller, Promise.resolve(), config);
+          }
+          if (needsPrevent) {
+            const preventKey = resolveRequestKey(config, prevent.requestKey);
+            config.__pendingKey = preventKey;
+            let deferred = pendingReturns.get(preventKey);
+            if (!deferred) {
+              let resolveFn;
+              let rejectFn;
+              const promise = new Promise((resolve, reject) => {
+                resolveFn = resolve;
+                rejectFn = reject;
+              });
+              deferred = { resolve: resolveFn, reject: rejectFn, promise };
+              pendingReturns.set(preventKey, deferred);
+            }
+            requestManager.registerRequest(preventKey, "prevent", controller, deferred.promise, config);
+          }
+        }
+        const format = getDataFormat(config);
+        if (format === "file" || format === "form") {
+          injectDataTransform(config, format, instance);
+        }
+        if ((config.needCacheBust ?? needCacheBust) !== false) {
+          const stamp = Date.now().toString(36);
+          if (config.params instanceof URLSearchParams) {
+            config.params.append("_", stamp);
+          } else if (typeof config.params === "object" && config.params !== null) {
+            config.params = { ...config.params, _: stamp };
+          } else {
+            config.params = { _: stamp };
+          }
+        }
+        return config;
+      },
+      (error) => {
+        if (error?.config) rejectAndCleanup(error.config, requestManager, pendingReturns, error);
+        return Promise.reject(error);
+      }
+    );
+    instance.interceptors.response.use(
+      // ─────────────────────────────────────────────────────────────────────────
+      // 成功响应处理 (2xx)
+      // ─────────────────────────────────────────────────────────────────────────
+      async (response) => {
+        const config = response.config;
+        const retryConfig = normalizeRetryConfig(config.retry, defaultRetry);
+        if (retryConfig.enabled && shouldApply(config.method, retryConfig.methods)) {
+          const syntheticError = new Error("Business logic error");
+          syntheticError.config = config;
+          syntheticError.response = response;
+          syntheticError.isAxiosError = true;
+          if (retryConfig.retryCondition(syntheticError)) {
+            const retryCount = config.__retryCount || 0;
+            if (retryCount < retryConfig.retries) {
+              await new Promise((resolve) => setTimeout(resolve, calculateRetryDelay(retryConfig, retryCount)));
+              cleanupRegistered(config, requestManager);
+              config.__retryCount = retryCount + 1;
+              return instance.request(config);
+            }
+          }
+        }
+        resolveAndCleanup(config, requestManager, pendingReturns, response);
+        return response;
+      },
+      // ─────────────────────────────────────────────────────────────────────────
+      // 错误响应处理 (非 2xx / 网络错误 / 取消 / 防重复拦截)
+      // ─────────────────────────────────────────────────────────────────────────
+      async (error) => {
+        const config = error.config || error.config;
+        if (!config) return Promise.reject(error);
+        if (error?.__preventReturn && error?.__pendingPromise) {
+          return error.__pendingPromise;
+        }
+        if (axios_shim_default.isCancel(error)) {
+          rejectAndCleanup(config, requestManager, pendingReturns, error);
+          return Promise.reject(error);
+        }
+        const retryConfig = normalizeRetryConfig(config.retry, defaultRetry);
+        if (retryConfig.enabled && shouldApply(config.method, retryConfig.methods)) {
+          const retryCount = config.__retryCount || 0;
+          const shouldRetry = retryCount < retryConfig.retries && retryConfig.retryCondition(error);
+          if (shouldRetry) {
+            await new Promise((resolve) => setTimeout(resolve, calculateRetryDelay(retryConfig, retryCount)));
+            cleanupRegistered(config, requestManager);
+            config.__retryCount = retryCount + 1;
+            return instance.request(config);
+          }
+        }
+        rejectAndCleanup(config, requestManager, pendingReturns, error);
+        return Promise.reject(error);
+      }
+    );
+    const methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+    for (const method of methods) {
+      instance[method.toLowerCase()] = (url, data, config) => {
+        const finalConfig = {
+          ...config,
+          url,
+          method
+        };
+        if (["GET", "HEAD", "OPTIONS"].includes(method)) {
+          if (data) finalConfig.params = data;
+        } else {
+          if (data !== void 0) finalConfig.data = data;
+        }
+        return instance.request(finalConfig);
+      };
+    }
+    instance.enhance = enhanceInstance;
+    return instance;
+  }
+
+  // src/version.ts
+  var version = "1.0.2";
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map