@vlian/framework 1.1.0 → 1.2.1

package/dist/request/plugin/queue.cjs

@@ -0,0 +1,140 @@
+/**
+ * 请求队列插件
+ * 
+ * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，
+ * 执行回调方法，等待回调完成后继续执行队列中的请求
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createQueuePlugin", {
+    enumerable: true,
+    get: function() {
+        return createQueuePlugin;
+    }
+});
+const _RequestPlugin = require("./RequestPlugin");
+const _RequestQueueManager = require("../utils/RequestQueueManager");
+/**
+ * 检查响应是否匹配触发条件
+ */ function matchesTrigger(response, context, trigger) {
+    // 检查自定义检查函数
+    if (trigger.check) {
+        return trigger.check(response, context);
+    }
+    // 检查响应数据中的 code 字段
+    if (trigger.code !== undefined) {
+        const responseData = response.data;
+        if (responseData && typeof responseData === 'object' && 'code' in responseData) {
+            const code = responseData.code;
+            if (typeof trigger.code === 'function') {
+                if (trigger.code(code)) {
+                    return true;
+                }
+            } else if (code === trigger.code) {
+                return true;
+            }
+        }
+    }
+    // 检查 HTTP 状态码
+    if (trigger.status !== undefined) {
+        const status = response.status;
+        if (typeof trigger.status === 'function') {
+            if (trigger.status(status)) {
+                return true;
+            }
+        } else if (Array.isArray(trigger.status)) {
+            if (trigger.status.includes(status)) {
+                return true;
+            }
+        } else if (status === trigger.status) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 检查响应是否匹配任一触发条件
+ */ function matchesAnyTrigger(response, context, triggers) {
+    return triggers.some((trigger)=>matchesTrigger(response, context, trigger));
+}
+function createQueuePlugin(config = {}) {
+    const { triggers = [], onTrigger, enabled = true, checkOnError = true, queueTimeout = 30000 } = config;
+    if (triggers.length === 0) {
+        // 如果没有配置触发条件，返回一个空插件
+        return {
+            name: 'queue',
+            priority: _RequestPlugin.PluginPriority.HIGH,
+            onBeforeRequest: undefined,
+            onAfterRequest: undefined,
+            onError: undefined
+        };
+    }
+    const queueManager = (0, _RequestQueueManager.getRequestQueueManager)();
+    return {
+        name: 'queue',
+        priority: _RequestPlugin.PluginPriority.HIGH,
+        async onAfterRequest (context) {
+            if (!enabled || !context.response) {
+                return;
+            }
+            // 检查是否匹配触发条件
+            const matched = matchesAnyTrigger(context.response, context, triggers);
+            if (matched && onTrigger) {
+                // 暂停队列（后续请求会被 RequestClient 自动放入队列）
+                queueManager.pause();
+                // 设置队列超时
+                const timeoutId = setTimeout(()=>{
+                    queueManager.clear('队列超时');
+                }, queueTimeout);
+                try {
+                    // 执行回调并等待完成，然后恢复队列
+                    await queueManager.processAndResume(async ()=>{
+                        await onTrigger(context.response, context);
+                    });
+                } catch (error) {
+                    // 回调执行失败，清空队列
+                    queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
+                // 不抛出错误，让请求正常返回（但队列已被清空）
+                } finally{
+                    clearTimeout(timeoutId);
+                }
+            }
+        },
+        async onError (context) {
+            if (!enabled || !checkOnError || !context.error) {
+                return;
+            }
+            // 如果有响应，检查是否匹配触发条件
+            if (context.response) {
+                const matched = matchesAnyTrigger(context.response, context, triggers);
+                if (matched && onTrigger) {
+                    // 暂停队列（后续请求会被 RequestClient 自动放入队列）
+                    queueManager.pause();
+                    // 设置队列超时
+                    const timeoutId = setTimeout(()=>{
+                        queueManager.clear('队列超时');
+                    }, queueTimeout);
+                    try {
+                        // 执行回调并等待完成，然后恢复队列
+                        await queueManager.processAndResume(async ()=>{
+                            await onTrigger(context.response, context);
+                        });
+                        // 错误已被处理，返回 true 阻止错误传播
+                        return true;
+                    } catch (error) {
+                        // 回调执行失败，清空队列
+                        queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
+                        // 不处理错误，继续传播
+                        return false;
+                    } finally{
+                        clearTimeout(timeoutId);
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}
+
+//# sourceMappingURL=queue.js.map

package/dist/request/plugin/queue.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/request/plugin/queue.ts"],"sourcesContent":["/**\n * 请求队列插件\n * \n * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，\n * 执行回调方法，等待回调完成后继续执行队列中的请求\n */\n\nimport type { RequestPlugin } from './RequestPlugin';\nimport type { RequestContext, Response } from '../types';\nimport { PluginPriority } from './RequestPlugin';\nimport { getRequestQueueManager } from '../utils/RequestQueueManager';\n\n/**\n * 触发条件配置\n */\nexport interface QueueTriggerCondition {\n  /**\n   * 响应数据中的 code 字段值（业务状态码）\n   * 如果响应数据是对象且包含 code 字段，且值匹配则触发\n   */\n  code?: number | string | ((code: unknown) => boolean);\n  \n  /**\n   * HTTP 状态码\n   * 如果 HTTP status 匹配则触发\n   */\n  status?: number | number[] | ((status: number) => boolean);\n  \n  /**\n   * 自定义检查函数\n   * 返回 true 表示应该触发队列暂停\n   */\n  check?: (response: Response, context: RequestContext) => boolean;\n}\n\n/**\n * 队列插件配置\n */\nexport interface QueuePluginConfig {\n  /**\n   * 触发条件列表\n   * 当响应匹配任一条件时，会暂停队列并执行回调\n   */\n  triggers?: QueueTriggerCondition[];\n  \n  /**\n   * 回调函数\n   * 当检测到触发条件时执行，返回 Promise 表示异步操作\n   * \n   * @param response - 触发条件的响应\n   * @param context - 请求上下文\n   * @returns Promise 或 void\n   */\n  onTrigger?: (response: Response, context: RequestContext) => Promise<void> | void;\n  \n  /**\n   * 是否启用队列功能\n   * @default true\n   */\n  enabled?: boolean;\n  \n  /**\n   * 是否在错误时也检查触发条件\n   * @default true\n   */\n  checkOnError?: boolean;\n  \n  /**\n   * 队列超时时间（毫秒）\n   * 如果队列暂停超过此时间，会自动恢复并拒绝队列中的请求\n   * @default 30000 (30秒)\n   */\n  queueTimeout?: number;\n}\n\n/**\n * 检查响应是否匹配触发条件\n */\nfunction matchesTrigger(\n  response: Response,\n  context: RequestContext,\n  trigger: QueueTriggerCondition\n): boolean {\n  // 检查自定义检查函数\n  if (trigger.check) {\n    return trigger.check(response, context);\n  }\n  \n  // 检查响应数据中的 code 字段\n  if (trigger.code !== undefined) {\n    const responseData = response.data;\n    if (responseData && typeof responseData === 'object' && 'code' in responseData) {\n      const code = (responseData as { code: unknown }).code;\n      \n      if (typeof trigger.code === 'function') {\n        if (trigger.code(code)) {\n          return true;\n        }\n      } else if (code === trigger.code) {\n        return true;\n      }\n    }\n  }\n  \n  // 检查 HTTP 状态码\n  if (trigger.status !== undefined) {\n    const status = response.status;\n    \n    if (typeof trigger.status === 'function') {\n      if (trigger.status(status)) {\n        return true;\n      }\n    } else if (Array.isArray(trigger.status)) {\n      if (trigger.status.includes(status)) {\n        return true;\n      }\n    } else if (status === trigger.status) {\n      return true;\n    }\n  }\n  \n  return false;\n}\n\n/**\n * 检查响应是否匹配任一触发条件\n */\nfunction matchesAnyTrigger(\n  response: Response,\n  context: RequestContext,\n  triggers: QueueTriggerCondition[]\n): boolean {\n  return triggers.some((trigger) => matchesTrigger(response, context, trigger));\n}\n\n/**\n * 创建请求队列插件\n * \n * @param config - 队列插件配置\n * @returns 队列插件实例\n * \n * @example\n * ```typescript\n * import { createRequestClient } from '@vlian/framework/request';\n * import { createQueuePlugin } from '@vlian/framework/request/plugin';\n * \n * const client = await createRequestClient({\n *   plugins: [\n *     createQueuePlugin({\n *       triggers: [\n *         { code: 401 }, // 业务 code 401 表示未授权\n *         { status: 401 }, // HTTP 401 未授权\n *       ],\n *       onTrigger: async (response, context) => {\n *         // 刷新 token 或跳转登录\n *         await refreshToken();\n *       },\n *     }),\n *   ],\n * });\n * ```\n */\nexport function createQueuePlugin(config: QueuePluginConfig = {}): RequestPlugin {\n  const {\n    triggers = [],\n    onTrigger,\n    enabled = true,\n    checkOnError = true,\n    queueTimeout = 30000,\n  } = config;\n  \n  if (triggers.length === 0) {\n    // 如果没有配置触发条件，返回一个空插件\n    return {\n      name: 'queue',\n      priority: PluginPriority.HIGH,\n      onBeforeRequest: undefined,\n      onAfterRequest: undefined,\n      onError: undefined,\n    };\n  }\n  \n  const queueManager = getRequestQueueManager();\n  \n  return {\n    name: 'queue',\n    priority: PluginPriority.HIGH, // 高优先级，确保在其他插件之前执行\n    \n    async onAfterRequest(context: RequestContext): Promise<Response | void> {\n      if (!enabled || !context.response) {\n        return;\n      }\n      \n      // 检查是否匹配触发条件\n      const matched = matchesAnyTrigger(context.response, context, triggers);\n      \n      if (matched && onTrigger) {\n        // 暂停队列（后续请求会被 RequestClient 自动放入队列）\n        queueManager.pause();\n        \n        // 设置队列超时\n        const timeoutId = setTimeout(() => {\n          queueManager.clear('队列超时');\n        }, queueTimeout);\n        \n        try {\n          // 执行回调并等待完成，然后恢复队列\n          await queueManager.processAndResume(async () => {\n            await onTrigger(context.response!, context);\n          });\n        } catch (error) {\n          // 回调执行失败，清空队列\n          queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);\n          // 不抛出错误，让请求正常返回（但队列已被清空）\n        } finally {\n          clearTimeout(timeoutId);\n        }\n      }\n    },\n    \n    async onError(context: RequestContext): Promise<boolean | void> {\n      if (!enabled || !checkOnError || !context.error) {\n        return;\n      }\n      \n      // 如果有响应，检查是否匹配触发条件\n      if (context.response) {\n        const matched = matchesAnyTrigger(context.response, context, triggers);\n        \n        if (matched && onTrigger) {\n          // 暂停队列（后续请求会被 RequestClient 自动放入队列）\n          queueManager.pause();\n          \n          // 设置队列超时\n          const timeoutId = setTimeout(() => {\n            queueManager.clear('队列超时');\n          }, queueTimeout);\n          \n          try {\n            // 执行回调并等待完成，然后恢复队列\n            await queueManager.processAndResume(async () => {\n              await onTrigger(context.response!, context);\n            });\n            \n            // 错误已被处理，返回 true 阻止错误传播\n            return true;\n          } catch (error) {\n            // 回调执行失败，清空队列\n            queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);\n            // 不处理错误，继续传播\n            return false;\n          } finally {\n            clearTimeout(timeoutId);\n          }\n        }\n      }\n      \n      return false;\n    },\n  };\n}\n"],"names":["createQueuePlugin","matchesTrigger","response","context","trigger","check","code","undefined","responseData","data","status","Array","isArray","includes","matchesAnyTrigger","triggers","some","config","onTrigger","enabled","checkOnError","queueTimeout","length","name","priority","PluginPriority","HIGH","onBeforeRequest","onAfterRequest","onError","queueManager","getRequestQueueManager","matched","pause","timeoutId","setTimeout","clear","processAndResume","error","Error","message","String","clearTimeout"],"mappings":"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"}

package/dist/request/plugin/queue.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 请求队列插件
+ *
+ * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，
+ * 执行回调方法，等待回调完成后继续执行队列中的请求
+ */
+import type { RequestPlugin } from './RequestPlugin';
+import type { RequestContext, Response } from '../types';
+/**
+ * 触发条件配置
+ */
+export interface QueueTriggerCondition {
+    /**
+     * 响应数据中的 code 字段值（业务状态码）
+     * 如果响应数据是对象且包含 code 字段，且值匹配则触发
+     */
+    code?: number | string | ((code: unknown) => boolean);
+    /**
+     * HTTP 状态码
+     * 如果 HTTP status 匹配则触发
+     */
+    status?: number | number[] | ((status: number) => boolean);
+    /**
+     * 自定义检查函数
+     * 返回 true 表示应该触发队列暂停
+     */
+    check?: (response: Response, context: RequestContext) => boolean;
+}
+/**
+ * 队列插件配置
+ */
+export interface QueuePluginConfig {
+    /**
+     * 触发条件列表
+     * 当响应匹配任一条件时，会暂停队列并执行回调
+     */
+    triggers?: QueueTriggerCondition[];
+    /**
+     * 回调函数
+     * 当检测到触发条件时执行，返回 Promise 表示异步操作
+     *
+     * @param response - 触发条件的响应
+     * @param context - 请求上下文
+     * @returns Promise 或 void
+     */
+    onTrigger?: (response: Response, context: RequestContext) => Promise<void> | void;
+    /**
+     * 是否启用队列功能
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * 是否在错误时也检查触发条件
+     * @default true
+     */
+    checkOnError?: boolean;
+    /**
+     * 队列超时时间（毫秒）
+     * 如果队列暂停超过此时间，会自动恢复并拒绝队列中的请求
+     * @default 30000 (30秒)
+     */
+    queueTimeout?: number;
+}
+/**
+ * 创建请求队列插件
+ *
+ * @param config - 队列插件配置
+ * @returns 队列插件实例
+ *
+ * @example
+ * ```typescript
+ * import { createRequestClient } from '@vlian/framework/request';
+ * import { createQueuePlugin } from '@vlian/framework/request/plugin';
+ *
+ * const client = await createRequestClient({
+ *   plugins: [
+ *     createQueuePlugin({
+ *       triggers: [
+ *         { code: 401 }, // 业务 code 401 表示未授权
+ *         { status: 401 }, // HTTP 401 未授权
+ *       ],
+ *       onTrigger: async (response, context) => {
+ *         // 刷新 token 或跳转登录
+ *         await refreshToken();
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function createQueuePlugin(config?: QueuePluginConfig): RequestPlugin;
+//# sourceMappingURL=queue.d.ts.map

package/dist/request/plugin/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/request/plugin/queue.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAIzD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC;IAEtD;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC;IAE3D;;;OAGG;IACH,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC;CAClE;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAEnC;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAElF;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,iBAAsB,GAAG,aAAa,CAkG/E"}

package/dist/request/plugin/queue.js

@@ -0,0 +1,156 @@
+/**
+ * 请求队列插件
+ * 
+ * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，
+ * 执行回调方法，等待回调完成后继续执行队列中的请求
+ */ import { PluginPriority } from "./RequestPlugin";
+import { getRequestQueueManager } from "../utils/RequestQueueManager";
+/**
+ * 检查响应是否匹配触发条件
+ */ function matchesTrigger(response, context, trigger) {
+    // 检查自定义检查函数
+    if (trigger.check) {
+        return trigger.check(response, context);
+    }
+    // 检查响应数据中的 code 字段
+    if (trigger.code !== undefined) {
+        const responseData = response.data;
+        if (responseData && typeof responseData === 'object' && 'code' in responseData) {
+            const code = responseData.code;
+            if (typeof trigger.code === 'function') {
+                if (trigger.code(code)) {
+                    return true;
+                }
+            } else if (code === trigger.code) {
+                return true;
+            }
+        }
+    }
+    // 检查 HTTP 状态码
+    if (trigger.status !== undefined) {
+        const status = response.status;
+        if (typeof trigger.status === 'function') {
+            if (trigger.status(status)) {
+                return true;
+            }
+        } else if (Array.isArray(trigger.status)) {
+            if (trigger.status.includes(status)) {
+                return true;
+            }
+        } else if (status === trigger.status) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 检查响应是否匹配任一触发条件
+ */ function matchesAnyTrigger(response, context, triggers) {
+    return triggers.some((trigger)=>matchesTrigger(response, context, trigger));
+}
+/**
+ * 创建请求队列插件
+ * 
+ * @param config - 队列插件配置
+ * @returns 队列插件实例
+ * 
+ * @example
+ * ```typescript
+ * import { createRequestClient } from '@vlian/framework/request';
+ * import { createQueuePlugin } from '@vlian/framework/request/plugin';
+ * 
+ * const client = await createRequestClient({
+ *   plugins: [
+ *     createQueuePlugin({
+ *       triggers: [
+ *         { code: 401 }, // 业务 code 401 表示未授权
+ *         { status: 401 }, // HTTP 401 未授权
+ *       ],
+ *       onTrigger: async (response, context) => {
+ *         // 刷新 token 或跳转登录
+ *         await refreshToken();
+ *       },
+ *     }),
+ *   ],
+ * });
+ * ```
+ */ export function createQueuePlugin(config = {}) {
+    const { triggers = [], onTrigger, enabled = true, checkOnError = true, queueTimeout = 30000 } = config;
+    if (triggers.length === 0) {
+        // 如果没有配置触发条件，返回一个空插件
+        return {
+            name: 'queue',
+            priority: PluginPriority.HIGH,
+            onBeforeRequest: undefined,
+            onAfterRequest: undefined,
+            onError: undefined
+        };
+    }
+    const queueManager = getRequestQueueManager();
+    return {
+        name: 'queue',
+        priority: PluginPriority.HIGH,
+        async onAfterRequest (context) {
+            if (!enabled || !context.response) {
+                return;
+            }
+            // 检查是否匹配触发条件
+            const matched = matchesAnyTrigger(context.response, context, triggers);
+            if (matched && onTrigger) {
+                // 暂停队列（后续请求会被 RequestClient 自动放入队列）
+                queueManager.pause();
+                // 设置队列超时
+                const timeoutId = setTimeout(()=>{
+                    queueManager.clear('队列超时');
+                }, queueTimeout);
+                try {
+                    // 执行回调并等待完成，然后恢复队列
+                    await queueManager.processAndResume(async ()=>{
+                        await onTrigger(context.response, context);
+                    });
+                } catch (error) {
+                    // 回调执行失败，清空队列
+                    queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
+                // 不抛出错误，让请求正常返回（但队列已被清空）
+                } finally{
+                    clearTimeout(timeoutId);
+                }
+            }
+        },
+        async onError (context) {
+            if (!enabled || !checkOnError || !context.error) {
+                return;
+            }
+            // 如果有响应，检查是否匹配触发条件
+            if (context.response) {
+                const matched = matchesAnyTrigger(context.response, context, triggers);
+                if (matched && onTrigger) {
+                    // 暂停队列（后续请求会被 RequestClient 自动放入队列）
+                    queueManager.pause();
+                    // 设置队列超时
+                    const timeoutId = setTimeout(()=>{
+                        queueManager.clear('队列超时');
+                    }, queueTimeout);
+                    try {
+                        // 执行回调并等待完成，然后恢复队列
+                        await queueManager.processAndResume(async ()=>{
+                            await onTrigger(context.response, context);
+                        });
+                        // 错误已被处理，返回 true 阻止错误传播
+                        return true;
+                    } catch (error) {
+                        // 回调执行失败，清空队列
+                        queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);
+                        // 不处理错误，继续传播
+                        return false;
+                    } finally{
+                        clearTimeout(timeoutId);
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}
+
+//# sourceMappingURL=queue.js.map

package/dist/request/plugin/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/request/plugin/queue.ts"],"sourcesContent":["/**\n * 请求队列插件\n * \n * 当检测到特定的响应 code 或 status 时，暂停后续请求并放入队列，\n * 执行回调方法，等待回调完成后继续执行队列中的请求\n */\n\nimport type { RequestPlugin } from './RequestPlugin';\nimport type { RequestContext, Response } from '../types';\nimport { PluginPriority } from './RequestPlugin';\nimport { getRequestQueueManager } from '../utils/RequestQueueManager';\n\n/**\n * 触发条件配置\n */\nexport interface QueueTriggerCondition {\n  /**\n   * 响应数据中的 code 字段值（业务状态码）\n   * 如果响应数据是对象且包含 code 字段，且值匹配则触发\n   */\n  code?: number | string | ((code: unknown) => boolean);\n  \n  /**\n   * HTTP 状态码\n   * 如果 HTTP status 匹配则触发\n   */\n  status?: number | number[] | ((status: number) => boolean);\n  \n  /**\n   * 自定义检查函数\n   * 返回 true 表示应该触发队列暂停\n   */\n  check?: (response: Response, context: RequestContext) => boolean;\n}\n\n/**\n * 队列插件配置\n */\nexport interface QueuePluginConfig {\n  /**\n   * 触发条件列表\n   * 当响应匹配任一条件时，会暂停队列并执行回调\n   */\n  triggers?: QueueTriggerCondition[];\n  \n  /**\n   * 回调函数\n   * 当检测到触发条件时执行，返回 Promise 表示异步操作\n   * \n   * @param response - 触发条件的响应\n   * @param context - 请求上下文\n   * @returns Promise 或 void\n   */\n  onTrigger?: (response: Response, context: RequestContext) => Promise<void> | void;\n  \n  /**\n   * 是否启用队列功能\n   * @default true\n   */\n  enabled?: boolean;\n  \n  /**\n   * 是否在错误时也检查触发条件\n   * @default true\n   */\n  checkOnError?: boolean;\n  \n  /**\n   * 队列超时时间（毫秒）\n   * 如果队列暂停超过此时间，会自动恢复并拒绝队列中的请求\n   * @default 30000 (30秒)\n   */\n  queueTimeout?: number;\n}\n\n/**\n * 检查响应是否匹配触发条件\n */\nfunction matchesTrigger(\n  response: Response,\n  context: RequestContext,\n  trigger: QueueTriggerCondition\n): boolean {\n  // 检查自定义检查函数\n  if (trigger.check) {\n    return trigger.check(response, context);\n  }\n  \n  // 检查响应数据中的 code 字段\n  if (trigger.code !== undefined) {\n    const responseData = response.data;\n    if (responseData && typeof responseData === 'object' && 'code' in responseData) {\n      const code = (responseData as { code: unknown }).code;\n      \n      if (typeof trigger.code === 'function') {\n        if (trigger.code(code)) {\n          return true;\n        }\n      } else if (code === trigger.code) {\n        return true;\n      }\n    }\n  }\n  \n  // 检查 HTTP 状态码\n  if (trigger.status !== undefined) {\n    const status = response.status;\n    \n    if (typeof trigger.status === 'function') {\n      if (trigger.status(status)) {\n        return true;\n      }\n    } else if (Array.isArray(trigger.status)) {\n      if (trigger.status.includes(status)) {\n        return true;\n      }\n    } else if (status === trigger.status) {\n      return true;\n    }\n  }\n  \n  return false;\n}\n\n/**\n * 检查响应是否匹配任一触发条件\n */\nfunction matchesAnyTrigger(\n  response: Response,\n  context: RequestContext,\n  triggers: QueueTriggerCondition[]\n): boolean {\n  return triggers.some((trigger) => matchesTrigger(response, context, trigger));\n}\n\n/**\n * 创建请求队列插件\n * \n * @param config - 队列插件配置\n * @returns 队列插件实例\n * \n * @example\n * ```typescript\n * import { createRequestClient } from '@vlian/framework/request';\n * import { createQueuePlugin } from '@vlian/framework/request/plugin';\n * \n * const client = await createRequestClient({\n *   plugins: [\n *     createQueuePlugin({\n *       triggers: [\n *         { code: 401 }, // 业务 code 401 表示未授权\n *         { status: 401 }, // HTTP 401 未授权\n *       ],\n *       onTrigger: async (response, context) => {\n *         // 刷新 token 或跳转登录\n *         await refreshToken();\n *       },\n *     }),\n *   ],\n * });\n * ```\n */\nexport function createQueuePlugin(config: QueuePluginConfig = {}): RequestPlugin {\n  const {\n    triggers = [],\n    onTrigger,\n    enabled = true,\n    checkOnError = true,\n    queueTimeout = 30000,\n  } = config;\n  \n  if (triggers.length === 0) {\n    // 如果没有配置触发条件，返回一个空插件\n    return {\n      name: 'queue',\n      priority: PluginPriority.HIGH,\n      onBeforeRequest: undefined,\n      onAfterRequest: undefined,\n      onError: undefined,\n    };\n  }\n  \n  const queueManager = getRequestQueueManager();\n  \n  return {\n    name: 'queue',\n    priority: PluginPriority.HIGH, // 高优先级，确保在其他插件之前执行\n    \n    async onAfterRequest(context: RequestContext): Promise<Response | void> {\n      if (!enabled || !context.response) {\n        return;\n      }\n      \n      // 检查是否匹配触发条件\n      const matched = matchesAnyTrigger(context.response, context, triggers);\n      \n      if (matched && onTrigger) {\n        // 暂停队列（后续请求会被 RequestClient 自动放入队列）\n        queueManager.pause();\n        \n        // 设置队列超时\n        const timeoutId = setTimeout(() => {\n          queueManager.clear('队列超时');\n        }, queueTimeout);\n        \n        try {\n          // 执行回调并等待完成，然后恢复队列\n          await queueManager.processAndResume(async () => {\n            await onTrigger(context.response!, context);\n          });\n        } catch (error) {\n          // 回调执行失败，清空队列\n          queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);\n          // 不抛出错误，让请求正常返回（但队列已被清空）\n        } finally {\n          clearTimeout(timeoutId);\n        }\n      }\n    },\n    \n    async onError(context: RequestContext): Promise<boolean | void> {\n      if (!enabled || !checkOnError || !context.error) {\n        return;\n      }\n      \n      // 如果有响应，检查是否匹配触发条件\n      if (context.response) {\n        const matched = matchesAnyTrigger(context.response, context, triggers);\n        \n        if (matched && onTrigger) {\n          // 暂停队列（后续请求会被 RequestClient 自动放入队列）\n          queueManager.pause();\n          \n          // 设置队列超时\n          const timeoutId = setTimeout(() => {\n            queueManager.clear('队列超时');\n          }, queueTimeout);\n          \n          try {\n            // 执行回调并等待完成，然后恢复队列\n            await queueManager.processAndResume(async () => {\n              await onTrigger(context.response!, context);\n            });\n            \n            // 错误已被处理，返回 true 阻止错误传播\n            return true;\n          } catch (error) {\n            // 回调执行失败，清空队列\n            queueManager.clear(`回调执行失败: ${error instanceof Error ? error.message : String(error)}`);\n            // 不处理错误，继续传播\n            return false;\n          } finally {\n            clearTimeout(timeoutId);\n          }\n        }\n      }\n      \n      return false;\n    },\n  };\n}\n"],"names":["PluginPriority","getRequestQueueManager","matchesTrigger","response","context","trigger","check","code","undefined","responseData","data","status","Array","isArray","includes","matchesAnyTrigger","triggers","some","createQueuePlugin","config","onTrigger","enabled","checkOnError","queueTimeout","length","name","priority","HIGH","onBeforeRequest","onAfterRequest","onError","queueManager","matched","pause","timeoutId","setTimeout","clear","processAndResume","error","Error","message","String","clearTimeout"],"mappings":"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"}

package/dist/request/utils/RequestQueueManager.cjs

@@ -0,0 +1,168 @@
+/**
+ * 请求队列管理器
+ * 
+ * 用于管理待执行的请求队列，支持请求拦截、暂停、恢复等功能
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRequestQueueManager", {
+    enumerable: true,
+    get: function() {
+        return getRequestQueueManager;
+    }
+});
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * 队列状态
+ */ var QueueState = /*#__PURE__*/ function(QueueState) {
+    /**
+   * 正常状态，请求可以正常执行
+   */ QueueState["IDLE"] = "idle";
+    /**
+   * 暂停状态，请求会被放入队列
+   */ QueueState["PAUSED"] = "paused";
+    /**
+   * 处理中状态，正在执行回调
+   */ QueueState["PROCESSING"] = "processing";
+    return QueueState;
+}(QueueState || {});
+/**
+ * 请求队列管理器
+ */ let RequestQueueManager = class RequestQueueManager {
+    /**
+   * 获取单例实例
+   */ static getInstance() {
+        if (!RequestQueueManager.instance) {
+            RequestQueueManager.instance = new RequestQueueManager();
+        }
+        return RequestQueueManager.instance;
+    }
+    /**
+   * 检查队列是否处于暂停状态
+   */ isPaused() {
+        return this.state === "paused" || this.state === "processing";
+    }
+    /**
+   * 暂停队列，后续请求会被放入队列
+   */ pause() {
+        if (this.state === "idle") {
+            this.state = "paused";
+        }
+    }
+    /**
+   * 恢复队列，执行队列中的所有请求
+   */ async resume() {
+        if (this.state === "idle") {
+            return;
+        }
+        this.state = "idle";
+        // 执行队列中的所有请求
+        const requests = [
+            ...this.queue
+        ];
+        this.queue = [];
+        // 并行执行所有请求
+        await Promise.allSettled(requests.map((item)=>{
+            return item.execute().then(item.resolve).catch(item.reject);
+        }));
+    }
+    /**
+   * 执行回调并等待完成，然后恢复队列
+   * 
+   * @param callback - 回调函数
+   */ async processAndResume(callback) {
+        if (this.state === "processing") {
+            // 如果已经在处理中，等待当前处理完成
+            if (this.processingPromise) {
+                await this.processingPromise;
+            }
+            return;
+        }
+        this.state = "processing";
+        try {
+            // 执行回调
+            this.processingPromise = Promise.resolve(callback());
+            await this.processingPromise;
+        } finally{
+            this.processingPromise = null;
+            // 恢复队列
+            await this.resume();
+        }
+    }
+    /**
+   * 将请求添加到队列
+   * 
+   * @template TResponse - 响应数据类型
+   * @param options - 请求配置
+   * @param execute - 请求执行函数
+   * @returns Promise 解析为响应对象
+   */ async enqueue(options, execute) {
+        return new Promise((resolve, reject)=>{
+            this.queue.push({
+                options: options,
+                execute: execute,
+                resolve: resolve,
+                reject,
+                timestamp: Date.now()
+            });
+        });
+    }
+    /**
+   * 获取队列长度
+   */ getQueueLength() {
+        return this.queue.length;
+    }
+    /**
+   * 清空队列
+   * 
+   * @param reason - 清空原因（用于错误信息）
+   */ clear(reason) {
+        const requests = [
+            ...this.queue
+        ];
+        this.queue = [];
+        // 拒绝所有待执行的请求
+        const error = reason ? new Error(`请求队列已清空: ${reason}`) : new Error('请求队列已清空');
+        requests.forEach((item)=>{
+            item.reject(error);
+        });
+        this.state = "idle";
+        this.processingPromise = null;
+    }
+    /**
+   * 销毁管理器
+   */ destroy() {
+        this.clear('管理器已销毁');
+        RequestQueueManager.instance = null;
+    }
+    constructor(){
+        /**
+   * 待执行的请求队列
+   */ _define_property(this, "queue", []);
+        /**
+   * 队列状态
+   */ _define_property(this, "state", "idle");
+        /**
+   * 当前正在执行的回调 Promise
+   */ _define_property(this, "processingPromise", null);
+    }
+};
+_define_property(RequestQueueManager, "instance", null);
+function getRequestQueueManager() {
+    return RequestQueueManager.getInstance();
+}
+
+//# sourceMappingURL=RequestQueueManager.js.map

package/dist/request/utils/RequestQueueManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/request/utils/RequestQueueManager.ts"],"sourcesContent":["/**\n * 请求队列管理器\n * \n * 用于管理待执行的请求队列，支持请求拦截、暂停、恢复等功能\n */\n\nimport type { RequestOptions, Response } from '../types';\n\n/**\n * 待执行的请求项\n */\ninterface QueuedRequest {\n  /**\n   * 请求配置\n   */\n  options: RequestOptions<unknown>;\n  \n  /**\n   * 请求执行函数\n   */\n  execute: () => Promise<Response<unknown>>;\n  \n  /**\n   * Promise resolve 函数\n   */\n  resolve: (response: Response<unknown>) => void;\n  \n  /**\n   * Promise reject 函数\n   */\n  reject: (error: unknown) => void;\n  \n  /**\n   * 请求时间戳\n   */\n  timestamp: number;\n}\n\n/**\n * 队列状态\n */\nenum QueueState {\n  /**\n   * 正常状态，请求可以正常执行\n   */\n  IDLE = 'idle',\n  \n  /**\n   * 暂停状态，请求会被放入队列\n   */\n  PAUSED = 'paused',\n  \n  /**\n   * 处理中状态，正在执行回调\n   */\n  PROCESSING = 'processing',\n}\n\n/**\n * 请求队列管理器\n */\nclass RequestQueueManager {\n  private static instance: RequestQueueManager | null = null;\n  \n  /**\n   * 待执行的请求队列\n   */\n  private queue: QueuedRequest[] = [];\n  \n  /**\n   * 队列状态\n   */\n  private state: QueueState = QueueState.IDLE;\n  \n  /**\n   * 当前正在执行的回调 Promise\n   */\n  private processingPromise: Promise<void> | null = null;\n  \n  /**\n   * 获取单例实例\n   */\n  static getInstance(): RequestQueueManager {\n    if (!RequestQueueManager.instance) {\n      RequestQueueManager.instance = new RequestQueueManager();\n    }\n    return RequestQueueManager.instance;\n  }\n  \n  /**\n   * 检查队列是否处于暂停状态\n   */\n  isPaused(): boolean {\n    return this.state === QueueState.PAUSED || this.state === QueueState.PROCESSING;\n  }\n  \n  /**\n   * 暂停队列，后续请求会被放入队列\n   */\n  pause(): void {\n    if (this.state === QueueState.IDLE) {\n      this.state = QueueState.PAUSED;\n    }\n  }\n  \n  /**\n   * 恢复队列，执行队列中的所有请求\n   */\n  async resume(): Promise<void> {\n    if (this.state === QueueState.IDLE) {\n      return;\n    }\n    \n    this.state = QueueState.IDLE;\n    \n    // 执行队列中的所有请求\n    const requests = [...this.queue];\n    this.queue = [];\n    \n    // 并行执行所有请求\n    await Promise.allSettled(\n      requests.map((item) => {\n        return item\n          .execute()\n          .then(item.resolve)\n          .catch(item.reject);\n      })\n    );\n  }\n  \n  /**\n   * 执行回调并等待完成，然后恢复队列\n   * \n   * @param callback - 回调函数\n   */\n  async processAndResume(callback: () => Promise<void> | void): Promise<void> {\n    if (this.state === QueueState.PROCESSING) {\n      // 如果已经在处理中，等待当前处理完成\n      if (this.processingPromise) {\n        await this.processingPromise;\n      }\n      return;\n    }\n    \n    this.state = QueueState.PROCESSING;\n    \n    try {\n      // 执行回调\n      this.processingPromise = Promise.resolve(callback());\n      await this.processingPromise;\n    } finally {\n      this.processingPromise = null;\n      // 恢复队列\n      await this.resume();\n    }\n  }\n  \n  /**\n   * 将请求添加到队列\n   * \n   * @template TResponse - 响应数据类型\n   * @param options - 请求配置\n   * @param execute - 请求执行函数\n   * @returns Promise 解析为响应对象\n   */\n  async enqueue<TResponse = unknown>(\n    options: RequestOptions<TResponse>,\n    execute: () => Promise<Response<TResponse>>\n  ): Promise<Response<TResponse>> {\n    return new Promise<Response<TResponse>>((resolve, reject) => {\n      this.queue.push({\n        options: options as RequestOptions<unknown>,\n        execute: execute as () => Promise<Response<unknown>>,\n        resolve: resolve as (response: Response<unknown>) => void,\n        reject,\n        timestamp: Date.now(),\n      });\n    });\n  }\n  \n  /**\n   * 获取队列长度\n   */\n  getQueueLength(): number {\n    return this.queue.length;\n  }\n  \n  /**\n   * 清空队列\n   * \n   * @param reason - 清空原因（用于错误信息）\n   */\n  clear(reason?: string): void {\n    const requests = [...this.queue];\n    this.queue = [];\n    \n    // 拒绝所有待执行的请求\n    const error = reason\n      ? new Error(`请求队列已清空: ${reason}`)\n      : new Error('请求队列已清空');\n    \n    requests.forEach((item) => {\n      item.reject(error);\n    });\n    \n    this.state = QueueState.IDLE;\n    this.processingPromise = null;\n  }\n  \n  /**\n   * 销毁管理器\n   */\n  destroy(): void {\n    this.clear('管理器已销毁');\n    RequestQueueManager.instance = null;\n  }\n}\n\n/**\n * 获取请求队列管理器实例\n */\nexport function getRequestQueueManager(): RequestQueueManager {\n  return RequestQueueManager.getInstance();\n}\n"],"names":["getRequestQueueManager","QueueState","RequestQueueManager","getInstance","instance","isPaused","state","pause","resume","requests","queue","Promise","allSettled","map","item","execute","then","resolve","catch","reject","processAndResume","callback","processingPromise","enqueue","options","push","timestamp","Date","now","getQueueLength","length","clear","reason","error","Error","forEach","destroy"],"mappings":"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"}