@robot-admin/request-core 0.2.0 → 0.4.0

package/dist/chunk-OAZ5BUBU.js

@@ -0,0 +1,969 @@
+import axios2 from 'axios';
+
+// 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(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "bigint") return `bigint:${value.toString()}`;
+  if (typeof value !== "object") return `${typeof value}:${String(value)}`;
+  if (seen.has(value)) {
+    throw new Error("Cannot generate a stable request key from a circular value.");
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => sortedStringify(item, seen)).join(",")}]`;
+    }
+    if (value instanceof Date) return `date:${value.toISOString()}`;
+    if (value instanceof Map) {
+      return `map:${sortedStringify(
+        [...value.entries()].sort(
+          ([left], [right]) => String(left).localeCompare(String(right))
+        ),
+        seen
+      )}`;
+    }
+    if (value instanceof Set) {
+      return `set:${sortedStringify(
+        [...value.values()].sort(
+          (left, right) => String(left).localeCompare(String(right))
+        ),
+        seen
+      )}`;
+    }
+    if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) {
+      return `url-search:${JSON.stringify([...value.entries()].sort())}`;
+    }
+    if (typeof FormData !== "undefined" && value instanceof FormData) {
+      const entries = [...value.entries()].map(([key, item]) => [
+        key,
+        typeof item === "string" ? `string:${item}` : `binary:${getBinaryObjectId(item)}:${item.name}:${item.size}:${item.type}`
+      ]);
+      return `form-data:${JSON.stringify(entries)}`;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+      return `binary:${getBinaryObjectId(value)}`;
+    }
+    const candidate = value;
+    const jsonValue = typeof candidate.toJSON === "function" && candidate.constructor?.name === "AxiosHeaders" ? candidate.toJSON() : candidate;
+    if (!jsonValue || typeof jsonValue !== "object") {
+      return sortedStringify(jsonValue, seen);
+    }
+    const source = jsonValue;
+    return `{${Object.keys(source).sort().map((key) => `${JSON.stringify(key)}:${sortedStringify(source[key], seen)}`).join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+function fingerprint(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function generateRequestKey(config, options = {}) {
+  const {
+    method = "get",
+    url = "",
+    baseURL = "",
+    params,
+    data,
+    headers,
+    responseType = "json"
+  } = config;
+  const parts = [method.toUpperCase(), baseURL, url, responseType];
+  if (params != null) parts.push(sortedStringify(params));
+  if (data != null) parts.push(sortedStringify(data));
+  if (headers) {
+    const headerSource = typeof headers.toJSON === "function" ? headers.toJSON() : headers;
+    const normalized = {};
+    for (const [key, value] of Object.entries(
+      headerSource
+    )) {
+      normalized[key.toLowerCase()] = value;
+    }
+    const varyHeaders = new Set(
+      ["authorization", "x-tenant-id", "x-user-id", ...options.varyHeaders ?? []].map(
+        (key) => key.toLowerCase()
+      )
+    );
+    const selected = {};
+    for (const key of [...varyHeaders].sort()) {
+      if (normalized[key] != null) {
+        selected[key] = fingerprint(String(normalized[key]));
+      }
+    }
+    if (Object.keys(selected).length > 0) parts.push(sortedStringify(selected));
+  }
+  return parts.join("|");
+}
+function defaultClone(value) {
+  if (typeof structuredClone !== "function") return value;
+  try {
+    return structuredClone(value);
+  } catch {
+    return value;
+  }
+}
+var MemoryCache = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.accessOrder = /* @__PURE__ */ new Set();
+    this.maxSize = options.maxSize ?? 1e3;
+    this.assertMaxSize(this.maxSize);
+    this.cloneValue = typeof options.clone === "function" ? options.clone : options.clone === false ? (value) => value : defaultClone;
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    if (Date.now() >= item.expireAt) {
+      this.delete(key);
+      return null;
+    }
+    this.accessOrder.delete(key);
+    this.accessOrder.add(key);
+    return this.cloneValue(item.data);
+  }
+  set(key, data, ttl, options = {}) {
+    if (!Number.isFinite(ttl) || ttl < 0) {
+      throw new RangeError("Cache TTL must be a finite number greater than or equal to 0.");
+    }
+    if (this.maxSize === 0) return;
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) this.evictOldest();
+    this.cache.set(key, {
+      data: this.cloneValue(data),
+      expireAt: Date.now() + ttl,
+      tags: options.tags ? [...options.tags] : void 0
+    });
+    this.accessOrder.delete(key);
+    this.accessOrder.add(key);
+  }
+  delete(key) {
+    this.accessOrder.delete(key);
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+    this.accessOrder.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, item] of this.cache) {
+      if (now >= item.expireAt) this.delete(key);
+    }
+  }
+  deleteByPrefix(prefix) {
+    let removed = 0;
+    for (const key of [...this.cache.keys()]) {
+      if (key.startsWith(prefix) && this.delete(key)) removed += 1;
+    }
+    return removed;
+  }
+  deleteByTag(tag) {
+    let removed = 0;
+    for (const [key, item] of [...this.cache.entries()]) {
+      if (item.tags?.includes(tag) && this.delete(key)) removed += 1;
+    }
+    return removed;
+  }
+  get size() {
+    return this.cache.size;
+  }
+  setMaxSize(size) {
+    this.assertMaxSize(size);
+    this.maxSize = size;
+    while (this.cache.size > this.maxSize) this.evictOldest();
+  }
+  assertMaxSize(size) {
+    if (!Number.isInteger(size) || size < 0) {
+      throw new RangeError(
+        "Cache capacity must be an integer greater than or equal to 0."
+      );
+    }
+  }
+  evictOldest() {
+    const oldestKey = this.accessOrder.values().next().value;
+    if (oldestKey !== void 0) this.delete(oldestKey);
+  }
+};
+function delay(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(createAbortError(signal.reason));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.("abort", onAbort);
+      reject(createAbortError(signal?.reason));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener?.("abort", onAbort);
+      resolve();
+    }, Math.max(0, Number.isFinite(ms) ? ms : 0));
+    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) {
+  const candidate = error;
+  return !candidate?.response && Boolean(candidate?.code) && candidate.code !== "ECONNABORTED" && candidate.code !== "ERR_CANCELED" && candidate.message !== "canceled" && candidate.message !== "Request aborted" && candidate.message !== "Request cancelled";
+}
+function isTimeoutError(error) {
+  const code = error?.code;
+  return code === "ECONNABORTED" || code === "ETIMEDOUT";
+}
+function isRetryableStatus(status, retryableStatusCodes) {
+  return retryableStatusCodes.includes(status);
+}
+function normalizeConfig(config, defaults) {
+  if (config === true) return { ...defaults, enabled: true };
+  if (config === false) return { ...defaults, enabled: false };
+  if (config && typeof config === "object") {
+    return {
+      ...defaults,
+      ...Object.fromEntries(
+        Object.entries(config).filter(
+          ([, value]) => value !== void 0
+        )
+      )
+    };
+  }
+  return { ...defaults };
+}
+
+// src/axios/runtime.ts
+var RUNTIME_KEY = /* @__PURE__ */ Symbol.for("@robot-admin/request-core/runtime/v1");
+var PACKAGE_STATE_KEY = /* @__PURE__ */ Symbol.for("@robot-admin/request-core/state/v1");
+var DEFAULT_GLOBAL_CONFIG = {
+  successCodes: [200, 0, "200", "0"],
+  fieldAliases: {
+    data: ["data", "list", "items", "records"],
+    list: ["list", "items", "records", "rows", "data"],
+    total: ["total", "totalCount", "count", "totalElements"]
+  }
+};
+function cloneGlobalConfig(config) {
+  return {
+    successCodes: [...config.successCodes],
+    fieldAliases: {
+      data: [...config.fieldAliases.data],
+      list: [...config.fieldAliases.list],
+      total: [...config.fieldAliases.total]
+    }
+  };
+}
+function getSharedState() {
+  const target = globalThis;
+  if (!target[PACKAGE_STATE_KEY]) {
+    target[PACKAGE_STATE_KEY] = {
+      defaultInstance: null,
+      lastInstance: null,
+      globalConfig: cloneGlobalConfig(DEFAULT_GLOBAL_CONFIG)
+    };
+  }
+  return target[PACKAGE_STATE_KEY];
+}
+function createRequestRuntime(options = {}) {
+  return {
+    cache: options.cache ?? new MemoryCache(),
+    defaults: { ...options.defaults },
+    pendingRequests: /* @__PURE__ */ new Map(),
+    cancelableRequests: /* @__PURE__ */ new Map(),
+    joinedRequests: /* @__PURE__ */ new Map(),
+    requestId: 0,
+    dedupeCleanupTimer: null,
+    cancelCleanupTimer: null,
+    reLogin: { promise: null, resolve: null, reject: null },
+    authRefreshPromise: null,
+    reauthenticatePromise: null,
+    disposed: false
+  };
+}
+function attachRequestRuntime(instance, runtime) {
+  Object.defineProperty(instance, RUNTIME_KEY, {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: runtime
+  });
+  getSharedState().lastInstance = instance;
+}
+function getRequestRuntime(instance) {
+  const runtime = instance[RUNTIME_KEY];
+  if (!runtime) {
+    throw new Error("The Axios instance is not managed by request-core.");
+  }
+  return runtime;
+}
+function getActiveRequestRuntime(instance) {
+  const shared = getSharedState();
+  const target = instance ?? shared.defaultInstance ?? shared.lastInstance;
+  if (!target) {
+    throw new Error(
+      "Request client not initialized. Create a client or call createRequestCore() first."
+    );
+  }
+  return getRequestRuntime(target);
+}
+function setDefaultAxiosInstance(instance) {
+  getRequestRuntime(instance);
+  getSharedState().defaultInstance = instance;
+}
+function getDefaultAxiosInstance() {
+  return getSharedState().defaultInstance;
+}
+function getGlobalRuntimeConfig() {
+  return cloneGlobalConfig(getSharedState().globalConfig);
+}
+function setGlobalRuntimeConfig(config) {
+  const next = cloneGlobalConfig(DEFAULT_GLOBAL_CONFIG);
+  if (config.successCodes) next.successCodes = [...config.successCodes];
+  if (config.fieldAliases?.data) next.fieldAliases.data = [...config.fieldAliases.data];
+  if (config.fieldAliases?.list) next.fieldAliases.list = [...config.fieldAliases.list];
+  if (config.fieldAliases?.total) next.fieldAliases.total = [...config.fieldAliases.total];
+  getSharedState().globalConfig = next;
+}
+
+// src/axios/plugins/cache.ts
+var DEFAULT_CACHE_CONFIG = {
+  enabled: false,
+  ttl: 5 * 60 * 1e3,
+  forceUpdate: false,
+  tags: [],
+  varyHeaders: []
+};
+function resolveCacheConfig(config, runtime) {
+  const inherited = normalizeConfig(
+    runtime.defaults.cache,
+    DEFAULT_CACHE_CONFIG
+  );
+  const resolved = normalizeConfig(config.cache, inherited);
+  if (!Number.isFinite(resolved.ttl) || resolved.ttl < 0) {
+    throw new RangeError("Cache TTL must be a finite number greater than or equal to 0.");
+  }
+  return resolved;
+}
+function cacheKey(config, cacheConfig) {
+  return cacheConfig.key ?? generateRequestKey(config, { varyHeaders: cacheConfig.varyHeaders });
+}
+function createCacheResponse(cached, config) {
+  return {
+    data: cached.data,
+    status: cached.status,
+    statusText: `${cached.statusText} (from cache)`,
+    headers: cached.headers,
+    config
+  };
+}
+function setupCachePlugin(instance, runtime) {
+  instance.interceptors.request.use((config) => {
+    const enhanced = config;
+    const cacheConfig = resolveCacheConfig(enhanced, runtime);
+    if (config.method?.toUpperCase() !== "GET" || !cacheConfig.enabled || cacheConfig.forceUpdate) {
+      return config;
+    }
+    const cached = runtime.cache.get(
+      cacheKey(config, cacheConfig)
+    );
+    if (!cached) return config;
+    enhanced.__fromCache = true;
+    const hit = {
+      __fromCache: true,
+      __cachedResponse: createCacheResponse(cached, config),
+      config
+    };
+    return Promise.reject(hit);
+  });
+  instance.interceptors.response.use(
+    (response) => {
+      const config = response.config;
+      if (config.__fromCache && config.__cachedResponse) {
+        return config.__cachedResponse;
+      }
+      const cacheConfig = resolveCacheConfig(config, runtime);
+      if (config.method?.toUpperCase() === "GET" && cacheConfig.enabled && response.status >= 200 && response.status < 300) {
+        const cached = {
+          data: response.data,
+          status: response.status,
+          statusText: response.statusText,
+          headers: { ...response.headers }
+        };
+        runtime.cache.set(cacheKey(config, cacheConfig), cached, cacheConfig.ttl, {
+          tags: cacheConfig.tags
+        });
+      }
+      return response;
+    },
+    (error) => {
+      const hit = error;
+      if (hit.__fromCache && hit.__cachedResponse) {
+        return Promise.resolve(hit.__cachedResponse);
+      }
+      return Promise.reject(error);
+    }
+  );
+}
+function clearAllCache(instance) {
+  getActiveRequestRuntime(instance).cache.clear();
+}
+function clearCache(config, instance) {
+  const runtime = getActiveRequestRuntime(instance);
+  const cacheConfig = resolveCacheConfig(config, runtime);
+  return runtime.cache.delete(cacheKey(config, cacheConfig));
+}
+function clearCacheByPrefix(prefix, instance) {
+  return getActiveRequestRuntime(instance).cache.deleteByPrefix?.(prefix) ?? 0;
+}
+function clearCacheByTag(tag, instance) {
+  return getActiveRequestRuntime(instance).cache.deleteByTag?.(tag) ?? 0;
+}
+function cleanupExpiredCache(instance) {
+  getActiveRequestRuntime(instance).cache.cleanup?.();
+}
+function getCacheSize(instance) {
+  return getActiveRequestRuntime(instance).cache.size;
+}
+
+// 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/plugins/cancel.ts
+var DEFAULT_CANCEL_CONFIG = {
+  enabled: true,
+  whitelist: []
+};
+var CLEANUP_INTERVAL = 3e4;
+var REQUEST_TIMEOUT = 5 * 6e4;
+function stopTimerIfIdle(runtime) {
+  if (runtime.cancelableRequests.size === 0 && runtime.cancelCleanupTimer) {
+    clearInterval(runtime.cancelCleanupTimer);
+    runtime.cancelCleanupTimer = null;
+  }
+}
+function startTimer(runtime) {
+  if (runtime.cancelCleanupTimer) return;
+  runtime.cancelCleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [id, entry] of runtime.cancelableRequests) {
+      if (now - (entry.controller._startTime ?? now) > REQUEST_TIMEOUT) {
+        entry.controller.abort(new Error("Request lifecycle expired."));
+        runtime.cancelableRequests.delete(id);
+      }
+    }
+    stopTimerIfIdle(runtime);
+  }, CLEANUP_INTERVAL);
+  runtime.cancelCleanupTimer.unref?.();
+}
+function isWhitelisted(url, whitelist) {
+  return whitelist.some((pattern) => new RegExp(pattern.source, pattern.flags).test(url));
+}
+function removeCancelable(config, runtime) {
+  if (config?.__cancelId) runtime.cancelableRequests.delete(config.__cancelId);
+  stopTimerIfIdle(runtime);
+}
+function setupCancelPlugin(instance, runtime) {
+  instance.interceptors.request.use((config) => {
+    const enhanced = config;
+    const inherited = normalizeConfig(
+      runtime.defaults.cancel,
+      DEFAULT_CANCEL_CONFIG
+    );
+    const cancel = normalizeConfig(enhanced.cancel, inherited);
+    if (!cancel.enabled || enhanced.__fromCache || isWhitelisted(config.url ?? "", cancel.whitelist)) {
+      return config;
+    }
+    const controller = ensureSharedAbortController(enhanced);
+    if (!controller) return config;
+    const id = `request_${++runtime.requestId}`;
+    enhanced.__cancelId = id;
+    runtime.cancelableRequests.set(id, {
+      controller,
+      scope: cancel.scope ?? enhanced.scope
+    });
+    startTimer(runtime);
+    return config;
+  });
+  instance.interceptors.response.use(
+    (response) => {
+      removeCancelable(response.config, runtime);
+      return response;
+    },
+    (error) => {
+      removeCancelable(
+        error?.config,
+        runtime
+      );
+      return Promise.reject(error);
+    }
+  );
+}
+function cancelAllRequests(instance) {
+  const runtime = getActiveRequestRuntime(instance);
+  for (const entry of runtime.cancelableRequests.values()) entry.controller.abort();
+  runtime.cancelableRequests.clear();
+  stopTimerIfIdle(runtime);
+}
+function cancelRequestScope(scope, instance) {
+  const runtime = getActiveRequestRuntime(instance);
+  let canceled = 0;
+  for (const [id, entry] of [...runtime.cancelableRequests.entries()]) {
+    if (entry.scope === scope) {
+      entry.controller.abort(new Error(`Request scope canceled: ${String(scope)}`));
+      runtime.cancelableRequests.delete(id);
+      canceled += 1;
+    }
+  }
+  stopTimerIfIdle(runtime);
+  return canceled;
+}
+function getCancelableRequestCount(instance) {
+  return getActiveRequestRuntime(instance).cancelableRequests.size;
+}
+
+// src/axios/plugins/dedupe.ts
+var DEFAULT_DEDUPE_CONFIG = {
+  enabled: true,
+  keyGenerator: generateRequestKey
+};
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var CLEANUP_INTERVAL2 = 3e4;
+var REQUEST_TIMEOUT2 = 5 * 6e4;
+function stopTimerIfIdle2(runtime) {
+  if (runtime.pendingRequests.size === 0 && runtime.dedupeCleanupTimer) {
+    clearInterval(runtime.dedupeCleanupTimer);
+    runtime.dedupeCleanupTimer = null;
+  }
+}
+function startTimer2(runtime) {
+  if (runtime.dedupeCleanupTimer) return;
+  runtime.dedupeCleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, controller] of runtime.pendingRequests) {
+      if (now - (controller._startTime ?? now) > REQUEST_TIMEOUT2) {
+        controller.abort();
+        runtime.pendingRequests.delete(key);
+      }
+    }
+    stopTimerIfIdle2(runtime);
+  }, CLEANUP_INTERVAL2);
+  runtime.dedupeCleanupTimer.unref?.();
+}
+function removePending(config, runtime) {
+  const key = config.__requestKey;
+  const controller = config.__abortController;
+  if (key && controller && runtime.pendingRequests.get(key) === controller) {
+    runtime.pendingRequests.delete(key);
+  }
+  stopTimerIfIdle2(runtime);
+}
+function setupDedupePlugin(instance, runtime) {
+  instance.interceptors.request.use((config) => {
+    const enhanced = config;
+    const method = (config.method ?? "get").toUpperCase();
+    const requestSetting = enhanced.dedupe ?? runtime.defaults.dedupe;
+    const isImplicitDefault = requestSetting === void 0;
+    if (isImplicitDefault && !SAFE_METHODS.has(method)) return config;
+    const dedupe = normalizeConfig(
+      requestSetting,
+      DEFAULT_DEDUPE_CONFIG
+    );
+    if (!dedupe.enabled || enhanced.__fromCache) return config;
+    const key = dedupe.keyGenerator(config);
+    const existing = runtime.pendingRequests.get(key);
+    if (existing) {
+      existing.abort(new Error("Superseded by a newer request."));
+      runtime.pendingRequests.delete(key);
+    }
+    const controller = ensureSharedAbortController(enhanced);
+    if (!controller) return config;
+    enhanced.__requestKey = key;
+    runtime.pendingRequests.set(key, controller);
+    startTimer2(runtime);
+    return config;
+  });
+  instance.interceptors.response.use(
+    (response) => {
+      removePending(response.config, runtime);
+      return response;
+    },
+    (error) => {
+      const config = error?.config;
+      if (config) removePending(config, runtime);
+      return Promise.reject(error);
+    }
+  );
+}
+function cancelAllPendingRequests(instance) {
+  const runtime = getActiveRequestRuntime(instance);
+  for (const controller of runtime.pendingRequests.values()) controller.abort();
+  runtime.pendingRequests.clear();
+  stopTimerIfIdle2(runtime);
+}
+function getPendingRequestCount(instance) {
+  return getActiveRequestRuntime(instance).pendingRequests.size;
+}
+
+// src/axios/plugins/request.ts
+function waitForReLogin(instance) {
+  const state = getActiveRequestRuntime(instance).reLogin;
+  if (!state.promise) {
+    state.promise = new Promise((resolve, reject) => {
+      state.resolve = resolve;
+      state.reject = reject;
+    }).finally(() => {
+      state.promise = null;
+      state.resolve = null;
+      state.reject = null;
+    });
+  }
+  return state.promise;
+}
+function getReLoginPromise(instance) {
+  return getActiveRequestRuntime(instance).reLogin.promise;
+}
+function resolveReLogin(instance) {
+  getActiveRequestRuntime(instance).reLogin.resolve?.();
+}
+function rejectReLogin(reason, instance) {
+  getActiveRequestRuntime(instance).reLogin.reject?.(reason);
+}
+
+// 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/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  enabled: false,
+  count: 3,
+  delay: 1e3,
+  exponentialBackoff: true,
+  jitter: true,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504],
+  retryableMethods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"],
+  maxDelay: 3e4,
+  maxElapsedMs: 0,
+  respectRetryAfter: true,
+  retryUnsafeBody: false
+};
+function resolveRetryConfig(config, runtime) {
+  const inherited = normalizeConfig(
+    runtime.defaults.retry,
+    DEFAULT_RETRY_CONFIG
+  );
+  const resolved = normalizeConfig(config.retry, inherited);
+  for (const [name, value] of [
+    ["count", resolved.count],
+    ["delay", resolved.delay],
+    ["maxDelay", resolved.maxDelay],
+    ["maxElapsedMs", resolved.maxElapsedMs]
+  ]) {
+    if (!Number.isFinite(value) || value < 0 || name === "count" && !Number.isInteger(value)) {
+      throw new RangeError(`Retry ${name} has an invalid value.`);
+    }
+  }
+  return resolved;
+}
+function isCanceled(error) {
+  const candidate = error;
+  return candidate?.name === "CanceledError" || candidate?.name === "AbortError" || candidate?.code === "ERR_CANCELED";
+}
+function hasUnsafeBody(data) {
+  if (!data || typeof data !== "object") return false;
+  const candidate = data;
+  return typeof candidate.pipe === "function" || typeof candidate.getReader === "function" || candidate.locked === true;
+}
+async function shouldRetry(error, retry) {
+  const config = error.config;
+  if (!retry.enabled || !config || isCanceled(error)) return false;
+  const attempt = config.__retryCount ?? 0;
+  if (attempt >= retry.count) return false;
+  if (hasUnsafeBody(config.data) && !retry.retryUnsafeBody) return false;
+  const method = (config.method ?? "get").toUpperCase();
+  if (!retry.retryableMethods.some((item) => item.toUpperCase() === method)) return false;
+  if (retry.shouldRetry) return retry.shouldRetry(error, attempt + 1);
+  if (isNetworkError(error) || isTimeoutError(error)) return true;
+  return error.response?.status ? isRetryableStatus(error.response.status, retry.retryableStatusCodes) : false;
+}
+function retryAfterDelay(error) {
+  const raw = error.response?.headers?.["retry-after"];
+  if (raw == null) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const timestamp = Date.parse(String(raw));
+  return Number.isFinite(timestamp) ? Math.max(0, timestamp - Date.now()) : null;
+}
+function calculateDelay(error, attempt, retry) {
+  let calculated = retry.exponentialBackoff ? retry.delay * 2 ** (attempt - 1) : retry.delay;
+  if (retry.jitter) calculated = Math.round(calculated * (0.75 + Math.random() * 0.5));
+  if (retry.respectRetryAfter && [429, 503].includes(error.response?.status ?? 0)) {
+    calculated = Math.max(calculated, retryAfterDelay(error) ?? 0);
+  }
+  return Math.min(Math.max(0, calculated), retry.maxDelay);
+}
+function setupRetryPlugin(instance, runtime) {
+  instance.interceptors.response.use(void 0, async (error) => {
+    const config = error.config;
+    if (!config) return Promise.reject(error);
+    const retry = resolveRetryConfig(config, runtime);
+    if (!await shouldRetry(error, retry)) return Promise.reject(error);
+    const startedAt = config.__retryStartedAt ?? Date.now();
+    config.__retryStartedAt = startedAt;
+    const attempt = (config.__retryCount ?? 0) + 1;
+    const wait = calculateDelay(error, attempt, retry);
+    const elapsed = Date.now() - startedAt;
+    if (retry.maxElapsedMs > 0 && elapsed + wait > retry.maxElapsedMs) {
+      return Promise.reject(error);
+    }
+    config.__retryCount = attempt;
+    await retry.onRetry?.({ attempt, delay: wait, elapsed, error, config });
+    try {
+      await delay(wait, config.signal);
+    } catch (cause) {
+      return Promise.reject(
+        Object.assign(new Error("canceled"), {
+          name: "CanceledError",
+          code: "ERR_CANCELED",
+          config,
+          cause
+        })
+      );
+    }
+    const next = { ...config };
+    delete next.__cancelId;
+    delete next.__requestKey;
+    return instance.request(next);
+  });
+}
+
+// src/axios/plugins/index.ts
+function setupPlugins(instance, runtime) {
+  setupCachePlugin(instance, runtime);
+  setupCancelPlugin(instance, runtime);
+  setupDedupePlugin(instance, runtime);
+  setupRetryPlugin(instance, runtime);
+  setupResponsePlugin(instance);
+}
+
+// src/axios/service.ts
+function setGlobalAxiosInstance(instance) {
+  setDefaultAxiosInstance(instance);
+}
+function getGlobalAxiosInstance() {
+  const instance = getDefaultAxiosInstance();
+  if (!instance) {
+    throw new Error(
+      "Axios instance not initialized. Please call createRequestCore() or setGlobalAxiosInstance() first."
+    );
+  }
+  return instance;
+}
+new Proxy({}, {
+  get(_target, prop) {
+    return getGlobalAxiosInstance()[prop];
+  }
+});
+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 patchData(url, data, config) {
+  const response = await getGlobalAxiosInstance().patch(url, data, config);
+  return response.data;
+}
+async function deleteData(url, config) {
+  const response = await getGlobalAxiosInstance().delete(url, config);
+  return response.data;
+}
+function createAxiosInstance(config = {}, runtimeOptions = {}) {
+  const instance = axios2.create({
+    timeout: 5e3,
+    headers: { "Content-Type": "application/json" },
+    ...config
+  });
+  const runtime = createRequestRuntime(runtimeOptions);
+  attachRequestRuntime(instance, runtime);
+  setupPlugins(instance, runtime);
+  return instance;
+}
+var onReLoginSuccess = (instance) => {
+  resolveReLogin(instance);
+};
+var onReLoginCancel = (instance) => {
+  rejectReLogin(new Error("\u91CD\u65B0\u767B\u5F55\u5DF2\u53D6\u6D88"), instance);
+};
+
+// src/core.ts
+function getGlobalConfig() {
+  return getGlobalRuntimeConfig();
+}
+function createRequestCore(config = {}) {
+  const {
+    request = {},
+    interceptors = {},
+    successCodes,
+    fieldAliases,
+    defaults,
+    cacheStore
+  } = config;
+  setGlobalRuntimeConfig({ successCodes, fieldAliases });
+  const axiosInstance = createAxiosInstance(request, {
+    cache: cacheStore,
+    defaults
+  });
+  setGlobalAxiosInstance(axiosInstance);
+  if (interceptors.request || interceptors.requestError) {
+    axiosInstance.interceptors.request.use(
+      interceptors.request ?? ((requestConfig) => requestConfig),
+      interceptors.requestError
+    );
+  }
+  if (interceptors.response || interceptors.responseError) {
+    axiosInstance.interceptors.response.use(
+      interceptors.response ?? ((response) => response),
+      interceptors.responseError
+    );
+  }
+  return {
+    install(app) {
+      app.config.globalProperties.$axios = axiosInstance;
+    },
+    axiosInstance
+  };
+}
+var RequestError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "RequestError";
+    this.kind = options.kind;
+    this.code = options.code;
+    this.status = options.status;
+    this.data = options.data;
+    this.requestId = options.requestId;
+    this.retryable = options.retryable ?? false;
+    this.config = options.config;
+    this.cause = options.cause;
+  }
+};
+function isRequestError(error) {
+  return error instanceof RequestError;
+}
+function isCanceledError(error) {
+  return error instanceof RequestError && error.kind === "canceled" || axios2.isCancel(error) || error?.code === "ERR_CANCELED" || error?.name === "AbortError";
+}
+function normalizeRequestError(error) {
+  if (error instanceof RequestError) return error;
+  if (isCanceledError(error)) {
+    return new RequestError({
+      kind: "canceled",
+      message: "Request canceled.",
+      code: "ERR_CANCELED",
+      cause: error
+    });
+  }
+  if (axios2.isAxiosError(error)) {
+    const status = error.response?.status;
+    const timeout = error.code === "ECONNABORTED" || error.code === "ETIMEDOUT";
+    const kind = timeout ? "timeout" : status ? "http" : "network";
+    return new RequestError({
+      kind,
+      message: error.message || "Request failed.",
+      code: error.code,
+      status,
+      data: error.response?.data,
+      requestId: error.response?.headers?.["x-request-id"] ?? error.response?.headers?.["x-correlation-id"],
+      retryable: timeout || !status || status === 408 || status === 429 || status >= 500,
+      config: error.config,
+      cause: error
+    });
+  }
+  return new RequestError({
+    kind: "unknown",
+    message: error instanceof Error ? error.message : "Unknown request error.",
+    cause: error
+  });
+}
+
+export { MemoryCache, RequestError, cancelAllPendingRequests, cancelAllRequests, cancelRequestScope, cleanupExpiredCache, clearAllCache, clearCache, clearCacheByPrefix, clearCacheByTag, createAxiosInstance, createRequestCore, deleteData, generateRequestKey, getCacheSize, getCancelableRequestCount, getData, getGlobalAxiosInstance, getGlobalConfig, getPendingRequestCount, getReLoginPromise, getRequestRuntime, isCanceledError, isRequestError, normalizeRequestError, onReLoginCancel, onReLoginSuccess, patchData, postData, putData, setGlobalAxiosInstance, setGlobalRuntimeConfig, waitForReLogin };
+//# sourceMappingURL=chunk-OAZ5BUBU.js.map
+//# sourceMappingURL=chunk-OAZ5BUBU.js.map