@ahoo-wang/fetcher 0.6.8 → 0.6.9

package/dist/interceptor.d.ts

@@ -1,73 +1,288 @@
 import { Fetcher, FetcherRequest } from './fetcher';
 import { NamedCapable } from './types';
 import { OrderedCapable } from './orderedCapable';
+/**
+ * FetchExchange Interface
+ *
+ * Represents the complete exchange object that flows through the interceptor chain.
+ * This object contains all the information about a request, response, and any errors
+ * that occur during the HTTP request lifecycle. It also provides a mechanism for
+ * sharing data between interceptors through the attributes property.
+ *
+ * @example
+ * ```typescript
+ * // In a request interceptor
+ * const requestInterceptor: Interceptor = {
+ *   name: 'RequestInterceptor',
+ *   order: 0,
+ *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
+ *     // Add custom data to share with other interceptors
+ *     exchange.attributes = exchange.attributes || {};
+ *     exchange.attributes.startTime = Date.now();
+ *     exchange.attributes.customHeader = 'my-value';
+ *     return exchange;
+ *   }
+ * };
+ *
+ * // In a response interceptor
+ * const responseInterceptor: Interceptor = {
+ *   name: 'ResponseInterceptor',
+ *   order: 0,
+ *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
+ *     // Access data shared by previous interceptors
+ *     if (exchange.attributes && exchange.attributes.startTime) {
+ *       const startTime = exchange.attributes.startTime;
+ *       const duration = Date.now() - startTime;
+ *       console.log(`Request took ${duration}ms`);
+ *     }
+ *     return exchange;
+ *   }
+ * };
+ * ```
+ */
 export interface FetchExchange {
+    /**
+     * The Fetcher instance that initiated this exchange
+     */
     fetcher: Fetcher;
+    /**
+     * The URL for this request
+     */
     url: string;
+    /**
+     * The request configuration including method, headers, body, etc.
+     */
     request: FetcherRequest;
+    /**
+     * The response object, undefined until the request completes successfully
+     */
     response: Response | undefined;
+    /**
+     * Any error that occurred during the request processing, undefined if no error occurred
+     */
     error: Error | any | undefined;
+    /**
+     * Shared attributes for passing data between interceptors
+     *
+     * This property allows interceptors to share arbitrary data with each other.
+     * Interceptors can read from and write to this object to pass information
+     * along the interceptor chain.
+     *
+     * @remarks
+     * - This property is optional and may be undefined initially
+     * - Interceptors should initialize this property if they need to use it
+     * - Use string keys to avoid conflicts between different interceptors
+     * - Consider namespacing your keys (e.g., 'mylib.retryCount' instead of 'retryCount')
+     * - Be mindful of memory usage when storing large objects
+     */
+    attributes?: Record<string, any>;
 }
 /**
- * 拦截器接口，定义了拦截器的基本结构
- * @template T - 拦截器处理的数据类型
+ * Interceptor Interface
+ *
+ * Defines the basic structure of an interceptor. Interceptors are used to process
+ * requests, responses, or errors at different stages of the HTTP request lifecycle.
+ *
+ * @remarks
+ * Interceptors follow the Chain of Responsibility pattern, where each interceptor
+ * can modify the exchange object and pass it to the next interceptor in the chain.
+ *
+ * @example
+ * // Example of a custom request interceptor
+ * const loggingInterceptor: Interceptor = {
+ *   name: 'LoggingInterceptor',
+ *   order: 0,
+ *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
+ *     console.log(`Making request to ${exchange.url}`);
+ *     const result = await next.intercept(exchange);
+ *     console.log(`Received response with status ${result.response?.status}`);
+ *     return result;
+ *   }
+ * };
  */
 export interface Interceptor extends NamedCapable, OrderedCapable {
     /**
-     * 拦截器的名称,用于标识拦截器，不可重复
+     * Interceptor name, used to identify the interceptor and must be unique
+     *
+     * @remarks
+     * The name is used by the InterceptorManager to manage interceptors,
+     * including adding, removing, and preventing duplicates.
      */
     name: string;
     /**
-     * 拦截并处理数据
-     * @param exchange - 需要处理的数据
-     * @returns 处理后的数据，可以是同步或异步返回
+     * Intercept and process data
+     *
+     * This method is called by the InterceptorManager to process the exchange object.
+     * The interceptor can modify the request, response, or error properties of the
+     * exchange object and then pass it to the next interceptor in the chain.
+     *
+     * @param exchange - The data to be processed, containing request, response, and error information
+     * @returns The processed data, which can be returned synchronously or asynchronously
+     *
+     * @remarks
+     * Interceptors should either return the exchange object (possibly modified) or
+     * a new exchange object. They can also throw errors or transform errors into responses.
      */
     intercept(exchange: FetchExchange): FetchExchange | Promise<FetchExchange>;
 }
 /**
- * 拦截器管理器类，用于管理同一类型的多个拦截器
+ * InterceptorManager Class
+ *
+ * Manages multiple interceptors of the same type. Responsible for adding, removing,
+ * and executing interceptors in the correct order. Each InterceptorManager instance
+ * handles one type of interceptor (request, response, or error).
+ *
+ * @remarks
+ * Interceptors are executed in ascending order of their `order` property.
+ * Interceptors with the same order value are executed in the order they were added.
+ *
+ * @example
+ * // Create an interceptor manager with initial interceptors
+ * const requestManager = new InterceptorManager([interceptor1, interceptor2]);
+ *
+ * // Add a new interceptor
+ * requestManager.use(newInterceptor);
+ *
+ * // Remove an interceptor by name
+ * requestManager.eject('InterceptorName');
+ *
+ * // Process an exchange through all interceptors
+ * const result = await requestManager.intercept(exchange);
  */
 export declare class InterceptorManager implements Interceptor {
+    /**
+     * Gets the name of this interceptor manager
+     *
+     * @returns The constructor name of this class
+     */
     get name(): string;
+    /**
+     * Gets the order of this interceptor manager
+     *
+     * @returns Number.MIN_SAFE_INTEGER, indicating this manager should execute early
+     */
     get order(): number;
+    /**
+     * Array of interceptors managed by this manager, sorted by their order property
+     */
     private sortedInterceptors;
+    /**
+     * Creates a new InterceptorManager instance
+     *
+     * @param interceptors - Initial array of interceptors to manage
+     *
+     * @remarks
+     * The provided interceptors will be sorted by their order property immediately
+     * upon construction.
+     */
     constructor(interceptors?: Interceptor[]);
     /**
-     * 添加拦截器到管理器中
-     * @param interceptor - 要添加的拦截器
-     * @returns 拦截器在管理器中的索引位置
+     * Adds an interceptor to this manager
+     *
+     * @param interceptor - The interceptor to add
+     * @returns True if the interceptor was added, false if an interceptor with the
+     *          same name already exists
+     *
+     * @remarks
+     * Interceptors are uniquely identified by their name property. Attempting to add
+     * an interceptor with a name that already exists in the manager will fail.
+     *
+     * After adding, interceptors are automatically sorted by their order property.
      */
     use(interceptor: Interceptor): boolean;
     /**
-     * 根据名称移除拦截器
-     * @param name 要移除的拦截器名称
+     * Removes an interceptor by name
+     *
+     * @param name - The name of the interceptor to remove
+     * @returns True if an interceptor was removed, false if no interceptor with the
+     *          given name was found
      */
     eject(name: string): boolean;
     /**
-     * 清空所有拦截器
+     * Removes all interceptors from this manager
      */
     clear(): void;
     /**
-     * 依次执行所有拦截器对数据的处理
-     * @param exchange - 需要处理的数据
-     * @returns 经过所有拦截器处理后的数据
+     * Executes all managed interceptors on the given exchange object
+     *
+     * @param exchange - The exchange object to process
+     * @returns A promise that resolves to the processed exchange object
+     *
+     * @remarks
+     * Interceptors are executed in order, with each interceptor receiving the result
+     * of the previous interceptor. The first interceptor receives the original
+     * exchange object.
+     *
+     * If any interceptor throws an error, the execution chain is broken and the error
+     * is propagated to the caller.
      */
     intercept(exchange: FetchExchange): Promise<FetchExchange>;
 }
 /**
- * Fetcher拦截器集合类，包含请求、响应和错误拦截器管理器
+ * FetcherInterceptors Class
+ *
+ * The interceptor collection management class for Fetcher, responsible for managing three types of interceptors:
+ * 1. Request interceptors - Process requests before sending HTTP requests
+ * 2. Response interceptors - Process responses after receiving HTTP responses
+ * 3. Error interceptors - Handle errors when they occur during the request process
+ *
+ * Each type of interceptor is managed by an InterceptorManager instance, supporting adding, removing, and executing interceptors.
+ *
+ * @example
+ * // Create a custom interceptor
+ * const customRequestInterceptor: Interceptor = {
+ *   name: 'CustomRequestInterceptor',
+ *   order: 100,
+ *   async intercept(exchange: FetchExchange): Promise<FetchExchange> {
+ *     // Modify request headers
+ *     exchange.request.headers = {
+ *       ...exchange.request.headers,
+ *       'X-Custom-Header': 'custom-value'
+ *     };
+ *     return exchange;
+ *   }
+ * };
+ *
+ * // Add interceptor to Fetcher
+ * const fetcher = new Fetcher();
+ * fetcher.interceptors.request.use(customRequestInterceptor);
+ *
+ * @remarks
+ * By default, the request interceptor manager has two built-in interceptors registered:
+ * 1. RequestBodyInterceptor - Automatically converts object-type request bodies to JSON strings
+ * 2. FetchInterceptor - Executes actual HTTP requests and handles timeouts
  */
 export declare class FetcherInterceptors {
     /**
-     * 请求拦截器管理器
+     * Request Interceptor Manager
+     *
+     * Responsible for managing all request-phase interceptors, executed before HTTP requests are sent.
+     * Contains two built-in interceptors by default: RequestBodyInterceptor and FetchInterceptor.
+     *
+     * @remarks
+     * Request interceptors are executed in ascending order of their order values, with smaller values having higher priority.
+     * FetchInterceptor's order is set to Number.MAX_SAFE_INTEGER to ensure it executes last.
      */
     request: InterceptorManager;
     /**
-     * 响应拦截器管理器
+     * Response Interceptor Manager
+     *
+     * Responsible for managing all response-phase interceptors, executed after HTTP responses are received.
+     * Empty by default, custom response processing logic can be added as needed.
+     *
+     * @remarks
+     * Response interceptors are executed in ascending order of their order values, with smaller values having higher priority.
      */
     response: InterceptorManager;
     /**
-     * 错误拦截器管理器
+     * Error Interceptor Manager
+     *
+     * Responsible for managing all error-handling phase interceptors, executed when errors occur during HTTP requests.
+     * Empty by default, custom error handling logic can be added as needed.
+     *
+     * @remarks
+     * Error interceptors are executed in ascending order of their order values, with smaller values having higher priority.
+     * Error interceptors can transform errors into normal responses, avoiding thrown exceptions.
      */
     error: InterceptorManager;
 }

