@robot-admin/request-core 0.1.2 → 0.2.0

package/dist/index.js

@@ -4,37 +4,156 @@ import { useMessage, useDialog } from 'naive-ui';
 
 // src/axios/request.ts
 
+// src/axios/plugins/request.ts
+var reLoginPromise = null;
+var reLoginResolve = null;
+var reLoginReject = null;
+function waitForReLogin() {
+  if (!reLoginPromise) {
+    reLoginPromise = new Promise((resolve, reject) => {
+      reLoginResolve = resolve;
+      reLoginReject = reject;
+    }).finally(() => {
+      reLoginPromise = null;
+      reLoginResolve = null;
+      reLoginReject = null;
+    });
+  }
+  return reLoginPromise;
+}
+function getReLoginPromise() {
+  return reLoginPromise;
+}
+function resolveReLogin() {
+  if (reLoginResolve) {
+    reLoginResolve();
+  }
+}
+function rejectReLogin(reason) {
+  if (reLoginReject) {
+    reLoginReject(reason);
+  }
+}
+
+// src/axios/utils/abort.ts
+function ensureSharedAbortController(config) {
+  if (typeof AbortController === "undefined") return null;
+  const existing = config.__abortController;
+  if (existing) {
+    existing._startTime ?? (existing._startTime = Date.now());
+    config.signal = existing.signal;
+    return existing;
+  }
+  const externalSignal = config.signal;
+  const controller = new AbortController();
+  controller._startTime = Date.now();
+  if (externalSignal && externalSignal !== controller.signal) {
+    config.__externalSignal = externalSignal;
+    const forwardAbort = () => {
+      if (!controller.signal.aborted) {
+        controller.abort(externalSignal.reason);
+      }
+    };
+    if (externalSignal.aborted) {
+      forwardAbort();
+    } else {
+      externalSignal.addEventListener?.("abort", forwardAbort, { once: true });
+      config.__abortCleanup = () => {
+        externalSignal.removeEventListener?.("abort", forwardAbort);
+      };
+    }
+  }
+  config.__abortController = controller;
+  config.signal = controller.signal;
+  return controller;
+}
+function cleanupAbortContext(config) {
+  if (!config) return;
+  config.__abortCleanup?.();
+  if (config.__externalSignal) {
+    config.signal = config.__externalSignal;
+  } else if (config.signal === config.__abortController?.signal) {
+    delete config.signal;
+  }
+  delete config.__abortCleanup;
+  delete config.__externalSignal;
+  delete config.__abortController;
+}
+
 // src/axios/utils/helpers.ts
