@huangqi_an/request 0.0.0-stage → 0.1.0

package/dist/core.d.ts

@@ -0,0 +1,56 @@
+import { RequestAdapter, RequestConfig, RawResponse, RequestInterceptor, ResponseInterceptor, ErrorInterceptor, ChainableAdapter } from './index.js';
+
+interface CreateRequestOptions {
+    /** 必传：adapter 插件（axiosAdapter / fetchAdapter / uniappAdapter / 自定义 / 测试 mock） */
+    adapter: RequestAdapter;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+interface RequestInstance {
+    request<T = unknown>(config: RequestConfig): Promise<RawResponse<T>>;
+    get<T = unknown>(url: string, config?: Omit<RequestConfig, 'url' | 'method'>): Promise<RawResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<RawResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<RawResponse<T>>;
+    delete<T = unknown>(url: string, config?: Omit<RequestConfig, 'url' | 'method'>): Promise<RawResponse<T>>;
+    interceptors: {
+        request: {
+            use(interceptor: RequestInterceptor): void;
+        };
+        /** 成功链：转换 / 剥壳 */
+        response: {
+            use(interceptor: ResponseInterceptor): void;
+        };
+        /**
+         * 错误链：所有失败都会经过（请求拦截器抛错 / 网络失败 / 非 2xx / 响应链抛错）。
+         * 返回 RawResponse = 恢复；返回/抛出 RequestError = 替换；无返回值 = 放行（观察）。
+         */
+        error: {
+            use(interceptor: ErrorInterceptor): void;
+        };
+    };
+}
+/**
+ * 拼接 baseURL + url，并把 params 序列化为 query。
+ * - 绝对 URL 忽略 baseURL
+ * - 跳过 null / undefined；数组值序列化为重复 key（?id=1&id=2）
+ * - url 已带 ? 时用 & 追加
+ * params 统一在这里处理，保证两端一致，adapter 无需各自实现。
+ */
+declare function buildUrl(baseURL: string | undefined, url: string, params?: Record<string, unknown>): string;
+/**
+ * adapter 的显式扩展点：把任意（含第三方）adapter 变为可链式增强的 adapter，
+ * 同时为自定义 adapter 的实现函数提供参数类型推断。
+ *
+ * const myAdapter = defineAdapter(async (config) => {
+ *   // config.url 已是 core 拼好 params 的完整地址
+ *   // 返回 RawResponse；取消时抛 name='AbortError' 的错误
+ * }).use(withRetry()).use(withDedupe())   // 注册顺序 = 请求流经顺序
+ *
+ * 返回值本身仍是合法的 RequestAdapter，可直接传给 createRequest。
+ */
+declare function defineAdapter(adapter: RequestAdapter): ChainableAdapter;
+declare function createRequest(options: CreateRequestOptions): RequestInstance;
+
+export { buildUrl, createRequest, defineAdapter };
+export type { CreateRequestOptions, RequestInstance };

package/dist/core.js

@@ -0,0 +1,12 @@
+import {
+  buildUrl,
+  createRequest,
+  defineAdapter
+} from "./chunk-DQI4SM2Q.js";
+import "./chunk-Z4N22SLG.js";
+export {
+  buildUrl,
+  createRequest,
+  defineAdapter
+};
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/enhancers/dedupe.d.ts

@@ -0,0 +1,29 @@
+import { RequestConfig, AdapterEnhancer, RequestAdapter } from '../index.js';
+
+interface DedupeOptions {
+    /**
+     * 参与去重的方法，默认 ['GET', 'HEAD']（幂等）。
+     * 防双击提交等场景显式传入（如 methods: ['POST']），此时相同载荷的并发提交共享同一结果。
+     */
+    methods?: string[];
+    /**
+     * 去重键，默认 `${method} ${url} ${JSON.stringify(data)}`。
+     * params 已拼进 url，无需重复纳入；data 键序不同会被视为不同请求（宁可漏去重，不可错合并）。
+     */
+    key?: (config: RequestConfig) => string;
+}
+/**
+ * adapter 装饰器：进行中的相同请求共享同一个 Promise。
+ * - 默认只对幂等方法（GET/HEAD）生效，写方法默认放行
+ * - 请求 settle 后自动清理，不影响后续新请求
+ * - 共享的是同一个 RawResponse 对象；响应链拦截器用 {...res} 展开产生新对象，不会互相污染
+ *
+ * 两种形态：
+ * - withDedupe(adapter, options)：直接包装
+ * - withDedupe(options)：返回装饰器，交给 adapter.use() 组合
+ */
+declare function withDedupe(options?: DedupeOptions): AdapterEnhancer;
+declare function withDedupe(adapter: RequestAdapter, options?: DedupeOptions): RequestAdapter;
+
+export { withDedupe };
+export type { DedupeOptions };

package/dist/enhancers/dedupe.js

@@ -0,0 +1,37 @@
+// src/enhancers/dedupe.ts
+var SAFE_METHODS = ["GET", "HEAD"];
+function defaultKey(config) {
+  let dataKey = "";
+  if (config.data !== void 0) {
+    try {
+      dataKey = JSON.stringify(config.data);
+    } catch {
+      dataKey = `${Math.random()}`;
+    }
+  }
+  return `${config.method ?? "GET"} ${config.url} ${dataKey}`;
+}
+function withDedupe(first, maybeOptions) {
+  const options = first !== void 0 && typeof first !== "function" ? first : maybeOptions ?? {};
+  const decorate = (adapter) => {
+    const inFlight = /* @__PURE__ */ new Map();
+    const methods = options.methods ?? SAFE_METHODS;
+    const keyOf = options.key ?? defaultKey;
+    return (config) => {
+      if (!methods.includes(config.method ?? "GET")) return adapter(config);
+      const key = keyOf(config);
+      const pending = inFlight.get(key);
+      if (pending) return pending;
+      const promise = adapter(config).finally(() => {
+        inFlight.delete(key);
+      });
+      inFlight.set(key, promise);
+      return promise;
+    };
+  };
+  return typeof first === "function" ? decorate(first) : decorate;
+}
+export {
+  withDedupe
+};
+//# sourceMappingURL=dedupe.js.map

package/dist/enhancers/dedupe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/enhancers/dedupe.ts"],"sourcesContent":["import type { AdapterEnhancer, RawResponse, RequestAdapter, RequestConfig } from '../types'\n\n/**\n * 默认只去重幂等的安全方法。\n * 写方法（POST/PUT/DELETE）默认放行：去重的 share 语义不会\"多发\"，但会\"少发\"——\n * 对故意并发的非幂等请求（如计数 +1）静默合并等于丢操作。\n */\nconst SAFE_METHODS = ['GET', 'HEAD']\n\nfunction defaultKey(config: RequestConfig): string {\n  let dataKey = ''\n  if (config.data !== undefined) {\n    try {\n      dataKey = JSON.stringify(config.data)\n    } catch {\n      // 无法稳定序列化的 data 不参与去重：宁可漏去重，不可错合并\n      dataKey = `${Math.random()}`\n    }\n  }\n  return `${config.method ?? 'GET'} ${config.url} ${dataKey}`\n}\n\nexport interface DedupeOptions {\n  /**\n   * 参与去重的方法，默认 ['GET', 'HEAD']（幂等）。\n   * 防双击提交等场景显式传入（如 methods: ['POST']），此时相同载荷的并发提交共享同一结果。\n   */\n  methods?: string[]\n  /**\n   * 去重键，默认 `${method} ${url} ${JSON.stringify(data)}`。\n   * params 已拼进 url，无需重复纳入；data 键序不同会被视为不同请求（宁可漏去重，不可错合并）。\n   */\n  key?: (config: RequestConfig) => string\n}\n\n/**\n * adapter 装饰器：进行中的相同请求共享同一个 Promise。\n * - 默认只对幂等方法（GET/HEAD）生效，写方法默认放行\n * - 请求 settle 后自动清理，不影响后续新请求\n * - 共享的是同一个 RawResponse 对象；响应链拦截器用 {...res} 展开产生新对象，不会互相污染\n *\n * 两种形态：\n * - withDedupe(adapter, options)：直接包装\n * - withDedupe(options)：返回装饰器，交给 adapter.use() 组合\n */\nexport function withDedupe(options?: DedupeOptions): AdapterEnhancer\nexport function withDedupe(adapter: RequestAdapter, options?: DedupeOptions): RequestAdapter\nexport function withDedupe(\n  first?: RequestAdapter | DedupeOptions,\n  maybeOptions?: DedupeOptions,\n): RequestAdapter | AdapterEnhancer {\n  const options: DedupeOptions =\n    first !== undefined && typeof first !== 'function' ? first : (maybeOptions ?? {})\n\n  const decorate = (adapter: RequestAdapter): RequestAdapter => {\n    const inFlight = new Map<string, Promise<RawResponse>>()\n    const methods = options.methods ?? SAFE_METHODS\n    const keyOf = options.key ?? defaultKey\n\n    return (config) => {\n      // 非幂等方法直接放行，不参与去重\n      if (!methods.includes(config.method ?? 'GET')) return adapter(config)\n\n      const key = keyOf(config)\n      const pending = inFlight.get(key)\n      if (pending) return pending\n\n      const promise = adapter(config).finally(() => {\n        inFlight.delete(key)\n      })\n      inFlight.set(key, promise)\n      return promise\n    }\n  }\n\n  return typeof first === 'function' ? decorate(first) : decorate\n}\n"],"mappings":";AAOA,IAAM,eAAe,CAAC,OAAO,MAAM;AAEnC,SAAS,WAAW,QAA+B;AACjD,MAAI,UAAU;AACd,MAAI,OAAO,SAAS,QAAW;AAC7B,QAAI;AACF,gBAAU,KAAK,UAAU,OAAO,IAAI;AAAA,IACtC,QAAQ;AAEN,gBAAU,GAAG,KAAK,OAAO,CAAC;AAAA,IAC5B;AAAA,EACF;AACA,SAAO,GAAG,OAAO,UAAU,KAAK,IAAI,OAAO,GAAG,IAAI,OAAO;AAC3D;AA2BO,SAAS,WACd,OACA,cACkC;AAClC,QAAM,UACJ,UAAU,UAAa,OAAO,UAAU,aAAa,QAAS,gBAAgB,CAAC;AAEjF,QAAM,WAAW,CAAC,YAA4C;AAC5D,UAAM,WAAW,oBAAI,IAAkC;AACvD,UAAM,UAAU,QAAQ,WAAW;AACnC,UAAM,QAAQ,QAAQ,OAAO;AAE7B,WAAO,CAAC,WAAW;AAEjB,UAAI,CAAC,QAAQ,SAAS,OAAO,UAAU,KAAK,EAAG,QAAO,QAAQ,MAAM;AAEpE,YAAM,MAAM,MAAM,MAAM;AACxB,YAAM,UAAU,SAAS,IAAI,GAAG;AAChC,UAAI,QAAS,QAAO;AAEpB,YAAM,UAAU,QAAQ,MAAM,EAAE,QAAQ,MAAM;AAC5C,iBAAS,OAAO,GAAG;AAAA,MACrB,CAAC;AACD,eAAS,IAAI,KAAK,OAAO;AACzB,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO,OAAO,UAAU,aAAa,SAAS,KAAK,IAAI;AACzD;","names":[]}

package/dist/enhancers/retry.d.ts

@@ -0,0 +1,38 @@
+import { RawResponse, RequestConfig, AdapterEnhancer, RequestAdapter } from '../index.js';
+
+interface RetryFailure {
+    /** adapter 抛出的错误（取消为 name='AbortError'） */
+    error?: unknown;
+    /** adapter 返回的非 2xx 响应 */
+    response?: RawResponse;
+}
+interface RetryOptions {
+    /** 最大重试次数（不含首次），默认 2 */
+    retries?: number;
+    /**
+     * 默认重试规则覆盖的方法，默认 ['GET', 'HEAD']（幂等）。
+     * 只约束默认规则；提供 shouldRetry 后完全由 shouldRetry 决定。
+     */
+    methods?: string[];
+    /**
+     * 自定义是否重试，提供后完全接管默认规则（methods 不再生效）。
+     * 默认：抛错且方法幂等 → 重试；非 2xx 响应 / 取消 → 不重试。
+     * 需要对写方法重试时自行判断（如请求已带幂等键 Idempotency-Key）。
+     */
+    shouldRetry?: (failure: RetryFailure, attempt: number, config: RequestConfig) => boolean;
+    /** 第 attempt 次重试前的等待毫秒，默认不等待 */
+    delayMs?: (attempt: number) => number;
+}
+/**
+ * adapter 装饰器：失败自动重试（不引 core，可与任何 adapter 组合）。
+ * 与错误链恢复不同：重试成功的响应会正常走完整 core 管道（响应链剥壳等）。
+ *
+ * 两种形态：
+ * - withRetry(adapter, options)：直接包装
+ * - withRetry(options)：返回装饰器，交给 adapter.use() 组合
+ */
+declare function withRetry(options?: RetryOptions): AdapterEnhancer;
+declare function withRetry(adapter: RequestAdapter, options?: RetryOptions): RequestAdapter;
+
+export { withRetry };
+export type { RetryFailure, RetryOptions };

package/dist/enhancers/retry.js

@@ -0,0 +1,47 @@
+import {
+  isAbortError
+} from "../chunk-Z4N22SLG.js";
+
+// src/enhancers/retry.ts
+var SAFE_METHODS = ["GET", "HEAD"];
+function withRetry(first, maybeOptions) {
+  const options = first !== void 0 && typeof first !== "function" ? first : maybeOptions ?? {};
+  const decorate = (adapter) => {
+    const { retries = 2, shouldRetry, delayMs } = options;
+    const methods = options.methods ?? SAFE_METHODS;
+    const defaultShouldRetry = (failure, _attempt, config) => failure.error !== void 0 && methods.includes(config.method ?? "GET");
+    const decideRetry = shouldRetry ?? defaultShouldRetry;
+    return async (config) => {
+      let attempt = 0;
+      for (; ; ) {
+        let failure;
+        try {
+          const res = await adapter(config);
+          if (res.status >= 200 && res.status < 300) return res;
+          failure = { response: res };
+        } catch (error) {
+          if (isAbortError(error)) throw error;
+          failure = { error };
+        }
+        const giveUp = () => {
+          if (failure.error !== void 0) throw failure.error;
+          return failure.response;
+        };
+        if (attempt >= retries) return giveUp();
+        if (!decideRetry(failure, attempt + 1, config)) {
+          return giveUp();
+        }
+        attempt++;
+        const delay = delayMs?.(attempt);
+        if (delay && delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    };
+  };
+  return typeof first === "function" ? decorate(first) : decorate;
+}
+export {
+  withRetry
+};
+//# sourceMappingURL=retry.js.map

package/dist/enhancers/retry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/enhancers/retry.ts"],"sourcesContent":["import { isAbortError } from '../errors'\nimport type { AdapterEnhancer, RawResponse, RequestAdapter, RequestConfig } from '../types'\n\n/**\n * 默认只重试幂等的安全方法。\n * 写方法（POST/PUT/DELETE）默认不重试：网络错误可能是\"请求已到达服务端但响应丢失\"，\n * 自动重发会重复执行非幂等操作（如重复扣款）。\n */\nconst SAFE_METHODS = ['GET', 'HEAD']\n\nexport interface RetryFailure {\n  /** adapter 抛出的错误（取消为 name='AbortError'） */\n  error?: unknown\n  /** adapter 返回的非 2xx 响应 */\n  response?: RawResponse\n}\n\nexport interface RetryOptions {\n  /** 最大重试次数（不含首次），默认 2 */\n  retries?: number\n  /**\n   * 默认重试规则覆盖的方法，默认 ['GET', 'HEAD']（幂等）。\n   * 只约束默认规则；提供 shouldRetry 后完全由 shouldRetry 决定。\n   */\n  methods?: string[]\n  /**\n   * 自定义是否重试，提供后完全接管默认规则（methods 不再生效）。\n   * 默认：抛错且方法幂等 → 重试；非 2xx 响应 / 取消 → 不重试。\n   * 需要对写方法重试时自行判断（如请求已带幂等键 Idempotency-Key）。\n   */\n  shouldRetry?: (\n    failure: RetryFailure,\n    attempt: number,\n    config: RequestConfig,\n  ) => boolean\n  /** 第 attempt 次重试前的等待毫秒，默认不等待 */\n  delayMs?: (attempt: number) => number\n}\n\n/**\n * adapter 装饰器：失败自动重试（不引 core，可与任何 adapter 组合）。\n * 与错误链恢复不同：重试成功的响应会正常走完整 core 管道（响应链剥壳等）。\n *\n * 两种形态：\n * - withRetry(adapter, options)：直接包装\n * - withRetry(options)：返回装饰器，交给 adapter.use() 组合\n */\nexport function withRetry(options?: RetryOptions): AdapterEnhancer\nexport function withRetry(adapter: RequestAdapter, options?: RetryOptions): RequestAdapter\nexport function withRetry(\n  first?: RequestAdapter | RetryOptions,\n  maybeOptions?: RetryOptions,\n): RequestAdapter | AdapterEnhancer {\n  const options: RetryOptions =\n    first !== undefined && typeof first !== 'function' ? first : (maybeOptions ?? {})\n\n  const decorate = (adapter: RequestAdapter): RequestAdapter => {\n    const { retries = 2, shouldRetry, delayMs } = options\n    const methods = options.methods ?? SAFE_METHODS\n    const defaultShouldRetry = (failure: RetryFailure, _attempt: number, config: RequestConfig) =>\n      failure.error !== undefined && methods.includes(config.method ?? 'GET')\n    const decideRetry: (\n      failure: RetryFailure,\n      attempt: number,\n      config: RequestConfig,\n    ) => boolean = shouldRetry ?? defaultShouldRetry\n\n    return async (config) => {\n      let attempt = 0\n      for (;;) {\n        let failure: RetryFailure\n        try {\n          const res = await adapter(config)\n          if (res.status >= 200 && res.status < 300) return res\n          failure = { response: res }\n        } catch (error) {\n          // 取消语义永不重试\n          if (isAbortError(error)) throw error\n          failure = { error }\n        }\n\n        const giveUp = () => {\n          if (failure.error !== undefined) throw failure.error\n          return failure.response as RawResponse\n        }\n        if (attempt >= retries) return giveUp()\n        if (!decideRetry(failure, attempt + 1, config)) {\n          return giveUp()\n        }\n\n        attempt++\n        const delay = delayMs?.(attempt)\n        if (delay && delay > 0) {\n          await new Promise((resolve) => setTimeout(resolve, delay))\n        }\n      }\n    }\n  }\n\n  return typeof first === 'function' ? decorate(first) : decorate\n}\n"],"mappings":";;;;;AAQA,IAAM,eAAe,CAAC,OAAO,MAAM;AAyC5B,SAAS,UACd,OACA,cACkC;AAClC,QAAM,UACJ,UAAU,UAAa,OAAO,UAAU,aAAa,QAAS,gBAAgB,CAAC;AAEjF,QAAM,WAAW,CAAC,YAA4C;AAC5D,UAAM,EAAE,UAAU,GAAG,aAAa,QAAQ,IAAI;AAC9C,UAAM,UAAU,QAAQ,WAAW;AACnC,UAAM,qBAAqB,CAAC,SAAuB,UAAkB,WACnE,QAAQ,UAAU,UAAa,QAAQ,SAAS,OAAO,UAAU,KAAK;AACxE,UAAM,cAIS,eAAe;AAE9B,WAAO,OAAO,WAAW;AACvB,UAAI,UAAU;AACd,iBAAS;AACP,YAAI;AACJ,YAAI;AACF,gBAAM,MAAM,MAAM,QAAQ,MAAM;AAChC,cAAI,IAAI,UAAU,OAAO,IAAI,SAAS,IAAK,QAAO;AAClD,oBAAU,EAAE,UAAU,IAAI;AAAA,QAC5B,SAAS,OAAO;AAEd,cAAI,aAAa,KAAK,EAAG,OAAM;AAC/B,oBAAU,EAAE,MAAM;AAAA,QACpB;AAEA,cAAM,SAAS,MAAM;AACnB,cAAI,QAAQ,UAAU,OAAW,OAAM,QAAQ;AAC/C,iBAAO,QAAQ;AAAA,QACjB;AACA,YAAI,WAAW,QAAS,QAAO,OAAO;AACtC,YAAI,CAAC,YAAY,SAAS,UAAU,GAAG,MAAM,GAAG;AAC9C,iBAAO,OAAO;AAAA,QAChB;AAEA;AACA,cAAM,QAAQ,UAAU,OAAO;AAC/B,YAAI,SAAS,QAAQ,GAAG;AACtB,gBAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,KAAK,CAAC;AAAA,QAC3D;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,OAAO,UAAU,aAAa,SAAS,KAAK,IAAI;AACzD;","names":[]}

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export { f as RequestError, g as RequestErrorKind, h as RequestErrorOptions, l as createAbortError, m as isAbortError } from './types-CoJSp-ar.js';

package/dist/errors.js

@@ -0,0 +1,11 @@
+import {
+  RequestError,
+  createAbortError,
+  isAbortError
+} from "./chunk-Z4N22SLG.js";
+export {
+  RequestError,
+  createAbortError,
+  isAbortError
+};
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { A as AdapterEnhancer, e as AdapterOptions, C as ChainableAdapter, E as ErrorInterceptor, b as RawResponse, a as RequestAdapter, R as RequestConfig, f as RequestError, g as RequestErrorKind, h as RequestErrorOptions, i as RequestEvents, c as RequestInterceptor, j as RequestMethod, k as RequestProgress, d as ResponseInterceptor, l as createAbortError, m as isAbortError } from './types-CoJSp-ar.js';
+export { CreateRequestOptions, RequestInstance, buildUrl, createRequest, defineAdapter } from './core.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+import {
+  buildUrl,
+  createRequest,
+  defineAdapter
+} from "./chunk-DQI4SM2Q.js";
+import {
+  RequestError,
+  createAbortError,
+  isAbortError
+} from "./chunk-Z4N22SLG.js";
+export {
+  RequestError,
+  buildUrl,
+  createAbortError,
+  createRequest,
+  defineAdapter,
+  isAbortError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/interceptors/auth.d.ts

@@ -0,0 +1,17 @@
+import { RequestConfig, RequestInterceptor } from '../index.js';
+
+interface AuthInterceptorOptions {
+    /** 取 token；支持异步（如先静默刷新）。返回空值则跳过注入 */
+    getToken: () => string | undefined | null | Promise<string | undefined | null>;
+    /** 注入的头名，默认 'Authorization' */
+    headerName?: string;
+    /** token 前缀，默认 'Bearer '；不需要前缀传空字符串 */
+    scheme?: string;
+    /** 返回 false 的请求不注入（如登录接口本身） */
+    shouldAttach?: (config: RequestConfig) => boolean;
+}
+/** 请求链拦截器：从 getToken() 注入凭证头 */
+declare function createAuthInterceptor(options: AuthInterceptorOptions): RequestInterceptor;
+
+export { createAuthInterceptor };
+export type { AuthInterceptorOptions };

package/dist/interceptors/auth.js

@@ -0,0 +1,7 @@
+import {
+  createAuthInterceptor
+} from "../chunk-FY6YU3PV.js";
+export {
+  createAuthInterceptor
+};
+//# sourceMappingURL=auth.js.map

package/dist/interceptors/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/interceptors/index.d.ts

@@ -0,0 +1,5 @@
+export { AuthInterceptorOptions, createAuthInterceptor } from './auth.js';
+export { UnwrapInterceptorOptions, createUnwrapInterceptor } from './unwrap.js';
+export { LogFn, LogLevel, LoggerInterceptorsOptions, createLoggerInterceptors } from './logger.js';
+export { RequestIdInterceptorOptions, createRequestIdInterceptor } from './request-id.js';
+import '../types-CoJSp-ar.js';

package/dist/interceptors/index.js

@@ -0,0 +1,20 @@
+import {
+  createAuthInterceptor
+} from "../chunk-FY6YU3PV.js";
+import {
+  createLoggerInterceptors
+} from "../chunk-KLAI63DX.js";
+import {
+  createRequestIdInterceptor
+} from "../chunk-UCTOFBDY.js";
+import {
+  createUnwrapInterceptor
+} from "../chunk-OV6LXQTN.js";
+import "../chunk-Z4N22SLG.js";
+export {
+  createAuthInterceptor,
+  createLoggerInterceptors,
+  createRequestIdInterceptor,
+  createUnwrapInterceptor
+};
+//# sourceMappingURL=index.js.map

package/dist/interceptors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/interceptors/logger.d.ts

@@ -0,0 +1,25 @@
+import { RequestInterceptor, ResponseInterceptor, ErrorInterceptor } from '../index.js';
+
+type LogLevel = 'debug' | 'warn';
+type LogFn = (level: LogLevel, ...args: unknown[]) => void;
+interface LoggerInterceptorsOptions {
+    /**
+     * 自定义日志函数（如接埋点 SDK）。注意：不应抛错——
+     * request/response 链中抛错会进入错误链，error 链中抛错会替换原错误。
+     */
+    log?: LogFn;
+}
+/**
+ * 三链日志：返回 request / response / error 三件套，分别注册到对应链。
+ * - request：method / url / params
+ * - response：status / 耗时 / url（读 core 注入的 res.durationMs 与 res.config）
+ * - error：kind / message / url（读 err.config）
+ */
+declare function createLoggerInterceptors(options?: LoggerInterceptorsOptions): {
+    request: RequestInterceptor;
+    response: ResponseInterceptor;
+    error: ErrorInterceptor;
+};
+
+export { createLoggerInterceptors };
+export type { LogFn, LogLevel, LoggerInterceptorsOptions };

package/dist/interceptors/logger.js

@@ -0,0 +1,7 @@
+import {
+  createLoggerInterceptors
+} from "../chunk-KLAI63DX.js";
+export {
+  createLoggerInterceptors
+};
+//# sourceMappingURL=logger.js.map

package/dist/interceptors/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/interceptors/request-id.d.ts

@@ -0,0 +1,23 @@
+import { RequestInterceptor } from '../index.js';
+
+interface RequestIdInterceptorOptions {
+    /** 请求头名，默认 'X-Request-Id' */
+    headerName?: string;
+    /** 自定义 ID 生成器（如接入 tracing/Sentry 等链路库） */
+    generateId?: () => string;
+    /**
+     * 请求已携带该头时不覆盖（用于上游链路 ID 透传），默认 false。
+     * 注意：实例级默认头也算"已携带"，开启后会导致所有请求共用一个 ID，慎用。
+     */
+    keepExisting?: boolean;
+}
+/**
+ * 请求链拦截器：为每个请求生成唯一 ID 注入请求头，用于前后端日志关联与报障定位。
+ * - core 会把最终 config 盖章到 RawResponse.config 与 RequestError.config，
+ *   因此响应链日志、错误上报都能取到同一个 ID
+ * - 重试共享同一 config：同一次逻辑请求（含重试）带同一个 ID，服务端可识别重发
+ */
+declare function createRequestIdInterceptor(options?: RequestIdInterceptorOptions): RequestInterceptor;
+
+export { createRequestIdInterceptor };
+export type { RequestIdInterceptorOptions };

package/dist/interceptors/request-id.js

@@ -0,0 +1,7 @@
+import {
+  createRequestIdInterceptor
+} from "../chunk-UCTOFBDY.js";
+export {
+  createRequestIdInterceptor
+};
+//# sourceMappingURL=request-id.js.map

package/dist/interceptors/request-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/interceptors/unwrap.d.ts

@@ -0,0 +1,22 @@
+import { ResponseInterceptor } from '../index.js';
+
+interface UnwrapInterceptorOptions {
+    /** 业务成功码（后端常见字符串码，允许 string | number），默认 [0] */
+    successCodes?: Array<string | number>;
+    /** 业务码字段名，默认 'code' */
+    codeKey?: string;
+    /** 业务数据字段名，默认 'data' */
+    dataKey?: string;
+    /** 业务消息字段名，默认 'message' */
+    messageKey?: string;
+}
+/**
+ * 响应链拦截器：剥离 {code, data, message} 业务壳。
+ * - body 非对象或缺 codeKey：视为非业务壳响应，原样放行（防御非 JSON 响应）
+ * - 业务成功：res.data 替换为业务 data
+ * - 业务失败：抛 RequestError(kind='business')，进入错误链
+ */
+declare function createUnwrapInterceptor(options?: UnwrapInterceptorOptions): ResponseInterceptor;
+
+export { createUnwrapInterceptor };
+export type { UnwrapInterceptorOptions };

package/dist/interceptors/unwrap.js

@@ -0,0 +1,8 @@
+import {
+  createUnwrapInterceptor
+} from "../chunk-OV6LXQTN.js";
+import "../chunk-Z4N22SLG.js";
+export {
+  createUnwrapInterceptor
+};
+//# sourceMappingURL=unwrap.js.map

package/dist/interceptors/unwrap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types-CoJSp-ar.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 统一错误四分类：
+ * - http：收到响应但状态码非 2xx（业务层面最常处理的一类）
+ * - business：HTTP 2xx 但业务码失败（由内置 unwrap 拦截器产生）
+ * - abort：请求被取消（AbortSignal 或平台取消语义）
+ * - network：传输层失败，含超时；通过 raw 可拿到原始错误（axios 的 error.code / uni 的 errMsg）
+ */
+type RequestErrorKind = 'abort' | 'http' | 'business' | 'network';
+interface RequestErrorOptions {
+    status?: number;
+    data?: unknown;
+    headers?: Record<string, string>;
+    config?: RequestConfig;
+    /** 原始错误：axios error / uni fail 回调的 err，便于排查 */
+    raw?: unknown;
+}
+declare class RequestError extends Error {
+    readonly kind: RequestErrorKind;
+    readonly status?: number;
+    readonly data?: unknown;
+    readonly headers?: Record<string, string>;
+    readonly config?: RequestConfig;
+    readonly raw?: unknown;
+    constructor(kind: RequestErrorKind, message: string, options?: RequestErrorOptions);
+}
+/**
+ * 生成统一形态的 AbortError。
+ * 不用 DOMException：小程序运行时没有 DOMException，
+ * Error + name='AbortError' 与 `e.name === 'AbortError'` 的通用判定方式兼容。
+ */
+declare function createAbortError(message?: string): Error;
+/** 是否为取消错误（兼容原生 DOMException/AbortController 与本库生成的） */
+declare function isAbortError(error: unknown): boolean;
+
+/** 统一的请求方法，axios 与 uni.request 均可表达 */
+type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/**
+ * 请求事件集合：adapter 在支持的平台能力上触发。
+ * 扩展策略：新增事件只加这里的可选成员（并在对应 adapter 中 emit），
+ * RequestConfig 结构保持封闭——不再往根上加回调字段。
+ */
+interface RequestEvents {
+    /** 上传进度（字节数）；axios/uniapp 支持，fetch 平台不支持（README 有能力矩阵） */
+    uploadProgress?: (progress: RequestProgress) => void;
+    /** 下载进度（字节数）；fetch 走流式读取，Content-Length 缺失时 total/progress 为 undefined */
+    downloadProgress?: (progress: RequestProgress) => void;
+}
+/**
+ * adapter 专有配置透传袋：按 adapter 名取用，仅对应 adapter 消费，其它 adapter 忽略。
+ * 这是平台特有能力的统一逃生舱（如 axios 的 adapter/responseType、fetch 的 credentials/cache、
+ * uni.request 的 enableHttp2）——RequestConfig 保持平台无关，特有参数走这里，不往根上加字段。
+ *
+ * 冲突规则：契约派生字段（url/method/headers/timeout/signal/validateStatus 等）
+ * 以 RequestConfig 为准，透传项覆盖不了它们——统一语义不被破坏。
+ */
+interface AdapterOptions {
+    /** axiosAdapter 透传给 axios.request 的额外配置（axios 专有类型见 axios 官方文档） */
+    axios?: Record<string, unknown>;
+    /** uniappAdapter 透传给 uni.request 的额外配置 */
+    uniapp?: Record<string, unknown>;
+    /** fetchAdapter 透传给 fetch() 的额外配置（credentials / cache / redirect 等） */
+    fetch?: Record<string, unknown>;
+    /** 自定义 adapter 可按自己的名字扩展（结构由该 adapter 决定） */
+    [adapter: string]: Record<string, unknown> | undefined;
+}
+/**
+ * 平台无关的请求配置，adapter 的唯一输入。
+ * 注意：adapter 拿到的 url 已经是 core 拼好 params 的完整地址。
+ */
+interface RequestConfig {
+    url: string;
+    method?: RequestMethod;
+    baseURL?: string;
+    /** query 参数，由 core 统一序列化后拼进 url，adapter 无需感知 */
+    params?: Record<string, unknown>;
+    data?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+    /** 事件订阅（唯一的扩展点：新增事件只扩展 RequestEvents，不改 RequestConfig） */
+    on?: RequestEvents;
+    /** adapter 专有配置透传（见 AdapterOptions） */
+    adapterOptions?: AdapterOptions;
+}
+/**
+ * 平台无关的原始响应，adapter 的唯一输出。不做任何业务判断（含状态码）。
+ * durationMs 与 config 由 core 统一注入（adapter 无需填写）。
+ */
+interface RawResponse<T = unknown> {
+    status: number;
+    data: T;
+    headers: Record<string, string>;
+    /** adapter 调用耗时（毫秒），core 注入；供日志/性能监控使用 */
+    durationMs?: number;
+    /** 发起请求的最终配置（url 已拼好 params），core 注入；供响应链做条件逻辑 */
+    config?: RequestConfig;
+}
+/** 进度事件：loaded/total 为字节数，progress 为 0-1（total 未知时为 undefined） */
+interface RequestProgress {
+    loaded: number;
+    /** 总字节数；服务端未返回长度（chunked 等）时为 undefined */
+    total?: number;
+    /** 0-1；total 未知时为 undefined */
+    progress?: number;
+}
+/**
+ * adapter 契约：发请求、返回原始结果、翻译取消语义。
+ * 状态码判断、错误归一化、拦截器全部由 core 负责，adapter 保持"哑"。
+ */
+type RequestAdapter = (config: RequestConfig) => Promise<RawResponse>;
+/** adapter 装饰器：输入 adapter，输出增强后的 adapter（retry/dedupe 以该形态参与 .use 组合） */
+type AdapterEnhancer = (adapter: RequestAdapter) => RequestAdapter;
+/**
+ * 可链式增强的 adapter：本身可直接当 RequestAdapter 用，同时提供 .use 叠加装饰器。
+ * 注册顺序 = 请求流经顺序（与拦截器链一致）：adapter.use(a).use(b) 时请求依次经过 a → b → adapter。
+ */
+interface ChainableAdapter extends RequestAdapter {
+    /** 在外层叠加一个装饰器，返回新的链式 adapter（原 adapter 不被修改） */
+    use: (enhancer: AdapterEnhancer) => ChainableAdapter;
+}
+/** 请求拦截器：返回新 config（可异步） */
+type RequestInterceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
+/** 响应拦截器（成功链）：转换 / 剥壳 */
+type ResponseInterceptor = (res: RawResponse) => RawResponse | Promise<RawResponse>;
+/**
+ * 错误拦截器：所有失败都会按注册顺序经过——
+ * 请求拦截器抛错 / 网络失败（含超时）/ 非 2xx / 响应成功链抛错。
+ *
+ * - 返回 RawResponse → 恢复：结束错误链，直接作为最终结果（后续错误拦截器不再执行）
+ * - 返回 RequestError → 用它替换当前错误，继续错误链
+ * - 无返回值（undefined）→ 放行：适合纯观察（上报 / toast / 401 跳转）
+ * - 抛错 → 视为替换错误，继续错误链
+ */
+type ErrorInterceptor = (error: RequestError) => RawResponse | RequestError | void | Promise<RawResponse | RequestError | void>;
+
+export { RequestError as f, createAbortError as l, isAbortError as m };
+export type { AdapterEnhancer as A, ChainableAdapter as C, ErrorInterceptor as E, RequestConfig as R, RequestAdapter as a, RawResponse as b, RequestInterceptor as c, ResponseInterceptor as d, AdapterOptions as e, RequestErrorKind as g, RequestErrorOptions as h, RequestEvents as i, RequestMethod as j, RequestProgress as k };