package/dist/interceptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,cAAc,EAAY,MAAM,kBAAkB,CAAC;AAG5D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC/B,KAAK,EAAE,KAAK,GAAG,GAAG,GAAG,SAAS,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,cAAc;IAC/D;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC5E;AAED;;GAEG;AACH,qBAAa,kBAAmB,YAAW,WAAW;IACpD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,OAAO,CAAC,kBAAkB,CAAqB;gBAEnC,YAAY,GAAE,WAAW,EAAO;IAI5C;;;;OAIG;IACH,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAQtC;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAM5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;OAIG;IACG,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;CAQjE;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,OAAO,EAAE,kBAAkB,CAA0D;IAErF;;OAEG;IACH,QAAQ,EAAE,kBAAkB,CAA4B;IAExD;;OAEG;IACH,KAAK,EAAE,kBAAkB,CAA4B;CACtD"}
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../src/interceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,cAAc,EAAY,MAAM,kBAAkB,CAAC;AAI5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,OAAO,EAAE,cAAc,CAAC;IAExB;;OAEG;IACH,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE/B;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,GAAG,GAAG,SAAS,CAAC;IAE/B;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,WAAY,SAAQ,YAAY,EAAE,cAAc;IAC/D;;;;;;OAMG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;CAC5E;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,kBAAmB,YAAW,WAAW;IACpD;;;;OAIG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB,CAAqB;IAE/C;;;;;;;;OAQG;gBACS,YAAY,GAAE,WAAW,EAAO;IAI5C;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;IAWtC;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAS5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;OAaG;IACG,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;CAQjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,mBAAmB;IAC9B;;;;;;;;;OASG;IACH,OAAO,EAAE,kBAAkB,CAGxB;IAEH;;;;;;;;OAQG;IACH,QAAQ,EAAE,kBAAkB,CAA4B;IAExD;;;;;;;;;OASG;IACH,KAAK,EAAE,kBAAkB,CAA4B;CACtD"}