+var binaryObjectIds = /* @__PURE__ */ new WeakMap();
+var nextBinaryObjectId = 0;
+function getBinaryObjectId(value) {
+  let id = binaryObjectIds.get(value);
+  if (id === void 0) {
+    id = ++nextBinaryObjectId;
+    binaryObjectIds.set(value, id);
+  }
+  return id;
+}
 function sortedStringify(obj, seen = /* @__PURE__ */ new WeakSet()) {
   if (obj === null || obj === void 0) {
     return "";
   }
+  if (typeof obj === "bigint") return `bigint:${obj.toString()}`;
   if (typeof obj !== "object") {
-    return String(obj);
+    return `${typeof obj}:${String(obj)}`;
   }
   if (seen.has(obj)) {
     throw new Error("\u68C0\u6D4B\u5230\u5FAA\u73AF\u5F15\u7528\uFF0C\u65E0\u6CD5\u751F\u6210\u7A33\u5B9A\u7684\u7F13\u5B58\u952E");
   }
   seen.add(obj);
-  if (Array.isArray(obj)) {
-    return JSON.stringify(obj.map((item) => sortedStringify(item, seen)));
-  }
-  const sortedKeys = Object.keys(obj).sort();
-  const sortedObj = {};
-  for (const key of sortedKeys) {
-    sortedObj[key] = obj[key];
+  try {
+    if (Array.isArray(obj)) {
+      return `[${obj.map((item) => sortedStringify(item, seen)).join(",")}]`;
+    }
+    if (obj instanceof Date) return `date:${obj.toISOString()}`;
+    if (typeof URLSearchParams !== "undefined" && obj instanceof URLSearchParams) {
+      return `url-search:${JSON.stringify(Array.from(obj.entries()).sort())}`;
+    }
+    if (typeof FormData !== "undefined" && obj instanceof FormData) {
+      const entries = Array.from(obj.entries()).map(([key, value]) => [
+        key,
+        typeof value === "string" ? `string:${value}` : `binary:${getBinaryObjectId(value)}:${value.name}:${value.size}:${value.type}`
+      ]);
+      return `form-data:${JSON.stringify(entries)}`;
+    }
+    if (typeof Blob !== "undefined" && obj instanceof Blob || obj instanceof ArrayBuffer || ArrayBuffer.isView(obj)) {
+      return `binary:${getBinaryObjectId(obj)}`;
+    }
+    const source = typeof obj.toJSON === "function" && obj.constructor?.name === "AxiosHeaders" ? obj.toJSON() : obj;
+    const sortedKeys = Object.keys(source).sort();
+    return `{${sortedKeys.map((key) => `${JSON.stringify(key)}:${sortedStringify(source[key], seen)}`).join(",")}}`;
+  } finally {
+    seen.delete(obj);
   }
-  return JSON.stringify(sortedObj);
 }
 function generateRequestKey(config) {
-  const { method = "get", url = "", params, data } = config;
+  const { method = "get", url = "", params, data, headers } = config;
   const parts = [method.toUpperCase(), url];
-  if (params && Object.keys(params).length > 0) {
+  if (params != null) {
     parts.push(sortedStringify(params));
   }
-  if (data && Object.keys(data).length > 0) {
+  if (data != null) {
     parts.push(sortedStringify(data));
   }
+  if (headers) {
+    const authHeaders = {};
+    const authKeys = ["authorization", "x-tenant-id", "x-user-id"];
+    const lowerHeaders = {};
+    const headerSource = typeof headers.toJSON === "function" ? headers.toJSON() : headers;
+    for (const [k, v] of Object.entries(headerSource)) {
+      lowerHeaders[String(k).toLowerCase()] = v;
+    }
+    for (const key of authKeys) {
+      if (lowerHeaders[key] != null) {
+        authHeaders[key] = String(lowerHeaders[key]);
+      }
+    }
+    if (Object.keys(authHeaders).length > 0) {
+      parts.push(sortedStringify(authHeaders));
+    }
+  }
   return parts.join("|");
 }
 var MemoryCache = class {
@@ -64,6 +183,10 @@ var MemoryCache = class {
    * 设置缓存
    */
   set(key, data, ttl) {
+    if (!Number.isFinite(ttl) || ttl < 0) {
+      throw new RangeError("\u7F13\u5B58 TTL \u5FC5\u987B\u662F\u5927\u4E8E\u6216\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u503C");
+    }
+    if (this.maxSize === 0) return;
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
       this.evictOldest();
     }
@@ -112,6 +235,9 @@ var MemoryCache = class {
    * 设置最大缓存大小
    */
   setMaxSize(size) {
+    if (!Number.isInteger(size) || size < 0) {
+      throw new RangeError("\u7F13\u5B58\u6700\u5927\u5BB9\u91CF\u5FC5\u987B\u662F\u5927\u4E8E\u6216\u7B49\u4E8E 0 \u7684\u6574\u6570");
+    }
     this.maxSize = size;
     while (this.cache.size > this.maxSize) {
       this.evictOldest();
@@ -129,14 +255,36 @@ var MemoryCache = class {
   }
 };
 var globalCache = new MemoryCache();
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(createAbortError(signal.reason));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener?.("abort", onAbort);
+      resolve();
+    }, Math.max(0, Number.isFinite(ms) ? ms : 0));
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+      reject(createAbortError(signal?.reason));
+    };
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+  });
+}
+function createAbortError(reason) {
+  if (reason instanceof Error) return reason;
+  return Object.assign(new Error("canceled"), {
+    name: "AbortError",
+    code: "ERR_CANCELED",
+    reason
+  });
 }
 function isNetworkError(error) {
   return !error.response && Boolean(error.code) && error.code !== "ECONNABORTED" && error.code !== "ERR_CANCELED" && error.message !== "canceled" && error.message !== "Request aborted" && error.message !== "Request cancelled";
 }
 function isTimeoutError(error) {
-  return error.code === "ECONNABORTED" && error.message.includes("timeout");
+  return error?.code === "ECONNABORTED" || error?.code === "ETIMEDOUT";
 }
 function isRetryableStatus(status, retryableStatusCodes) {
   return retryableStatusCodes.includes(status);
@@ -148,8 +296,11 @@ function normalizeConfig(config, defaults) {
   if (config === false) {
     return { ...defaults, enabled: false };
   }
-  if (typeof config === "object") {
-    return { ...defaults, ...config };
+  if (config && typeof config === "object") {
+    const definedEntries = Object.entries(config).filter(
+      ([, value]) => value !== void 0
+    );
+    return { ...defaults, ...Object.fromEntries(definedEntries) };
   }
   return defaults;
 }
@@ -160,12 +311,14 @@ var DEFAULT_DEDUPE_CONFIG = {
   keyGenerator: generateRequestKey
 };
 var pendingRequests = /* @__PURE__ */ new Map();
+var CLEANUP_INTERVAL = 3e4;
+var REQUEST_TIMEOUT = 5 * 60 * 1e3;
+var cleanupTimer = null;
 function cleanupExpiredRequests() {
   const now = Date.now();
-  const TIMEOUT = 5 * 60 * 1e3;
   Array.from(pendingRequests.entries()).forEach(([key, controller]) => {
     const startTime = controller._startTime || now;
-    if (now - startTime > TIMEOUT) {
+    if (now - startTime > REQUEST_TIMEOUT) {
       try {
         controller.abort();
       } catch (error) {
@@ -174,9 +327,26 @@ function cleanupExpiredRequests() {
       pendingRequests.delete(key);
     }
   });
+  stopCleanupTimerIfIdle();
+}
+function startCleanupTimer() {
+  if (cleanupTimer) return;
+  cleanupTimer = setInterval(cleanupExpiredRequests, CLEANUP_INTERVAL);
+  cleanupTimer.unref?.();
+}
+function stopCleanupTimerIfIdle() {
+  if (pendingRequests.size === 0 && cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
 }
-if (typeof window !== "undefined") {
-  setInterval(cleanupExpiredRequests, 3e4);
+function removePendingRequest(config) {
+  const requestKey = config.__requestKey;
+  const controller = config.__abortController;
+  if (requestKey && controller && pendingRequests.get(requestKey) === controller) {
+    pendingRequests.delete(requestKey);
+  }
+  stopCleanupTimerIfIdle();
 }
 function onRequest(config) {
   const enhancedConfig = config;
@@ -201,40 +371,22 @@ function onRequest(config) {
     }
     pendingRequests.delete(requestKey);
   }
-  if (config.signal) {
-    return config;
-  }
-  const controller = new AbortController();
-  controller._startTime = Date.now();
-  config.signal = controller.signal;
+  const controller = ensureSharedAbortController(enhancedConfig);
+  if (!controller) return config;
+  enhancedConfig.__requestKey = requestKey;
   pendingRequests.set(requestKey, controller);
+  startCleanupTimer();
   return config;
 }
 function onResponse(response) {
   const config = response.config;
-  const dedupeConfig = normalizeConfig(
-    config.dedupe,
-    DEFAULT_DEDUPE_CONFIG
-  );
-  if (dedupeConfig.enabled) {
-    const keyGenerator = dedupeConfig.keyGenerator || DEFAULT_DEDUPE_CONFIG.keyGenerator;
-    const requestKey = keyGenerator(config);
-    pendingRequests.delete(requestKey);
-  }
+  removePendingRequest(config);
   return response;
 }
 function onResponseError(error) {
   const config = error.config;
   if (config) {
-    const dedupeConfig = normalizeConfig(
-      config.dedupe,
-      DEFAULT_DEDUPE_CONFIG
-    );
-    if (dedupeConfig.enabled) {
-      const keyGenerator = dedupeConfig.keyGenerator || DEFAULT_DEDUPE_CONFIG.keyGenerator;
-      const requestKey = keyGenerator(config);
-      pendingRequests.delete(requestKey);
-    }
+    removePendingRequest(config);
   }
   return Promise.reject(error);
 }
@@ -251,11 +403,7 @@ function cancelAllPendingRequests() {
     }
   });
   pendingRequests.clear();
-}
-if (typeof window !== "undefined") {
-  window.addEventListener("beforeunload", () => {
-    cancelAllPendingRequests();
-  });
+  stopCleanupTimerIfIdle();
 }
 function getPendingRequestCount() {
   return pendingRequests.size;
@@ -372,10 +520,13 @@ var DEFAULT_RETRY_CONFIG = {
   count: 3,
   delay: 1e3,
   exponentialBackoff: true,
-  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+  jitter: true,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+  // 默认仅重试幂等方法，避免对 POST 等非幂等请求重复执行造成副作用（重复扣款/重复创建）
+  retryableMethods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]
 };
 function isCancelError(error) {
-  return error.name === "CanceledError" || error.name === "AbortError" || error.code === "ERR_CANCELED" || error.message === "canceled" || error.message?.includes("abort");
+  return error?.name === "CanceledError" || error?.name === "AbortError" || error?.code === "ERR_CANCELED";
 }
 function shouldRetry(error, retryConfig) {
   if (!retryConfig.enabled) {
@@ -389,6 +540,12 @@ function shouldRetry(error, retryConfig) {
   if (isCancelError(error)) {
     return false;
   }
+  const method = (config.method || "get").toUpperCase();
+  if (!retryConfig.retryableMethods.some(
+    (retryableMethod) => retryableMethod.toUpperCase() === method
+  )) {
+    return false;
+  }
   if (isNetworkError(error)) {
     return true;
   }
@@ -404,11 +561,17 @@ function shouldRetry(error, retryConfig) {
   return false;
 }
 function getRetryDelay(retryCount, retryConfig) {
+  let calculated;
   if (!retryConfig.exponentialBackoff) {
-    return retryConfig.delay;
+    calculated = retryConfig.delay;
+  } else {
+    calculated = retryConfig.delay * Math.pow(2, retryCount - 1);
+  }
+  if (retryConfig.jitter) {
+    const factor = 0.75 + Math.random() * 0.5;
+    calculated = Math.round(calculated * factor);
   }
-  const calculatedDelay = retryConfig.delay * Math.pow(2, retryCount);
-  return Math.min(calculatedDelay, 3e4);
+  return Math.min(Math.max(0, calculated), 3e4);
 }
 function setupRetryPlugin(instance) {
   const onResponseError4 = async (error) => {
@@ -425,24 +588,39 @@ function setupRetryPlugin(instance) {
     }
     config.__retryCount = (config.__retryCount ?? 0) + 1;
     const retryDelay = getRetryDelay(config.__retryCount, retryConfig);
-    await delay(retryDelay);
-    const retryConfig_ = { ...config };
-    const originalSignal = config.signal;
-    const newController = new AbortController();
-    if (originalSignal && typeof originalSignal.addEventListener === "function") {
-      originalSignal.addEventListener("abort", () => {
-        newController.abort();
+    try {
+      await delay(retryDelay, config.signal);
+    } catch (abortError) {
+      const error_ = Object.assign(new Error("canceled"), {
+        name: "CanceledError",
+        code: "ERR_CANCELED",
+        config,
+        cause: abortError
       });
+      return Promise.reject(error_);
     }
-    retryConfig_.signal = newController.signal;
+    const retryConfig_ = { ...config };
     delete retryConfig_.__cancelId;
-    delete retryConfig_.__managedByCancel;
-    delete retryConfig_.__handling401;
+    delete retryConfig_.__requestKey;
     return instance.request(retryConfig_);
   };
   instance.interceptors.response.use(void 0, onResponseError4);
 }
 
+// src/axios/plugins/response.ts
+function setupResponsePlugin(instance) {
+  instance.interceptors.response.use(
+    (response) => {
+      cleanupAbortContext(response.config);
+      return response;
+    },
+    (error) => {
+      cleanupAbortContext(error?.config);
+      return Promise.reject(error);
+    }
+  );
+}
+
 // src/axios/plugins/cancel.ts
 var DEFAULT_CANCEL_CONFIG = {
   enabled: true,
@@ -450,15 +628,15 @@ var DEFAULT_CANCEL_CONFIG = {
 };
 var cancelableRequests = /* @__PURE__ */ new Map();
 var requestId = 0;
-var CLEANUP_INTERVAL = 3e4;
-var REQUEST_TIMEOUT = 3e5;
-var cleanupTimer = null;
+var CLEANUP_INTERVAL2 = 3e4;
+var REQUEST_TIMEOUT2 = 3e5;
+var cleanupTimer2 = null;
 function cleanupExpiredRequests2() {
   const now = Date.now();
   const expiredKeys = [];
   for (const [key, controller] of cancelableRequests.entries()) {
     const requestStartTime = controller._startTime || now;
-    if (now - requestStartTime > REQUEST_TIMEOUT) {
+    if (now - requestStartTime > REQUEST_TIMEOUT2) {
       expiredKeys.push(key);
       try {
         controller.abort();
@@ -468,27 +646,26 @@ function cleanupExpiredRequests2() {
     }
   }
   expiredKeys.forEach((key) => cancelableRequests.delete(key));
+  stopCleanupTimerIfIdle2();
 }
-function startCleanupTimer() {
-  if (cleanupTimer) {
-    clearInterval(cleanupTimer);
-  }
-  cleanupTimer = setInterval(cleanupExpiredRequests2, CLEANUP_INTERVAL);
+function startCleanupTimer2() {
+  if (cleanupTimer2) return;
+  cleanupTimer2 = setInterval(cleanupExpiredRequests2, CLEANUP_INTERVAL2);
+  cleanupTimer2.unref?.();
 }
 function stopCleanupTimer() {
-  if (cleanupTimer) {
-    clearInterval(cleanupTimer);
-    cleanupTimer = null;
+  if (cleanupTimer2) {
+    clearInterval(cleanupTimer2);
+    cleanupTimer2 = null;
   }
 }
+function stopCleanupTimerIfIdle2() {
+  if (cancelableRequests.size === 0) stopCleanupTimer();
+}
 function isInWhitelist(url, whitelist) {
   return whitelist.some((pattern) => pattern.test(url));
 }
 function onRequest3(config) {
-  if (typeof AbortController === "undefined") {
-    console.warn("AbortController is not supported in this environment");
-    return config;
-  }
   const enhancedConfig = config;
   const cancelConfig = normalizeConfig(
     enhancedConfig.cancel,
@@ -504,12 +681,12 @@ function onRequest3(config) {
   if (isInWhitelist(url, cancelConfig.whitelist)) {
     return config;
   }
-  const controller = new AbortController();
+  const activeController = ensureSharedAbortController(enhancedConfig);
+  if (!activeController) return config;
   const id = `request_${++requestId}`;
-  controller._startTime = Date.now();
-  config.signal = controller.signal;
-  config.__cancelId = id;
-  cancelableRequests.set(id, controller);
+  enhancedConfig.__cancelId = id;
+  cancelableRequests.set(id, activeController);
+  startCleanupTimer2();
   return config;
 }
 function onResponse3(response) {
@@ -517,6 +694,7 @@ function onResponse3(response) {
   const cancelId = config.__cancelId;
   if (cancelId) {
     cancelableRequests.delete(cancelId);
+    stopCleanupTimerIfIdle2();
   }
   return response;
 }
@@ -525,6 +703,7 @@ function onResponseError3(error) {
   const cancelId = config?.__cancelId;
   if (cancelId) {
     cancelableRequests.delete(cancelId);
+    stopCleanupTimerIfIdle2();
   }
   return Promise.reject(error);
 }
@@ -541,13 +720,7 @@ function cancelAllRequests() {
     }
   });
   cancelableRequests.clear();
-}
-if (typeof window !== "undefined") {
-  window.addEventListener("beforeunload", () => {
-    cancelAllRequests();
-    stopCleanupTimer();
-  });
-  startCleanupTimer();
+  stopCleanupTimer();
 }
 function getCancelableRequestCount() {
   return cancelableRequests.size;
@@ -559,56 +732,61 @@ function setupPlugins(instance) {
   setupCancelPlugin(instance);
   setupDedupePlugin(instance);
   setupRetryPlugin(instance);
+  setupResponsePlugin(instance);
 }
 
-// src/axios/request.ts
+// src/axios/service.ts
 var globalService = null;
-function createAxiosInstance(config = {}) {
-  const instance = axios.create({
-    timeout: 5e3,
-    headers: {
-      "Content-Type": "application/json"
-    },
-    ...config
-  });
-  setupPlugins(instance);
-  return instance;
-}
 function setGlobalAxiosInstance(instance) {
   globalService = instance;
 }
 function getGlobalAxiosInstance() {
   if (!globalService) {
     throw new Error(
-      "Axios instance not initialized. Please call createRequestCore() first."
+      "Axios instance not initialized. Please call createRequestCore() or setGlobalAxiosInstance() first."
     );
   }
   return globalService;
 }
 new Proxy({}, {
-  get(target, prop) {
+  get(_target, prop) {
     return getGlobalAxiosInstance()[prop];
   }
 });
-var getData = async (url, config) => {
-  const res = await getGlobalAxiosInstance().get(url, config);
-  return res.data;
-};
-var postData = async (url, data, config) => {
-  const res = await getGlobalAxiosInstance().post(url, data, config);
-  return res.data;
-};
-var putData = async (url, data, config) => {
-  const res = await getGlobalAxiosInstance().put(url, data, config);
-  return res.data;
-};
-var deleteData = async (url, config) => {
-  const res = await getGlobalAxiosInstance().delete(url, config);
-  return res.data;
-};
+async function getData(url, config) {
+  const response = await getGlobalAxiosInstance().get(url, config);
+  return response.data;
+}
+async function postData(url, data, config) {
+  const response = await getGlobalAxiosInstance().post(url, data, config);
+  return response.data;
+}
+async function putData(url, data, config) {
+  const response = await getGlobalAxiosInstance().put(url, data, config);
+  return response.data;
+}
+async function deleteData(url, config) {
+  const response = await getGlobalAxiosInstance().delete(url, config);
+  return response.data;
+}
+
+// src/axios/request.ts
+function createAxiosInstance(config = {}) {
+  const instance = axios.create({
+    timeout: 5e3,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    ...config
+  });
+  setupPlugins(instance);
+  return instance;
+}
 var onReLoginSuccess = () => {
+  resolveReLogin();
 };
 var onReLoginCancel = () => {
+  rejectReLogin(new Error("\u91CD\u65B0\u767B\u5F55\u5DF2\u53D6\u6D88"));
 };
 
 // src/core.ts
@@ -1102,6 +1280,6 @@ function useTableCrud(config) {
   };
 }
 
-export { cancelAllPendingRequests, cancelAllRequests, cleanupExpiredCache, clearAllCache, clearCache, createAxiosInstance, createRequestCore, deleteData, getCacheSize, getCancelableRequestCount, getData, getGlobalConfig, getPendingRequestCount, onReLoginCancel, onReLoginSuccess, postData, putData, useTableCrud };
+export { cancelAllPendingRequests, cancelAllRequests, cleanupExpiredCache, clearAllCache, clearCache, createAxiosInstance, createRequestCore, deleteData, getCacheSize, getCancelableRequestCount, getData, getGlobalConfig, getPendingRequestCount, getReLoginPromise, onReLoginCancel, onReLoginSuccess, postData, putData, useTableCrud, waitForReLogin };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map