@taicode/common-base 1.7.1 → 1.7.3

package/output/batching-buffer/batching-buffer.d.ts

@@ -25,12 +25,6 @@ export interface BatchingBufferOptions<T> {
      * @default true
      */
     autoFlush?: boolean;
-    /**
-     * 错误处理回调函数
-     * @param error 发生的错误
-     * @param failedItems 处理失败的项目
-     */
-    onError?: (error: Error, failedItems: T[]) => void;
 }
 /**
  * 批处理缓冲区
@@ -48,11 +42,7 @@ export interface BatchingBufferOptions<T> {
  *     await saveToDatabase(items)
  *   },
  *   bufferSize: 10,
- *   flushInterval: 5000,
- *   onError: (error, failedItems) => {
- *     console.error('处理失败:', error, '失败项目:', failedItems)
- *     // 可以进行重试或其他错误处理逻辑
- *   }
+ *   flushInterval: 5000
  * })
  *
  * // 单个处理模式
@@ -66,9 +56,8 @@ export interface BatchingBufferOptions<T> {
  * })
  *
  * // 添加数据
- * buffer.add('data1')                    // 添加单个数据
- * buffer.add('data2', 'data3', 'data4')  // 添加多个数据
- * buffer.add(...array)                   // 展开数组添加
+ * buffer.add('data1')
+ * buffer.add('data2')
  *
  * // 手动刷新
  * await buffer.flush()
@@ -87,13 +76,17 @@ export declare class BatchingBuffer<T> {
     private readonly bufferSize;
     private readonly flushInterval;
     private readonly autoFlush;
-    private readonly onError?;
     constructor(options: BatchingBufferOptions<T>);
     /**
      * 添加数据到缓冲区
-     * @param items 要添加的数据项
+     * @param item 要添加的数据项
+     */
+    add(item: T): void;
+    /**
+     * 批量添加数据到缓冲区
+     * @param items 要添加的数据项数组
      */
-    add(...items: T[]): void;
+    addBatch(items: T[]): void;
     /**
      * 手动刷新缓冲区，处理所有待处理的数据
      * @returns Promise，在处理完成后 resolve

package/output/batching-buffer/batching-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batching-buffer.d.ts","sourceRoot":"","sources":["../../source/batching-buffer/batching-buffer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAEjD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAA;CACnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC3B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAsC;IACtE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAmC;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA0C;gBAEvD,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;IA2B7C;;;OAGG;IACH,GAAG,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAiCxB;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACH,IAAI,kBAAkB,IAAI,MAAM,CAE/B;IAED;;;OAGG;IACG,OAAO,CAAC,cAAc,GAAE,OAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB5D;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgEzB;;OAEG;YACW,kBAAkB;CA2BjC"}
+{"version":3,"file":"batching-buffer.d.ts","sourceRoot":"","sources":["../../source/batching-buffer/batching-buffer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAEjD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC3B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAsC;IACtE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAmC;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;IA0B7C;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAmBlB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAyB1B;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACH,IAAI,kBAAkB,IAAI,MAAM,CAE/B;IAED;;;OAGG;IACG,OAAO,CAAC,cAAc,GAAE,OAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB5D;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;OAEG;YACW,kBAAkB;CA2BjC"}

package/output/batching-buffer/batching-buffer.js

@@ -14,11 +14,7 @@
  *     await saveToDatabase(items)
  *   },
  *   bufferSize: 10,
- *   flushInterval: 5000,
- *   onError: (error, failedItems) => {
- *     console.error('处理失败:', error, '失败项目:', failedItems)
- *     // 可以进行重试或其他错误处理逻辑
- *   }
+ *   flushInterval: 5000
  * })
  *
  * // 单个处理模式
@@ -32,9 +28,8 @@
  * })
  *
  * // 添加数据
- * buffer.add('data1')                    // 添加单个数据
- * buffer.add('data2', 'data3', 'data4')  // 添加多个数据
- * buffer.add(...array)                   // 展开数组添加
+ * buffer.add('data1')
+ * buffer.add('data2')
  *
  * // 手动刷新
  * await buffer.flush()
@@ -53,7 +48,6 @@ export class BatchingBuffer {
     bufferSize;
     flushInterval;
     autoFlush;
-    onError;
     constructor(options) {
         // 验证处理器配置
         if (!options.batchProcessor && !options.itemProcessor) {
@@ -67,7 +61,6 @@ export class BatchingBuffer {
         this.bufferSize = options.bufferSize ?? 100;
         this.flushInterval = options.flushInterval ?? 5000;
         this.autoFlush = options.autoFlush ?? true;
-        this.onError = options.onError;
         // 验证配置参数
         if (this.bufferSize <= 0) {
             throw new Error('bufferSize 必须大于 0');
@@ -78,33 +71,46 @@ export class BatchingBuffer {
     }
     /**
      * 添加数据到缓冲区
-     * @param items 要添加的数据项
+     * @param item 要添加的数据项
      */
