@taicode/common-base 1.7.3 → 1.7.4

package/output/flow-queue/flow-queue.d.ts

@@ -75,6 +75,8 @@
  * - **流量控制**：可配置任务间延迟，避免资源竞争
  * - **状态追踪**：清晰的成功/失败状态管理
  * - **背压处理**：避免内存溢出的队列管理
+ * - **并发控制**：支持配置并发处理数量，默认为 1
+ * - **链式调用**：支持流畅的链式 API 调用
  */
 type FlowQueueInput = {};
 type FlowQueueOutput = {};
@@ -157,6 +159,7 @@ export type FlowQueueDelayConfig = {
 export type FlowQueueOptions = {
     retry?: FlowQueueRetryConfig;
     delay?: FlowQueueDelayConfig;
+    concurrency?: number;
 };
 /**
  * FlowQueue 流式队列处理器类
@@ -172,7 +175,8 @@ export type FlowQueueOptions = {
  * const queue = new FlowQueue<InputType, OutputType>(
  *   {
  *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
- *     delay: { base: 100, jitter: true }
+ *     delay: { base: 100, jitter: true },
+ *     concurrency: 3 // 支持 3 个并发处理
  *   },
  *   async (input) => {
  *     // 处理逻辑
@@ -180,13 +184,25 @@ export type FlowQueueOptions = {
  *   }
  * );
  *
- * // 添加输入并监听输出
+ * // 传统方式
  * queue.input(data1, data2, data3);
  * queue.onGenerate(result => console.log('处理完成:', result));
- *
- * // 等待所有处理完成
  * queue.closeInput();
  * await queue.awaitCompletion();
+ *
+ * // 链式调用方式
+ * await queue
+ *   .input(data1, data2)
+ *   .input(data3)
+ *   .closeInput()
+ *   .awaitCompletion();
+ *
+ * // 重置并重新开始
+ * await queue
+ *   .reset()
+ *   .input(newData1, newData2)
+ *   .closeInput()
+ *   .awaitCompletion();
  * ```
  */
 export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutput> {
@@ -196,7 +212,7 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
     private processedInputs;
     successOutputs: Map<I, O>;
     erroredOutputs: Map<I, unknown>;
-    private isProcessing;
+    private processingCount;
     private retryCount;
     private onGenerates;
     private isInputClosed;
@@ -212,14 +228,16 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      * - 可以在处理过程中通过 this.input() 动态添加新任务
      * - 支持异步处理，避免阻塞主线程
      * - 失败时会根据重试策略自动重试
+     * - 支持并发处理，默认并发数为 1
      *
      * @example
      * ```typescript
-     * // 处理嵌套文件结构的示例
+     * // 处理嵌套文件结构的示例（单线程）
      * const fileQueue = new FlowQueue<FileNode, ProcessedFile>(
      *   {
      *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
-     *     delay: { base: 100, jitter: true }
+     *     delay: { base: 100, jitter: true },
+     *     concurrency: 1 // 默认值，可省略
      *   },
      *   async (node) => {
      *     try {
@@ -236,6 +254,17 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      *     }
      *   }
      * );
+     *
+     * // 并发处理示例
+     * const concurrentQueue = new FlowQueue<Task, Result>(
+     *   {
+     *     concurrency: 5, // 同时处理 5 个任务
+     *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 }
+     *   },
+     *   async (task) => {
+     *     return await processTask(task);
+     *   }
+     * );
      * ```
      */
     constructor(options: FlowQueueOptions, processor: FlowQueueProcessor<I, O>);
@@ -277,8 +306,10 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      * - 在 processor 函数内部可以动态添加新的输入
      * - 避免了深度递归调用栈
      * - 支持批量添加多个输入
+     * - 支持链式调用
      *
      * @param inputs 要处理的输入数据
+     * @returns 返回 FlowQueue 实例以支持链式调用
      *
      * @example
      * ```typescript
@@ -293,9 +324,15 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      *
      *   return result;
      * };
+     *
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .input(data3)
+     *   .closeInput();
      * ```
      */
-    input(...inputs: I[]): void;
+    input(...inputs: I[]): FlowQueue<I, O>;
     /**
      * 注册输出监听器
      *
@@ -331,9 +368,12 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      * - 队列将不再接受新的输入
      * - 当所有现有输入处理完成后，队列将进入完成状态
      * - 可以通过 awaitCompletion() 等待所有处理完成
+     * - 支持链式调用
      *
      * 在深度循环解耦场景中，这是控制处理边界的重要方法。
      *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
      * @example
      * ```typescript
      * // 添加所有初始数据
@@ -345,9 +385,15 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
      * // 等待所有处理完成
      * await queue.awaitCompletion();
      * console.log('所有数据处理完成');
+     *
+     * // 链式调用示例
+     * await queue
+     *   .input(data1, data2)
+     *   .closeInput()
+     *   .awaitCompletion();
      * ```
      */
-    closeInput(): void;
+    closeInput(): FlowQueue<I, O>;
     /**
      * 返回一个 Promise，代表当前已经标记为输入关闭状态、所有输入都已经处理完毕
      *
@@ -375,14 +421,36 @@ export declare class FlowQueue<I extends FlowQueueInput, O extends FlowQueueOutp
     awaitCompletion(): Promise<void>;
     /**
      * 移除尚未处理的输入并调用 closeInput
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .cancel()
+     *   .reset();
+     * ```
      */
-    cancel(): void;
+    cancel(): FlowQueue<I, O>;
     /**
      * 重置 FlowQueue 到初始状态
      * 清空所有数据，包括待处理、已处理、输出、重试计数等
      * 重置后可以重新开始处理
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .reset()
+     *   .input(newData1, newData2)
+     *   .closeInput();
+     * ```
      */
-    reset(): void;
+    reset(): FlowQueue<I, O>;
     /**
      * 重试所有失败的输入
      *

package/output/flow-queue/flow-queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flow-queue.d.ts","sourceRoot":"","sources":["../../source/flow-queue/flow-queue.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"flow-queue.d.ts","sourceRoot":"","sources":["../../source/flow-queue/flow-queue.ts"],"names":[],"mappings":"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"}

package/output/flow-queue/flow-queue.js

@@ -75,6 +75,8 @@
  * - **流量控制**：可配置任务间延迟，避免资源竞争
  * - **状态追踪**：清晰的成功/失败状态管理
  * - **背压处理**：避免内存溢出的队列管理
+ * - **并发控制**：支持配置并发处理数量，默认为 1
+ * - **链式调用**：支持流畅的链式 API 调用
  */
 import { catchIt } from '../catch';
 function delay(arg0) {
@@ -94,7 +96,8 @@ function delay(arg0) {
  * const queue = new FlowQueue<InputType, OutputType>(
  *   {
  *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
- *     delay: { base: 100, jitter: true }
+ *     delay: { base: 100, jitter: true },
+ *     concurrency: 3 // 支持 3 个并发处理
  *   },
  *   async (input) => {
  *     // 处理逻辑
@@ -102,13 +105,25 @@ function delay(arg0) {
  *   }
  * );
  *
- * // 添加输入并监听输出
+ * // 传统方式
  * queue.input(data1, data2, data3);
  * queue.onGenerate(result => console.log('处理完成:', result));
- *
- * // 等待所有处理完成
  * queue.closeInput();
  * await queue.awaitCompletion();
+ *
+ * // 链式调用方式
+ * await queue
+ *   .input(data1, data2)
+ *   .input(data3)
+ *   .closeInput()
+ *   .awaitCompletion();
+ *
+ * // 重置并重新开始
+ * await queue
+ *   .reset()
+ *   .input(newData1, newData2)
+ *   .closeInput()
+ *   .awaitCompletion();
  * ```
  */
 export class FlowQueue {
@@ -118,7 +133,7 @@ export class FlowQueue {
     processedInputs = []; // 已处理
     successOutputs = new Map();
     erroredOutputs = new Map();
-    isProcessing = false; // 防止并发处理
+    processingCount = 0; // 当前正在处理的任务数量
     retryCount = new Map(); // 记录每个输入的重试次数
     onGenerates = new Map();
     isInputClosed = false; // 标记输入是否已关闭
@@ -134,14 +149,16 @@ export class FlowQueue {
      * - 可以在处理过程中通过 this.input() 动态添加新任务
      * - 支持异步处理，避免阻塞主线程
      * - 失败时会根据重试策略自动重试
+     * - 支持并发处理，默认并发数为 1
      *
      * @example
      * ```typescript
-     * // 处理嵌套文件结构的示例
+     * // 处理嵌套文件结构的示例（单线程）
      * const fileQueue = new FlowQueue<FileNode, ProcessedFile>(
      *   {
      *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
-     *     delay: { base: 100, jitter: true }
+     *     delay: { base: 100, jitter: true },
+     *     concurrency: 1 // 默认值，可省略
      *   },
      *   async (node) => {
      *     try {
@@ -158,6 +175,17 @@ export class FlowQueue {
      *     }
      *   }
      * );
+     *
+     * // 并发处理示例
+     * const concurrentQueue = new FlowQueue<Task, Result>(
+     *   {
+     *     concurrency: 5, // 同时处理 5 个任务
+     *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 }
+     *   },
+     *   async (task) => {
+     *     return await processTask(task);
+     *   }
+     * );
      * ```
      */
     constructor(options, processor) {
@@ -172,6 +200,8 @@ export class FlowQueue {
         this.options.delay.base = this.options.delay.base ?? 0;
         this.options.delay.jitter = this.options.delay.jitter ?? false;
         this.options.delay.jitterRange = this.options.delay.jitterRange ?? 0.1;
+        // 设置并发配置默认值
+        this.options.concurrency = this.options.concurrency ?? 1;
     }
     /**
      * 计算重试延迟时间
@@ -242,7 +272,9 @@ export class FlowQueue {
      * 调度下一个处理任务
      */
     scheduleNextProcessing() {
-        if (this.pendingInputs.length > 0) {
+        // 启动尽可能多的处理任务，直到达到并发限制
+        const tasksToStart = Math.min(this.pendingInputs.length, this.options.concurrency - this.processingCount);
+        for (let i = 0; i < tasksToStart; i++) {
             // 计算任务间延迟
             const taskDelay = this.calculateTaskDelay();
             if (taskDelay > 0) {
@@ -254,10 +286,8 @@ export class FlowQueue {
                 setTimeout(() => this.processFlow(), 0);
             }
         }
-        else {
-            // 没有更多待处理的输入，检查是否已标记为完成
-            this.checkAndTriggerCompletion();
-        }
+        // 检查是否已标记为完成
+        this.checkAndTriggerCompletion();
     }
     /**
      * 延迟执行重试
@@ -265,12 +295,14 @@ export class FlowQueue {
     scheduleRetry(input, delayTime) {
         this.pendingInputs.unshift(input);
         if (delayTime <= 0) {
-            // 立即重试
-            setTimeout(() => this.processFlow(), 0);
+            // 立即重试，启动调度
+            this.scheduleNextProcessing();
         }
         else {
             // 延迟重试
-            setTimeout(() => this.processFlow(), delayTime);
+            setTimeout(() => {
+                this.scheduleNextProcessing();
+            }, delayTime);
         }
     }
     /**
@@ -278,7 +310,7 @@ export class FlowQueue {
      */
     async checkAndTriggerCompletion() {
         await delay(0); // 确保在当前执行栈完成后再检查
-        if (this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing && this.completionResolve) {
+        if (this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0 && this.completionResolve) {
             this.completionResolve();
             this.completionResolve = null;
         }
@@ -290,19 +322,19 @@ export class FlowQueue {
      * 可以设置失败的重试次数，如果超过最大重试次数则不再重试
      */
     async processFlow() {
-        // 如果正在处理或没有待处理的输入，直接返回
-        if (this.isProcessing || this.pendingInputs.length === 0) {
-            // 检查是否已标记为完成且没有待处理的输入
+        // 检查并发限制
+        if (this.processingCount >= this.options.concurrency) {
+            return;
+        }
+        // 取出第一个待处理的输入
+        const input = this.pendingInputs.shift();
+        if (!input) {
             this.checkAndTriggerCompletion();
             return;
         }
-        this.isProcessing = true;
-        const processResult = await catchIt(async () => {
-            // 取出第一个待处理的输入
-            const input = this.pendingInputs.shift();
-            if (!input) {
-                return;
-            }
+        // 增加处理计数
+        this.processingCount++;
+        try {
             // 获取当前输入的重试次数
             const currentRetries = this.retryCount.get(input) || 0;
             // 使用 processor 处理输入
@@ -319,8 +351,6 @@ export class FlowQueue {
                     this.erroredOutputs.set(input, result.error);
                     this.processedInputs.push(input);
                     this.retryCount.delete(input);
-                    // 处理完当前输入后，继续处理下一个（如果有的话）
-                    this.scheduleNextProcessing();
                 }
             }
             else {
@@ -332,17 +362,17 @@ export class FlowQueue {
                 this.erroredOutputs.delete(input);
                 // 通知所有注册的回调
                 await this.notifyOnGenerates(result.value);
-                // 处理完当前输入后，继续处理下一个（如果有的话）
-                this.scheduleNextProcessing();
             }
-        });
-        // 处理 processFlow 中的错误
-        if (processResult.isError()) {
-            console.error('Error in processFlow:', processResult.error);
         }
-        // 确保在任何情况下都重置 isProcessing 状态
-        this.isProcessing = false;
-        this.checkAndTriggerCompletion();
+        catch (error) {
+            console.error('Error in processFlow:', error);
+        }
+        finally {
+            // 减少正在处理的任务计数
+            this.processingCount--;
+            // 处理完当前输入后，尝试启动更多处理任务
+            this.scheduleNextProcessing();
+        }
     }
     /**
      * 通知所有注册的回调函数
@@ -362,8 +392,10 @@ export class FlowQueue {
      * - 在 processor 函数内部可以动态添加新的输入
      * - 避免了深度递归调用栈
      * - 支持批量添加多个输入
+     * - 支持链式调用
      *
      * @param inputs 要处理的输入数据
+     * @returns 返回 FlowQueue 实例以支持链式调用
      *
      * @example
      * ```typescript
@@ -378,13 +410,20 @@ export class FlowQueue {
      *
      *   return result;
      * };
+     *
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .input(data3)
+     *   .closeInput();
      * ```
      */
     input(...inputs) {
         if (this.isInputClosed)
-            return;
+            return this;
         this.pendingInputs.push(...inputs);
         this.processFlow();
+        return this;
     }
     /**
      * 注册输出监听器
@@ -418,7 +457,7 @@ export class FlowQueue {
      * 只读标记，代表是否当前已经 closeInput 并且所有输入都已经处理完毕
      */
     get isCompleted() {
-        return this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing;
+        return this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0;
     }
     /**
      * 标记当前 FlowQueue 不会再有新的输入了
@@ -427,9 +466,12 @@ export class FlowQueue {
      * - 队列将不再接受新的输入
      * - 当所有现有输入处理完成后，队列将进入完成状态
      * - 可以通过 awaitCompletion() 等待所有处理完成
+     * - 支持链式调用
      *
      * 在深度循环解耦场景中，这是控制处理边界的重要方法。
      *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
      * @example
      * ```typescript
      * // 添加所有初始数据
@@ -441,12 +483,19 @@ export class FlowQueue {
      * // 等待所有处理完成
      * await queue.awaitCompletion();
      * console.log('所有数据处理完成');
+     *
+     * // 链式调用示例
+     * await queue
+     *   .input(data1, data2)
+     *   .closeInput()
+     *   .awaitCompletion();
      * ```
      */
     closeInput() {
         this.isInputClosed = true;
         // 使用统一的完成检查方法
         this.checkAndTriggerCompletion();
+        return this;
     }
     /**
      * 返回一个 Promise，代表当前已经标记为输入关闭状态、所有输入都已经处理完毕
@@ -476,8 +525,8 @@ export class FlowQueue {
         if (this.completionPromise) {
             return this.completionPromise;
         }
-        // 如果已经标记为输入关闭且没有待处理的输入，立即返回 resolved Promise
-        if (this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing) {
+        // 如果已经标记为输入关闭且没有待处理的输入和正在处理的任务，立即返回 resolved Promise
+        if (this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0) {
             console.log('所有输入已处理完毕');
             return Promise.resolve();
         }
@@ -492,6 +541,17 @@ export class FlowQueue {
     }
     /**
      * 移除尚未处理的输入并调用 closeInput
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .cancel()
+     *   .reset();
+     * ```
      */
     cancel() {
         // 清除所有待处理的输入
@@ -500,11 +560,23 @@ export class FlowQueue {
         this.retryCount.clear();
         // 标记输入已关闭
         this.closeInput();
+        return this;
     }
     /**
      * 重置 FlowQueue 到初始状态
      * 清空所有数据，包括待处理、已处理、输出、重试计数等
      * 重置后可以重新开始处理
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .reset()
+     *   .input(newData1, newData2)
+     *   .closeInput();
+     * ```
      */
     reset() {
         // 清空所有队列和状态
@@ -514,7 +586,7 @@ export class FlowQueue {
         this.pendingInputs.length = 0;
         this.processedInputs.length = 0;
         // 重置处理状态
-        this.isProcessing = false;
+        this.processingCount = 0;
         this.isInputClosed = false;
         // 重置完成状态
         if (this.completionResolve) {
@@ -522,6 +594,7 @@ export class FlowQueue {
             this.completionResolve = null;
         }
         this.completionPromise = null;
+        return this;
     }
     /**
      * 重试所有失败的输入