package/dist/orderedCapable.d.ts

@@ -1,28 +1,33 @@
 /**
- * 具备排序能力的接口
+ * OrderedCapable Interface
  *
- * 实现该接口的类型需要提供一个排序属性，用于确定执行顺序。
- * 数值越小优先级越高，相同数值的元素保持原有相对顺序。
+ * Interface that provides ordering capability for types that implement it.
+ * Implementing types must provide an order property to determine execution order.
+ * Lower numerical values have higher priority, and elements with the same value
+ * maintain their relative order.
  */
 export interface OrderedCapable {
     /**
-     * 排序值
+     * Order value
      *
-     * 数值越小优先级越高。负数、零和正数都支持。
-     * 当多个元素具有相同的order值时，它们的相对顺序将保持不变（稳定排序）。
+     * Lower numerical values have higher priority. Negative numbers, zero, and
+     * positive numbers are all supported.
+     * When multiple elements have the same order value, their relative order
+     * will remain unchanged (stable sort).
      */
     order: number;
 }
 /**
- * 对实现了OrderedCapable接口的数组进行排序
+ * Sorts an array of elements that implement the OrderedCapable interface
  *
- * 该函数创建并返回一个新的排序数组，不会修改原始数组。
- * 支持可选的过滤函数来筛选需要排序的元素。
+ * This function creates and returns a new sorted array without modifying the
+ * original array. It supports an optional filter function to select elements
+ * that should participate in sorting.
  *
- * @template T - 数组元素类型，必须实现OrderedCapable接口
- * @param array - 需要排序的数组
- * @param filter - 可选的过滤函数，用于筛选需要参与排序的元素
- * @returns 排序后的新数组，按照order值升序排列
+ * @template T - Array element type that must implement the OrderedCapable interface
+ * @param array - The array to be sorted
+ * @param filter - Optional filter function to select elements that should be sorted
+ * @returns A new array sorted in ascending order by the order property
  *
  * @example
  * ```typescript
@@ -33,11 +38,11 @@ export interface OrderedCapable {
  * ];
  *
  * const sortedItems = toSorted(items);
- * // 结果: [{ order: 1 }, { order: 5 }, { order: 10 }]
+ * // Result: [{ order: 1 }, { order: 5 }, { order: 10 }]
  *
- * // 使用过滤函数
+ * // Using filter function
  * const filteredAndSorted = toSorted(items, item => item.order > 3);
- * // 结果: [{ order: 5 }, { order: 10 }]
+ * // Result: [{ order: 5 }, { order: 10 }]
  * ```
  */
 export declare function toSorted<T extends OrderedCapable>(array: T[], filter?: (item: T) => boolean): T[];