-    add(...items) {
+    add(item) {
         if (this.isDestroyed) {
             throw new Error('BatchingBuffer 已被销毁，不能添加新数据');
         }
-        if (items.length === 0) {
+        this.buffer.push(item);
+        // 检查是否需要基于大小触发处理
+        if (this.buffer.length >= this.bufferSize) {
+            this.processBufferSync();
             return;
         }
+        // 启动或重置定时器
+        if (this.autoFlush) {
+            this.resetTimer();
+        }
+    }
+    /**
+     * 批量添加数据到缓冲区
+     * @param items 要添加的数据项数组
+     */
+    addBatch(items) {
+        if (this.isDestroyed) {
+            throw new Error('BatchingBuffer 已被销毁，不能添加新数据');
+        }
         let i = 0;
         while (i < items.length) {
-            // 计算本次可以添加的数量
-            const remainingBufferSpace = this.bufferSize - this.buffer.length;
-            const itemsToAdd = Math.min(remainingBufferSpace, items.length - i);
-            // 添加数据到缓冲区
-            for (let j = 0; j < itemsToAdd; j++) {
-                this.buffer.push(items[i + j]);
+            // 填充缓冲区直到达到大小限制
+            while (i < items.length && this.buffer.length < this.bufferSize) {
+                this.buffer.push(items[i]);
+                i++;
             }
-            i += itemsToAdd;
             // 如果缓冲区满了，处理它
             if (this.buffer.length >= this.bufferSize) {
                 this.processBufferSync();
             }
         }
-        // 为剩余数据启动定时器（如果还有数据且启用自动刷新）
-        if (this.buffer.length > 0 && this.autoFlush) {
-            this.resetTimer();
+        // 处理剩余的项目（如果有的话）
+        if (this.buffer.length > 0) {
+            this.processBufferSync();
         }
     }
     /**
@@ -188,44 +194,29 @@ export class BatchingBuffer {
                 const result = this.batchProcessor(itemsToProcess);
                 // 如果返回 Promise，处理异步
                 if (result && typeof result.then === 'function') {
-                    result.catch((error) => {
-                        // 处理失败时，将数据重新放回缓冲区开头（如果没有被销毁）
-                        if (!this.isDestroyed) {
-                            this.buffer.unshift(...itemsToProcess);
-                        }
-                        // 调用错误处理回调
-                        if (this.onError) {
-                            this.onError(error, itemsToProcess);
-                        }
+                    result.catch(() => {
+                        // 处理失败时，将数据重新放回缓冲区开头
+                        this.buffer.unshift(...itemsToProcess);
                     });
                 }
             }
             else if (this.itemProcessor) {
                 // 单个处理模式 - 同步处理每个项目
-                const failedItems = [];
                 for (let i = 0; i < itemsToProcess.length; i++) {
                     const item = itemsToProcess[i];
                     try {
                         const result = this.itemProcessor(item);
                         // 如果返回 Promise，处理异步
                         if (result && typeof result.then === 'function') {
-                            result.catch((error) => {
-                                // 处理失败时，将数据重新放回缓冲区开头（如果没有被销毁）
-                                if (!this.isDestroyed) {
-                                    this.buffer.unshift(item);
-                                }
-                                // 调用错误处理回调
-                                if (this.onError) {
-                                    this.onError(error, [item]);
-                                }
+                            result.catch(() => {
+                                // 处理失败时，将数据重新放回缓冲区开头
+                                this.buffer.unshift(item);
                             });
                         }
                     }
                     catch (error) {
-                        // 同步错误处理 - 把当前项目和未处理的项目放回缓冲区
-                        failedItems.push(item);
-                        failedItems.push(...itemsToProcess.slice(i + 1));
-                        this.buffer.unshift(...failedItems);
+                        // 同步错误处理 - 只把未处理的项目放回缓冲区
+                        this.buffer.unshift(...itemsToProcess.slice(i));
                         throw error;
                     }
                 }

package/output/batching-buffer/batching-buffer.test.js

@@ -122,32 +122,12 @@ describe('BatchingBuffer', () => {
             expect(buffer.size).toBe(0);
         });
         it('应该支持批量添加数据', () => {
-            buffer.add('item1', 'item2', 'item3', 'item4', 'item5');
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            buffer.addBatch(['item1', 'item2', 'item3', 'item4', 'item5']);
+            expect(batchProcessor).toHaveBeenCalledTimes(2);
             expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
-            // 剩余的项目应该在缓冲区中
-            expect(buffer.size).toBe(2);
-        });
-        it('应该支持添加空参数', () => {
-            buffer.add();
-            expect(batchProcessor).not.toHaveBeenCalled();
-            expect(buffer.size).toBe(0);
-        });
-        it('应该支持混合添加单个和多个数据', () => {
-            buffer.add('item1'); // 单个
-            buffer.add('item2', 'item3'); // 多个
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2', 'item3']);
+            expect(batchProcessor).toHaveBeenNthCalledWith(2, ['item4', 'item5']);
             expect(buffer.size).toBe(0);
         });
-        it('应该支持使用数组展开语法', () => {
-            const items = ['item1', 'item2', 'item3', 'item4', 'item5'];
-            buffer.add(...items);
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
-            // 剩余的项目应该在缓冲区中
-            expect(buffer.size).toBe(2);
-        });
         it('应该正确处理处理器异常', () => {
             const error = new Error('处理失败');
             batchProcessor.mockImplementationOnce(() => {
@@ -236,11 +216,10 @@ describe('BatchingBuffer', () => {
         it('应该正确报告距离上次刷新的时间', async () => {
             const startTime = Date.now();
             buffer.add(1);
-            // 使用假定时器来精确控制时间
             vi.advanceTimersByTime(500);
-            expect(buffer.timeSinceLastFlush).toBe(500);
+            expect(buffer.timeSinceLastFlush).toBeGreaterThanOrEqual(500);
             await buffer.flush();
-            expect(buffer.timeSinceLastFlush).toBe(0);
+            expect(buffer.timeSinceLastFlush).toBeLessThan(100);
         });
     });
     describe('销毁功能', () => {
@@ -275,7 +254,7 @@ describe('BatchingBuffer', () => {
                 buffer.add('item1');
             }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
             expect(() => {
-                buffer.add('item1', 'item2');
+                buffer.addBatch(['item1', 'item2']);
             }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
         });
         it('应该支持重复销毁', async () => {
@@ -314,45 +293,6 @@ describe('BatchingBuffer', () => {
             expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
             await buffer.destroy();
         });
-        it('应该正确处理定时器重置', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 1000,
-                autoFlush: true
-            });
-            // 添加第一个项目，启动定时器
-            buffer.add('item1');
-            vi.advanceTimersByTime(500);
-            // 添加第二个项目，应该重置定时器
-            buffer.add('item2');
-            vi.advanceTimersByTime(500);
-            // 此时应该还没触发（总共过了1000ms，但最后一次重置后只过了500ms）
-            expect(batchProcessor).not.toHaveBeenCalled();
-            // 再等500ms，现在应该触发了
-            vi.advanceTimersByTime(500);
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            await buffer.destroy();
-        });
-        it('应该在销毁时清除定时器避免内存泄漏', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 1000,
-                autoFlush: true
-            });
-            buffer.add('item1');
-            // 立即销毁，应该处理剩余数据但不会因为定时器再次触发
-            await buffer.destroy();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            // 等待原本的定时器时间，不应该再次触发
-            vi.advanceTimersByTime(1000);
-            await vi.runAllTimersAsync();
-            // 仍然只被调用一次
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-        });
     });
     describe('复杂数据类型', () => {
         let buffer;
@@ -381,11 +321,11 @@ describe('BatchingBuffer', () => {
         let asyncItemProcessor;
         beforeEach(() => {
             asyncBatchProcessor = vi.fn().mockImplementation(async (items) => {
-                // 使用 fake timer 而不是真实的 setTimeout
+                await new Promise(resolve => setTimeout(resolve, 100));
                 return `处理了 ${items.length} 个项目`;
             });
             asyncItemProcessor = vi.fn().mockImplementation(async (item) => {
-                // 使用 fake timer 而不是真实的 setTimeout
+                await new Promise(resolve => setTimeout(resolve, 50));
                 return `处理了项目: ${item}`;
             });
         });
@@ -415,97 +355,4 @@ describe('BatchingBuffer', () => {
             buffer.destroy();
         });
     });
-    describe('错误处理回调', () => {
-        it('应该支持配置错误处理回调', () => {
-            const onError = vi.fn();
-            const buffer = new BatchingBuffer({
-                batchProcessor: vi.fn(),
-                bufferSize: 10,
-                flushInterval: 1000,
-                onError
-            });
-            expect(buffer).toBeDefined();
-            buffer.destroy();
-        });
-        it('错误处理回调应该可以正确配置', () => {
-            const onError = vi.fn();
-            const buffer = new BatchingBuffer({
-                batchProcessor: vi.fn(),
-                bufferSize: 10,
-                flushInterval: 1000,
-                onError
-            });
-            // 验证缓冲区正常工作
-            buffer.add('item1');
-            expect(buffer.size).toBe(1);
-            buffer.destroy();
-        });
-    });
-    describe('边界条件测试', () => {
-        it('应该正确处理极小的 bufferSize', () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 1,
-                flushInterval: 1000
-            });
-            buffer.add('item1');
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1']);
-            buffer.destroy();
-        });
-        it('应该正确处理极小的 flushInterval', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 1 // 1ms
-            });
-            buffer.add('item1');
-            vi.advanceTimersByTime(1);
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1']);
-            await buffer.destroy();
-        });
-        it('应该正确处理同时达到大小和时间限制', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 2,
-                flushInterval: 100
-            });
-            buffer.add('item1');
-            // 在时间限制之前添加第二个项目，应该立即触发
-            buffer.add('item2');
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            await buffer.destroy();
-        });
-        it('应该正确处理在处理过程中继续添加数据', () => {
-            const processedBatches = [];
-            let processingCount = 0;
-            const batchProcessorWithCallback = vi.fn().mockImplementation((items) => {
-                processingCount++;
-                processedBatches.push([...items]);
-                // 在第一次处理过程中添加新数据
-                if (processingCount === 1) {
-                    buffer.add('item4');
-                }
-            });
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessorWithCallback,
-                bufferSize: 2,
-                flushInterval: 1000
-            });
-            buffer.add('item1', 'item2', 'item3');
-            // 验证处理次数
-            expect(batchProcessorWithCallback).toHaveBeenCalledTimes(2);
-            // 验证第一次处理了前两个项目
-            expect(processedBatches[0]).toEqual(['item1', 'item2']);
-            // 第二次处理的顺序可能是 ['item4', 'item3'] 或 ['item3', 'item4']
-            // 这取决于具体实现，我们验证包含了正确的项目
-            expect(processedBatches[1]).toHaveLength(2);
-            expect(processedBatches[1]).toContain('item3');
-            expect(processedBatches[1]).toContain('item4');
-            buffer.destroy();
-        });
-    });
 });

package/output/events/disposer.d.ts

@@ -0,0 +1,6 @@
+export declare class Disposer {
+    private cleanupFunctions;
+    addDisposer(cleanupFn: () => unknown): void;
+    dispose(): void;
+}
+//# sourceMappingURL=disposer.d.ts.map

package/output/events/disposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/events/disposer.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAyB;IAGjD,WAAW,CAAC,SAAS,EAAE,MAAM,OAAO,GAAG,IAAI;IAK3C,OAAO,IAAI,IAAI;CAUhB"}

package/output/events/disposer.js

@@ -0,0 +1,19 @@
+export class Disposer {
+    cleanupFunctions = [];
+    // 添加清理函数
+    addDisposer(cleanupFn) {
+        this.cleanupFunctions.push(cleanupFn);
+    }
+    // 执行所有清理函数
+    dispose() {
+        for (const cleanupFn of this.cleanupFunctions) {
+            try {
+                cleanupFn();
+            }
+            catch (error) {
+                console.error('Error during cleanup:', error);
+            }
+        }
+        this.cleanupFunctions = []; // 清空清理函数列表
+    }
+}

package/output/events/disposer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=disposer.test.d.ts.map

package/output/events/disposer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposer.test.d.ts","sourceRoot":"","sources":["../../source/events/disposer.test.ts"],"names":[],"mappings":""}

package/output/events/disposer.test.js

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Disposer } from './disposer';
+describe('Disposer', () => {
+    let disposer;
+    beforeEach(() => {
+        disposer = new Disposer();
+    });
+    describe('addDisposer', () => {
+        it('应该能够添加清理函数', () => {
+            const cleanupFn = vi.fn();
+            expect(() => {
+                disposer.addDisposer(cleanupFn);
+            }).not.toThrow();
+        });
+        it('应该能够添加多个清理函数', () => {
+            const cleanupFn1 = vi.fn();
+            const cleanupFn2 = vi.fn();
+            const cleanupFn3 = vi.fn();
+            disposer.addDisposer(cleanupFn1);
+            disposer.addDisposer(cleanupFn2);
+            disposer.addDisposer(cleanupFn3);
+            disposer.dispose();
+            expect(cleanupFn1).toHaveBeenCalledOnce();
+            expect(cleanupFn2).toHaveBeenCalledOnce();
+            expect(cleanupFn3).toHaveBeenCalledOnce();
+        });
+        it('应该能够添加返回不同类型的清理函数', () => {
+            const voidFn = vi.fn(() => { });
+            const stringFn = vi.fn(() => 'cleanup result');
+            const numberFn = vi.fn(() => 42);
+            const promiseFn = vi.fn(() => Promise.resolve('async cleanup'));
+            disposer.addDisposer(voidFn);
+            disposer.addDisposer(stringFn);
+            disposer.addDisposer(numberFn);
+            disposer.addDisposer(promiseFn);
+            disposer.dispose();
+            expect(voidFn).toHaveBeenCalled();
+            expect(stringFn).toHaveBeenCalled();
+            expect(numberFn).toHaveBeenCalled();
+            expect(promiseFn).toHaveBeenCalled();
+        });
+    });
+    describe('dispose', () => {
+        it('应该执行所有清理函数', () => {
+            const cleanupFn1 = vi.fn();
+            const cleanupFn2 = vi.fn();
+            const cleanupFn3 = vi.fn();
+            disposer.addDisposer(cleanupFn1);
+            disposer.addDisposer(cleanupFn2);
+            disposer.addDisposer(cleanupFn3);
+            disposer.dispose();
+            expect(cleanupFn1).toHaveBeenCalledOnce();
+            expect(cleanupFn2).toHaveBeenCalledOnce();
+            expect(cleanupFn3).toHaveBeenCalledOnce();
+        });
+        it('应该按添加顺序执行清理函数', () => {
+            const executionOrder = [];
+            disposer.addDisposer(() => executionOrder.push(1));
+            disposer.addDisposer(() => executionOrder.push(2));
+            disposer.addDisposer(() => executionOrder.push(3));
+            disposer.dispose();
+            expect(executionOrder).toEqual([1, 2, 3]);
+        });
+        it('应该处理清理函数中的错误', () => {
+            const workingFn1 = vi.fn();
+            const errorFn = vi.fn(() => {
+                throw new Error('Cleanup error');
+            });
+            const workingFn2 = vi.fn();
+            // 模拟 console.error
+            const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            disposer.addDisposer(workingFn1);
+            disposer.addDisposer(errorFn);
+            disposer.addDisposer(workingFn2);
+            // dispose 不应该抛出错误
+            expect(() => {
+                disposer.dispose();
+            }).not.toThrow();
+            // 所有函数都应该被调用
+            expect(workingFn1).toHaveBeenCalled();
+            expect(errorFn).toHaveBeenCalled();
+            expect(workingFn2).toHaveBeenCalled();
+            // 错误应该被记录
+            expect(consoleSpy).toHaveBeenCalledWith('Error during cleanup:', expect.any(Error));
+            consoleSpy.mockRestore();
+        });
+        it('应该在执行后清空清理函数列表', () => {
+            const cleanupFn = vi.fn();
+            disposer.addDisposer(cleanupFn);
+            disposer.dispose();
+            expect(cleanupFn).toHaveBeenCalledOnce();
+            // 再次调用 dispose 不应该执行任何函数
+            disposer.dispose();
+            expect(cleanupFn).toHaveBeenCalledOnce();
+        });
+        it('应该能够在清空后重新添加清理函数', () => {
+            const firstCleanup = vi.fn();
+            const secondCleanup = vi.fn();
+            disposer.addDisposer(firstCleanup);
+            disposer.dispose();
+            disposer.addDisposer(secondCleanup);
+            disposer.dispose();
+            expect(firstCleanup).toHaveBeenCalledOnce();
+            expect(secondCleanup).toHaveBeenCalledOnce();
+        });
+        it('应该在没有清理函数时安全执行', () => {
+            expect(() => {
+                disposer.dispose();
+            }).not.toThrow();
+        });
+        it('应该能够多次调用 dispose', () => {
+            const cleanupFn = vi.fn();
+            disposer.addDisposer(cleanupFn);
+            disposer.dispose();
+            disposer.dispose();
+            disposer.dispose();
+            expect(cleanupFn).toHaveBeenCalledOnce();
+        });
+    });
+    describe('实际使用场景', () => {
+        it('应该能够清理事件监听器', () => {
+            const removeEventListener = vi.fn();
+            const unsubscribe = vi.fn();
+            disposer.addDisposer(removeEventListener);
+            disposer.addDisposer(unsubscribe);
+            disposer.dispose();
+            expect(removeEventListener).toHaveBeenCalled();
+            expect(unsubscribe).toHaveBeenCalled();
+        });
+        it('应该能够清理定时器', () => {
+            const clearTimeout = vi.fn();
+            const clearInterval = vi.fn();
+            disposer.addDisposer(() => clearTimeout(123));
+            disposer.addDisposer(() => clearInterval(456));
+            disposer.dispose();
+            expect(clearTimeout).toHaveBeenCalledWith(123);
+            expect(clearInterval).toHaveBeenCalledWith(456);
+        });
+        it('应该能够清理资源连接', () => {
+            const closeConnection = vi.fn();
+            const releaseResource = vi.fn();
+            disposer.addDisposer(() => closeConnection());
+            disposer.addDisposer(() => releaseResource());
+            disposer.dispose();
+            expect(closeConnection).toHaveBeenCalled();
+            expect(releaseResource).toHaveBeenCalled();
+        });
+        it('应该与 EventEmitter 配合使用', () => {
+            // 模拟 EventEmitter 的使用
+            const mockEventEmitter = {
+                on: vi.fn().mockReturnValue(vi.fn()), // 返回 off 函数
+                cleanup: vi.fn()
+            };
+            const offFunction1 = mockEventEmitter.on('event1', vi.fn());
+            const offFunction2 = mockEventEmitter.on('event2', vi.fn());
+            disposer.addDisposer(offFunction1);
+            disposer.addDisposer(offFunction2);
+            disposer.addDisposer(() => mockEventEmitter.cleanup());
+            disposer.dispose();
+            expect(offFunction1).toHaveBeenCalled();
+            expect(offFunction2).toHaveBeenCalled();
+            expect(mockEventEmitter.cleanup).toHaveBeenCalled();
+        });
+    });
+    describe('错误处理', () => {
+        it('应该捕获并记录同步错误', () => {
+            const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            const error = new Error('Sync error');
+            disposer.addDisposer(() => {
+                throw error;
+            });
+            disposer.dispose();
+            expect(consoleSpy).toHaveBeenCalledWith('Error during cleanup:', error);
+            consoleSpy.mockRestore();
+        });
+        it('应该处理不同类型的错误', () => {
+            const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            disposer.addDisposer(() => {
+                throw new TypeError('Type error');
+            });
+            disposer.addDisposer(() => {
+                throw 'String error';
+            });
+            disposer.addDisposer(() => {
+                throw { message: 'Object error' };
+            });
+            disposer.dispose();
+            expect(consoleSpy).toHaveBeenCalledTimes(3);
+            consoleSpy.mockRestore();
+        });
+    });
+});