@taicode/common-base 1.7.3 → 1.7.5

package/output/error/error.test.js

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { UserError, SystemError, UnknownError } from './error';
+import { UserError, SystemError } from './error';
 describe('UserError', () => {
     describe('constructor', () => {
         it('应该正确创建UserError实例', () => {
             const type = 'VALIDATION_ERROR';
             const message = '输入验证失败';
-            const error = new UserError(type, message);
+            const error = new UserError(type, undefined, message);
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(UserError);
             expect(error.name).toBe('UserError');
@@ -32,7 +32,7 @@ describe('UserError', () => {
         });
         it('应该在提供空字符串message时保持空字符串', () => {
             const type = 'VALIDATION_ERROR';
-            const error = new UserError(type, '');
+            const error = new UserError(type, {}, '');
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(UserError);
             expect(error.name).toBe('UserError');
@@ -43,34 +43,32 @@ describe('UserError', () => {
             const type = 'VALIDATION_ERROR';
             const message = '输入验证失败';
             const cause = new Error('原始错误');
-            const error = new UserError(type, message, { cause });
+            const error = new UserError(type, { cause }, message);
             expect(error.cause).toBe(cause);
         });
         it('应该支持ErrorOptions参数且message为可选', () => {
             const type = 'VALIDATION_ERROR';
             const cause = new Error('原始错误');
-            const error = new UserError(type, undefined, { cause });
+            const error = new UserError(type, { cause });
             expect(error.cause).toBe(cause);
             expect(error.message).toBe('');
         });
         it('应该正确设置错误堆栈信息', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(error.stack).toBeDefined();
             expect(error.stack).toContain('UserError');
         });
     });
     describe('is', () => {
         it('应该正确识别UserError实例', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(UserError.is(error)).toBe(true);
         });
         it('应该正确识别非UserError实例', () => {
             const regularError = new Error('普通错误');
-            const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
-            const unknownError = new UnknownError('未知错误');
+            const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
             expect(UserError.is(regularError)).toBe(false);
             expect(UserError.is(systemError)).toBe(false);
-            expect(UserError.is(unknownError)).toBe(false);
             expect(UserError.is(null)).toBe(false);
             expect(UserError.is(undefined)).toBe(false);
             expect(UserError.is('字符串')).toBe(false);
@@ -78,7 +76,7 @@ describe('UserError', () => {
             expect(UserError.is({})).toBe(false);
         });
         it('应该支持类型守卫功能', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             if (UserError.is(error)) {
                 // 在类型守卫内部，error的类型应该被正确推断
                 expect(error.type).toBe('TEST_ERROR');
@@ -89,13 +87,13 @@ describe('UserError', () => {
     });
     describe('继承行为', () => {
         it('应该正确继承Error的所有属性和方法', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(error.toString()).toContain('测试错误');
             expect(error.toString()).toContain('UserError');
             expect(error instanceof Error).toBe(true);
         });
         it('应该支持Error的标准用法', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             try {
                 throw error;
             }
@@ -111,7 +109,7 @@ describe('SystemError', () => {
         it('应该正确创建SystemError实例', () => {
             const type = 'DATABASE_ERROR';
             const message = '数据库连接失败';
-            const error = new SystemError(type, message);
+            const error = new SystemError(type, undefined, message);
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(SystemError);
             expect(error.name).toBe('SystemError');
@@ -138,7 +136,7 @@ describe('SystemError', () => {
         });
         it('应该在提供空字符串message时保持空字符串', () => {
             const type = 'DATABASE_ERROR';
-            const error = new SystemError(type, '');
+            const error = new SystemError(type, {}, '');
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(SystemError);
             expect(error.name).toBe('SystemError');
@@ -149,34 +147,32 @@ describe('SystemError', () => {
             const type = 'NETWORK_ERROR';
             const message = '网络请求失败';
             const cause = new Error('连接超时');
-            const error = new SystemError(type, message, { cause });
+            const error = new SystemError(type, { cause }, message);
             expect(error.cause).toBe(cause);
         });
         it('应该支持ErrorOptions参数且message为可选', () => {
             const type = 'NETWORK_ERROR';
             const cause = new Error('连接超时');
-            const error = new SystemError(type, undefined, { cause });
+            const error = new SystemError(type, { cause });
             expect(error.cause).toBe(cause);
             expect(error.message).toBe('');
         });
         it('应该正确设置错误堆栈信息', () => {
-            const error = new SystemError('FILE_ERROR', '文件读取失败');
+            const error = new SystemError('FILE_ERROR', undefined, '文件读取失败');
             expect(error.stack).toBeDefined();
             expect(error.stack).toContain('SystemError');
         });
     });
     describe('is', () => {
         it('应该正确识别SystemError实例', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             expect(SystemError.is(error)).toBe(true);
         });
         it('应该正确识别非SystemError实例', () => {
             const regularError = new Error('普通错误');
-            const userError = new UserError('USER_ERROR', '用户错误');
-            const unknownError = new UnknownError('未知错误');
+            const userError = new UserError('USER_ERROR', undefined, '用户错误');
             expect(SystemError.is(regularError)).toBe(false);
             expect(SystemError.is(userError)).toBe(false);
-            expect(SystemError.is(unknownError)).toBe(false);
             expect(SystemError.is(null)).toBe(false);
             expect(SystemError.is(undefined)).toBe(false);
             expect(SystemError.is('字符串')).toBe(false);
@@ -184,7 +180,7 @@ describe('SystemError', () => {
             expect(SystemError.is({})).toBe(false);
         });
         it('应该支持类型守卫功能', () => {
-            const error = new SystemError('DATABASE_ERROR', '数据库错误');
+            const error = new SystemError('DATABASE_ERROR', undefined, '数据库错误');
             if (SystemError.is(error)) {
                 // 在类型守卫内部，error的类型应该被正确推断
                 expect(error.type).toBe('DATABASE_ERROR');
@@ -195,13 +191,13 @@ describe('SystemError', () => {
     });
     describe('继承行为', () => {
         it('应该正确继承Error的所有属性和方法', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             expect(error.toString()).toContain('测试错误');
             expect(error.toString()).toContain('SystemError');
             expect(error instanceof Error).toBe(true);
         });
         it('应该支持Error的标准用法', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             try {
                 throw error;
             }
@@ -212,99 +208,176 @@ describe('SystemError', () => {
         });
     });
 });
-describe('UnknownError', () => {
-    describe('constructor', () => {
-        it('应该正确创建UnknownError实例', () => {
-            const message = '发生了未知错误';
-            const error = new UnknownError(message);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(UnknownError);
-            expect(error.name).toBe('UnknownError');
-            expect(error.message).toBe(message);
-        });
-        it('应该支持ErrorOptions参数', () => {
-            const message = '未知错误';
-            const cause = new Error('原始未知错误');
-            const error = new UnknownError(message, { cause });
-            expect(error.cause).toBe(cause);
-        });
-        it('应该正确设置错误堆栈信息', () => {
-            const error = new UnknownError('测试未知错误');
-            expect(error.stack).toBeDefined();
-            expect(error.stack).toContain('UnknownError');
-        });
-    });
-    describe('is', () => {
-        it('应该正确识别UnknownError实例', () => {
-            const error = new UnknownError('测试错误');
-            expect(UnknownError.is(error)).toBe(true);
-        });
-        it('应该正确识别非UnknownError实例', () => {
-            const regularError = new Error('普通错误');
-            const userError = new UserError('USER_ERROR', '用户错误');
-            const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
-            expect(UnknownError.is(regularError)).toBe(false);
-            expect(UnknownError.is(userError)).toBe(false);
-            expect(UnknownError.is(systemError)).toBe(false);
-            expect(UnknownError.is(null)).toBe(false);
-            expect(UnknownError.is(undefined)).toBe(false);
-            expect(UnknownError.is('字符串')).toBe(false);
-            expect(UnknownError.is(123)).toBe(false);
-            expect(UnknownError.is({})).toBe(false);
-        });
-    });
-    describe('继承行为', () => {
-        it('应该正确继承Error的所有属性和方法', () => {
-            const error = new UnknownError('测试错误');
-            expect(error.toString()).toContain('测试错误');
-            expect(error instanceof Error).toBe(true);
-        });
-        it('应该支持Error的标准用法', () => {
-            const error = new UnknownError('测试错误');
-            try {
-                throw error;
-            }
-            catch (caught) {
-                expect(caught).toBe(error);
-                expect(caught).toBeInstanceOf(UnknownError);
-            }
-        });
-    });
-});
 describe('错误类型区分', () => {
-    it('三种错误类型应该是不同的类', () => {
-        const userError = new UserError('USER_ERROR', '用户错误');
-        const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
-        const unknownError = new UnknownError('未知错误');
+    it('两种错误类型应该是不同的类', () => {
+        const userError = new UserError('USER_ERROR', undefined, '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
         // 每种错误只能被自己的类型检查函数识别
         expect(UserError.is(userError)).toBe(true);
         expect(SystemError.is(userError)).toBe(false);
-        expect(UnknownError.is(userError)).toBe(false);
         expect(UserError.is(systemError)).toBe(false);
         expect(SystemError.is(systemError)).toBe(true);
-        expect(UnknownError.is(systemError)).toBe(false);
-        expect(UserError.is(unknownError)).toBe(false);
-        expect(SystemError.is(unknownError)).toBe(false);
-        expect(UnknownError.is(unknownError)).toBe(true);
     });
     it('所有错误类型都应该是Error的实例', () => {
-        const userError = new UserError('USER_ERROR', '用户错误');
-        const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
-        const unknownError = new UnknownError('未知错误');
+        const userError = new UserError('USER_ERROR', undefined, '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
         expect(userError instanceof Error).toBe(true);
         expect(systemError instanceof Error).toBe(true);
-        expect(unknownError instanceof Error).toBe(true);
     });
 });
 describe('泛型类型支持', () => {
     it('UserError应该支持字符串字面量类型', () => {
-        const error = new UserError('REQUIRED_FIELD', '字段必填');
+        const error = new UserError('REQUIRED_FIELD', {}, '字段必填');
         expect(error.type).toBe('REQUIRED_FIELD');
         expect(UserError.is(error)).toBe(true);
     });
     it('SystemError应该支持字符串字面量类型', () => {
-        const error = new SystemError('DATABASE_ERROR', '数据库连接失败');
+        const error = new SystemError('DATABASE_ERROR', {}, '数据库连接失败');
         expect(error.type).toBe('DATABASE_ERROR');
         expect(SystemError.is(error)).toBe(true);
     });
 });
+describe('define 工厂方法', () => {
+    describe('UserError.define', () => {
+        it('应该定义一个绑定了特定错误类型的 UserError 类', () => {
+            const MyUserError = UserError.define({
+                'validation-failed': {},
+                'permission-denied': {},
+                'not-found': {}
+            });
+            const error = new MyUserError('validation-failed', {
+                field: 'email',
+                value: 'invalid@'
+            }, '验证失败');
+            expect(error).toBeInstanceOf(Error);
+            expect(error.name).toBe('UserError');
+            expect(error.type).toBe('validation-failed');
+            expect(error.message).toBe('验证失败');
+            expect(error.context).toEqual({ field: 'email', value: 'invalid@' });
+        });
+        it('应该支持 is 类型守卫', () => {
+            const MyUserError = UserError.define({
+                'test-error': {}
+            });
+            const error = new MyUserError('test-error', { code: 123 }, '测试错误');
+            expect(MyUserError.is(error)).toBe(true);
+            expect(MyUserError.is(new Error('普通错误'))).toBe(false);
+            expect(MyUserError.is(null)).toBe(false);
+        });
+        it('应该支持多次调用 define 定义不同的错误类', () => {
+            const ValidationError = UserError.define({
+                'required': {},
+                'invalid': {}
+            });
+            const AuthError = UserError.define({
+                'unauthorized': {},
+                'forbidden': {}
+            });
+            const validationError = new ValidationError('required', { field: 'username' }, '必填字段');
+            const authError = new AuthError('unauthorized', { reason: 'token expired' }, '未授权');
+            expect(validationError.type).toBe('required');
+            expect(authError.type).toBe('unauthorized');
+            expect(ValidationError.is(validationError)).toBe(true);
+            expect(ValidationError.is(authError)).toBe(false); // 不同的类不会互相识别
+            expect(AuthError.is(authError)).toBe(true);
+            expect(AuthError.is(validationError)).toBe(false); // 不同的类不会互相识别
+        });
+        it('应该支持不传 context 参数', () => {
+            const MyUserError = UserError.define({
+                'simple-error': {}
+            });
+            const error = new MyUserError('simple-error', undefined, '简单错误');
+            expect(error.type).toBe('simple-error');
+            expect(error.message).toBe('简单错误');
+            expect(error.context).toBeUndefined();
+        });
+        it('应该支持不传 message 参数', () => {
+            const MyUserError = UserError.define({
+                'no-message': {}
+            });
+            const error = new MyUserError('no-message');
+            expect(error.type).toBe('no-message');
+            expect(error.message).toBe('');
+        });
+        it('应该暴露所有定义的错误类型', () => {
+            const MyUserError = UserError.define({
+                'validation-failed': {},
+                'permission-denied': {},
+                'not-found': {}
+            });
+            expect(MyUserError.types).toEqual(['validation-failed', 'permission-denied', 'not-found']);
+            expect(MyUserError.types).toHaveLength(3);
+        });
+    });
+    describe('SystemError.define', () => {
+        it('应该定义一个绑定了特定错误类型的 SystemError 类', () => {
+            const MySystemError = SystemError.define({
+                'database-error': {},
+                'network-error': {},
+                'service-unavailable': {}
+            });
+            const error = new MySystemError('database-error', {
+                query: 'SELECT * FROM users',
+                table: 'users'
+            }, '数据库错误');
+            expect(error).toBeInstanceOf(Error);
+            expect(error.name).toBe('SystemError');
+            expect(error.type).toBe('database-error');
+            expect(error.message).toBe('数据库错误');
+            expect(error.context).toEqual({ query: 'SELECT * FROM users', table: 'users' });
+        });
+        it('应该支持 is 类型守卫', () => {
+            const MySystemError = SystemError.define({
+                'test-error': {}
+            });
+            const error = new MySystemError('test-error', { code: 500 }, '测试错误');
+            expect(MySystemError.is(error)).toBe(true);
+            expect(MySystemError.is(new Error('普通错误'))).toBe(false);
+            expect(MySystemError.is(null)).toBe(false);
+        });
+        it('应该支持多次调用 define 定义不同的错误类', () => {
+            const DatabaseError = SystemError.define({
+                'connection-failed': {},
+                'query-timeout': {}
+            });
+            const NetworkError = SystemError.define({
+                'request-failed': {},
+                'timeout': {}
+            });
+            const dbError = new DatabaseError('connection-failed', { host: 'localhost', port: 5432 }, '连接失败');
+            const netError = new NetworkError('request-failed', { url: '/api/data', method: 'GET' }, '请求失败');
+            expect(dbError.type).toBe('connection-failed');
+            expect(netError.type).toBe('request-failed');
+            expect(DatabaseError.is(dbError)).toBe(true);
+            expect(DatabaseError.is(netError)).toBe(false); // 不同的类不会互相识别
+            expect(NetworkError.is(netError)).toBe(true);
+            expect(NetworkError.is(dbError)).toBe(false); // 不同的类不会互相识别
+        });
+        it('应该支持不传 context 参数', () => {
+            const MySystemError = SystemError.define({
+                'simple-error': {}
+            });
+            const error = new MySystemError('simple-error', undefined, '简单错误');
+            expect(error.type).toBe('simple-error');
+            expect(error.message).toBe('简单错误');
+            expect(error.context).toBeUndefined();
+        });
+        it('应该支持不传 message 参数', () => {
+            const MySystemError = SystemError.define({
+                'no-message': {}
+            });
+            const error = new MySystemError('no-message');
+            expect(error.type).toBe('no-message');
+            expect(error.message).toBe('');
+        });
+        it('应该暴露所有定义的错误类型', () => {
+            const MySystemError = SystemError.define({
+                'database-error': {},
+                'network-error': {},
+                'service-unavailable': {}
+            });
+            expect(MySystemError.types).toEqual(['database-error', 'network-error', 'service-unavailable']);
+            expect(MySystemError.types).toHaveLength(3);
+        });
+    });
+});

package/output/error/index.d.ts

@@ -1,2 +1,3 @@
-export { UserError, SystemError, UnknownError, UserErrorTypes, SystemErrorTypes, UserErrorType, SystemErrorType, UserErrorContext, SystemErrorContext } from './error';
+export { UserError, SystemError } from './error';
+export type { ErrorContext } from './error';
 //# sourceMappingURL=index.d.ts.map

package/output/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACX,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB,YAAY,EACV,YAAY,EACb,MAAM,SAAS,CAAA"}

package/output/error/index.js

@@ -1 +1 @@
-export { UserError, SystemError, UnknownError } from './error';
+export { UserError, SystemError } from './error';

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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"}