@vlian/framework 1.1.0 → 1.1.1

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * @vlian/framework v1.1.0
+ * @vlian/framework v1.1.1
  * Secra Framework - 一个现代化的低代码框架
  * (c) 2026 Secra Framework Contributors
  * Licensed under Apache-2.0
@@ -37097,6 +37097,173 @@
       });
   }
 
+  /**
+   * 请求队列管理器
+   *
+   * 用于管理待执行的请求队列，支持请求拦截、暂停、恢复等功能
+   */
+  /**
+   * 队列状态
+   */
+  var QueueState;
+  (function (QueueState) {
+      /**
+       * 正常状态，请求可以正常执行
+       */
+      QueueState["IDLE"] = "idle";
+      /**
+       * 暂停状态，请求会被放入队列
+       */
+      QueueState["PAUSED"] = "paused";
+      /**
+       * 处理中状态，正在执行回调
+       */
+      QueueState["PROCESSING"] = "processing";
+  })(QueueState || (QueueState = {}));
+  /**
+   * 请求队列管理器
+   */
+  class RequestQueueManager {
+      constructor() {
+          /**
+           * 待执行的请求队列
+           */
+          this.queue = [];
+          /**
+           * 队列状态
+           */
+          this.state = QueueState.IDLE;
+          /**
+           * 当前正在执行的回调 Promise
+           */
+          this.processingPromise = null;
+      }
+      /**
+       * 获取单例实例
+       */
+      static getInstance() {
+          if (!RequestQueueManager.instance) {
+              RequestQueueManager.instance = new RequestQueueManager();
+          }
+          return RequestQueueManager.instance;
+      }
+      /**
+       * 检查队列是否处于暂停状态
+       */
+      isPaused() {
+          return this.state === QueueState.PAUSED || this.state === QueueState.PROCESSING;
+      }
+      /**
+       * 暂停队列，后续请求会被放入队列
+       */
+      pause() {
+          if (this.state === QueueState.IDLE) {
+              this.state = QueueState.PAUSED;
+          }
+      }
+      /**
+       * 恢复队列，执行队列中的所有请求
+       */
+      async resume() {
+          if (this.state === QueueState.IDLE) {
+              return;
+          }
+          this.state = QueueState.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 === QueueState.PROCESSING) {
+              // 如果已经在处理中，等待当前处理完成
+              if (this.processingPromise) {
+                  await this.processingPromise;
+              }
+              return;
+          }
+          this.state = QueueState.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 = QueueState.IDLE;
+          this.processingPromise = null;
+      }
+      /**
+       * 销毁管理器
+       */
+      destroy() {
+          this.clear('管理器已销毁');
+          RequestQueueManager.instance = null;
+      }
+  }
+  RequestQueueManager.instance = null;
+  /**
+   * 获取请求队列管理器实例
+   */
+  function getRequestQueueManager() {
+      return RequestQueueManager.getInstance();
+  }
+
   /**
    * 请求客户端核心实现
    *
@@ -37362,8 +37529,24 @@
           }
           // 合并配置
           const mergedOptions = this.mergeOptions(options);
+          // 检查队列状态，如果队列已暂停，将请求放入队列
+          const queueManager = getRequestQueueManager();
+          if (queueManager.isPaused()) {
+              return queueManager.enqueue(mergedOptions, () => this.executeRequest(mergedOptions));
+          }
+          // 正常执行请求
+          return this.executeRequest(mergedOptions);
+      }
+      /**
+       * 执行实际的请求逻辑
+       *
+       * @template TResponse - 响应数据类型
+       * @param options - 请求配置选项
+       * @returns Promise 解析为响应对象
+       */
+      async executeRequest(options) {
           // 创建请求上下文
-          const context = createRequestContext(mergedOptions, {});
+          const context = createRequestContext(options, {});
           try {
               // 执行请求前钩子
               const beforeResult = await this.pluginManager.executeHook(exports.PluginLifecycleStage.BEFORE_REQUEST, context);
@@ -37382,6 +37565,9 @@
               // 执行请求
               let response;
               try {
+                  if (!this.adapter) {
+                      throw new Error('适配器未初始化');
+                  }
                   response = await this.adapter.request(context.request);
               }
               catch (error) {