package/dist/orderedCapable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderedCapable.d.ts","sourceRoot":"","sources":["../src/orderedCapable.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAC/C,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC5B,CAAC,EAAE,CAKL"}
+{"version":3,"file":"orderedCapable.d.ts","sourceRoot":"","sources":["../src/orderedCapable.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;OAOG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAC/C,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAC5B,CAAC,EAAE,CAKL"}

package/dist/requestBodyInterceptor.d.ts

@@ -1,17 +1,38 @@
 import { FetchExchange, Interceptor } from './interceptor';
 /**
- * 请求体拦截器，负责将普通对象转换为JSON字符串
+ * RequestBodyInterceptor Class
+ *
+ * Interceptor responsible for converting plain objects to JSON strings for HTTP request bodies.
+ * This interceptor ensures that object request bodies are properly serialized and that
+ * the appropriate Content-Type header is set.
+ *
+ * @remarks
+ * This interceptor runs early in the request processing chain with the lowest possible
+ * order value (Number.MIN_SAFE_INTEGER) to ensure request bodies are properly formatted
+ * before other interceptors process them.
  */
 export declare class RequestBodyInterceptor implements Interceptor {
+    /**
+     * Interceptor name, used for identification and management
+     */
     name: string;
+    /**
+     * Interceptor execution order, set to minimum safe integer to ensure early execution
+     *
+     * @remarks
+     * This interceptor should run before other request interceptors to ensure
+     * request bodies are properly formatted early in the processing chain.
+     */
     order: number;
     /**
-     * 尝试转换请求体为合法的 fetch API body 类型
+     * Attempts to convert request body to a valid fetch API body type
+     *
+     * According to the Fetch API specification, body can be multiple types, but for
+     * plain objects, they need to be converted to JSON strings.
      *
-     * 根据 Fetch API 规范，body 可以是多种类型，但对于普通对象，需要转换为 JSON 字符串
-     * https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#setting_a_body
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#setting_a_body}
      *
-     * 支持的类型:
+     * Supported types:
      *   - a string
      *   - ArrayBuffer
      *   - TypedArray
@@ -22,10 +43,22 @@ export declare class RequestBodyInterceptor implements Interceptor {
      *   - FormData
      *   - ReadableStream
      *
-     * 对于不支持的 object 类型（如普通对象），将自动转换为 JSON 字符串
+     * For unsupported object types (like plain objects), they will be automatically
+     * converted to JSON strings.
+     *
+     * @param exchange - The exchange object containing the request to process
+     * @returns The processed exchange object with potentially modified request body
      *
-     * @param exchange
-     * @returns 转换后的请求
+     * @example
+     * // Plain object body will be converted to JSON
+     * const exchange = {
+     *   request: {
+     *     body: { name: 'John', age: 30 }
+     *   }
+     * };
+     * const result = interceptor.intercept(exchange);
+     * // result.request.body will be '{"name":"John","age":30}'
+     * // result.request.headers will include 'Content-Type: application/json'
      */
     intercept(exchange: FetchExchange): FetchExchange;
 }

package/dist/requestBodyInterceptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestBodyInterceptor.d.ts","sourceRoot":"","sources":["../src/requestBodyInterceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG3D;;GAEG;AACH,qBAAa,sBAAuB,YAAW,WAAW;IACxD,IAAI,SAA4B;IAChC,KAAK,SAA2B;IAEhC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa;CA2ClD"}
+{"version":3,"file":"requestBodyInterceptor.d.ts","sourceRoot":"","sources":["../src/requestBodyInterceptor.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG3D;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAuB,YAAW,WAAW;IACxD;;OAEG;IACH,IAAI,SAA4B;IAEhC;;;;;;OAMG;IACH,KAAK,SAA2B;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,SAAS,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa;CA2ClD"}

package/dist/timeout.d.ts

@@ -1,28 +1,96 @@
-import { FetchExchange } from './interceptor';
 /**
- * 定义具有超时能力的接口
+ * TimeoutCapable Interface
+ *
+ * Interface that defines timeout capability for HTTP requests.
  */
 export interface TimeoutCapable {
     /**
-     * 请求超时
-     * 当值为0时，表示不设置超时，默认值为 undefined
+     * Request timeout in milliseconds
+     *
+     * When the value is 0, it indicates no timeout should be set.
+     * The default value is undefined.
      */
     timeout?: number;
 }
 /**
- * 解析请求超时设置，优先使用请求级别的超时设置
+ * Resolves request timeout settings, prioritizing request-level timeout settings
+ *
+ * @param requestTimeout - Request-level timeout setting
+ * @param optionsTimeout - Configuration-level timeout setting
+ * @returns Resolved timeout setting
  *
- * @param requestTimeout - 请求级别的超时设置
- * @param optionsTimeout - 配置级别的超时设置
- * @returns 解析后的超时设置
+ * @remarks
+ * If requestTimeout is defined, it takes precedence over optionsTimeout.
+ * Otherwise, optionsTimeout is returned. If both are undefined, undefined is returned.
  */
 export declare function resolveTimeout(requestTimeout?: number, optionsTimeout?: number): number | undefined;
 /**
- * FetchTimeoutError 异常类
- * 当HTTP请求超时时抛出此异常
+ * FetchTimeoutError Class
+ *
+ * Exception class thrown when an HTTP request times out.
+ * This error is thrown by the timeoutFetch function when a request exceeds its timeout limit.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await timeoutFetch('https://api.example.com/users', {}, 1000);
+ * } catch (error) {
+ *   if (error instanceof FetchTimeoutError) {
+ *     console.log(`Request timed out after ${error.timeout}ms`);
+ *   }
+ * }
+ * ```
  */
 export declare class FetchTimeoutError extends Error {
-    exchange: FetchExchange;
-    constructor(exchange: FetchExchange, timeout: number);
+    /**
+     * The URL that timed out
+     */
+    url: string;
+    /**
+     * The request options that timed out
+     */
+    request: RequestInit;
+    /**
+     * The timeout value in milliseconds
+     */
+    timeout: number;
+    /**
+     * Creates a new FetchTimeoutError instance
+     *
+     * @param url - The URL that timed out
+     * @param request - The request options that timed out
+     * @param timeout - The timeout value in milliseconds
+     */
+    constructor(url: string, request: RequestInit, timeout: number);
 }
+/**
+ * HTTP request method with timeout control
+ *
+ * This method uses Promise.race to implement timeout control, initiating both
+ * fetch request and timeout Promise simultaneously. When either Promise completes,
+ * it returns the result or throws an exception.
+ *
+ * @param url - The URL to fetch
+ * @param request - The request initialization options
+ * @param timeout - Optional timeout in milliseconds
+ * @returns Promise<Response> HTTP response Promise
+ * @throws FetchTimeoutError Thrown when the request times out
+ *
+ * @example
+ * ```typescript
+ * // With timeout
+ * try {
+ *   const response = await timeoutFetch('https://api.example.com/users', { method: 'GET' }, 5000);
+ *   console.log('Request completed successfully');
+ * } catch (error) {
+ *   if (error instanceof FetchTimeoutError) {
+ *     console.log(`Request timed out after ${error.timeout}ms`);
+ *   }
+ * }
+ *
+ * // Without timeout (delegates to regular fetch)
+ * const response = await timeoutFetch('https://api.example.com/users', { method: 'GET' });
+ * ```
+ */
+export declare function timeoutFetch(url: string, request: RequestInit, timeout?: number): Promise<Response>;
 //# sourceMappingURL=timeout.d.ts.map

package/dist/timeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAKpB;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,EAAE,aAAa,CAAC;gBAEZ,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM;CAUrD"}
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,cAAc,CAAC,EAAE,MAAM,EACvB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,GAAG,SAAS,CAKpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IAErB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;OAMG;gBACS,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM;CAW/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,CAAC,CAyCnB"}

package/dist/urlBuilder.d.ts

@@ -1,37 +1,62 @@
 import { BaseURLCapable } from './types';
 /**
- * URL构建器类，用于构建带有路径参数和查询参数的完整URL
+ * UrlBuilder Class
+ *
+ * URL builder class for constructing complete URLs with path parameters and query parameters.
+ * This class handles URL composition, path parameter interpolation, and query string generation.
  *
  * @example
+ * ```typescript
  * const urlBuilder = new UrlBuilder('https://api.example.com');
  * const url = urlBuilder.build('/users/{id}', { id: 123 }, { filter: 'active' });
- * // 结果: https://api.example.com/users/123?filter=active
+ * // Result: https://api.example.com/users/123?filter=active
+ * ```
  */
 export declare class UrlBuilder implements BaseURLCapable {
+    /**
+     * Base URL that all constructed URLs will be based on
+     */
     baseURL: string;
     /**
-     * 创建UrlBuilder实例
+     * Creates a UrlBuilder instance
      *
-     * @param baseURL - 基础URL，所有构建的URL都将基于此URL
+     * @param baseURL - Base URL that all constructed URLs will be based on
      */
     constructor(baseURL: string);
     /**
-     * 构建完整的URL，包括路径参数替换和查询参数添加
+     * Builds a complete URL, including path parameter replacement and query parameter addition
      *
-     * @param url - 需要构建的URL路径
-     * @param path - 路径参数对象，用于替换URL中的占位符（如{id}）
-     * @param query - 查询参数对象，将被添加到URL查询字符串中
-     * @returns 完整的URL字符串
-     * @throws 当路径参数中缺少必需的占位符时抛出错误
+     * @param url - URL path to build
+     * @param path - Path parameter object used to replace placeholders in the URL (e.g., {id})
+     * @param query - Query parameter object to be added to the URL query string
+     * @returns Complete URL string
+     * @throws Error when required path parameters are missing
+     *
+     * @example
+     * ```typescript
+     * const urlBuilder = new UrlBuilder('https://api.example.com');
+     * const url = urlBuilder.build('/users/{id}/posts/{postId}',
+     *   { id: 123, postId: 456 },
+     *   { filter: 'active', limit: 10 }
+     * );
+     * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
+     * ```
      */
     build(url: string, path?: Record<string, any>, query?: Record<string, any>): string;
     /**
-     * 替换url中的占位符参数
+     * Replaces placeholders in the URL with path parameters
+     *
+     * @param url - Path string containing placeholders, e.g., "http://localhost/users/{id}/posts/{postId}"
+     * @param path - Path parameter object used to replace placeholders in the URL
+     * @returns Path string with placeholders replaced
+     * @throws Error when required path parameters are missing
      *
-     * @param url - 包含占位符的路径字符串，如 "http://localhost/users/{id}/posts/{postId}"
-     * @param path - 路径参数对象，用于替换路径中的占位符
-     * @returns 替换占位符后的路径字符串
-     * @throws 当路径参数中缺少必需的占位符时抛出错误
+     * @example
+     * ```typescript
+     * const urlBuilder = new UrlBuilder('https://api.example.com');
+     * const result = urlBuilder.interpolateUrl('/users/{id}/posts/{postId}', { id: 123, postId: 456 });
+     * // Result: /users/123/posts/456
+     * ```
      */
     interpolateUrl(url: string, path?: Record<string, any>): string;
 }

package/dist/urlBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"urlBuilder.d.ts","sourceRoot":"","sources":["../src/urlBuilder.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;GAOG;AACH,qBAAa,UAAW,YAAW,cAAc;IAC/C,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;gBACS,OAAO,EAAE,MAAM;IAI3B;;;;;;;;OAQG;IACH,KAAK,CACH,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,MAAM;IAYT;;;;;;;OAOG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;CAWhE"}
+{"version":3,"file":"urlBuilder.d.ts","sourceRoot":"","sources":["../src/urlBuilder.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,YAAW,cAAc;IAC/C;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;gBACS,OAAO,EAAE,MAAM;IAI3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CACH,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC1B,MAAM;IAYT;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;CAWhE"}