@taicode/common-base 3.1.0 → 3.1.1

package/output/disposer/disposer.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/disposer/disposer.ts"],"names":[],"mappings":"AAEA,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAyB;IAGjD,WAAW,CAAC,SAAS,EAAE,MAAM,OAAO,GAAG,IAAI;IAK3C,OAAO,IAAI,IAAI;CAUhB"}
+{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/disposer/disposer.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;AAEvD,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAwB;IAGhD,WAAW,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAKvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAY/B"}

package/output/disposer/disposer.js

@@ -6,15 +6,16 @@ export class Disposer {
         this.cleanupFunctions.push(cleanupFn);
     }
     // 执行所有清理函数
-    dispose() {
-        for (const cleanupFn of this.cleanupFunctions) {
+    async dispose() {
+        const cleanupFunctions = this.cleanupFunctions;
+        this.cleanupFunctions = [];
+        for (const cleanupFn of cleanupFunctions) {
             try {
-                cleanupFn();
+                await cleanupFn();
             }
             catch (error) {
                 logger.error('Error during cleanup:', error);
             }
         }
-        this.cleanupFunctions = []; // 清空清理函数列表
     }
 }

package/output/disposer/disposer.test.js

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

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();
+        });
+    });
+});

package/output/events/event-emitter.d.ts

@@ -0,0 +1,33 @@
+type OffFn = () => void;
+type Listener<T = unknown> = (data: T) => void;
+export declare class EventEmitter<Events extends object = object> {
+    private listeners;
+    constructor();
+    /**
+     * 订阅事件
+     * @param type 事件类型
+     * @param listener 回调函数
+     */
+    on<K extends keyof Events>(type: K, listener: Listener<Events[K]>): OffFn;
+    /**
+     * 取消订阅
+     * @param type 事件类型
+     * @param listener 要移除的回调函数（可选）
+     */
+    off<K extends keyof Events>(type: K, listener?: Listener<Events[K]>): void;
+    /**
+     * 触发事件
+     * @param type 事件类型
+     * @param data 要传递的数据
+     */
+    emit<K extends keyof Events>(type: K, data: Events[K]): void;
+    /**
+     * 一次性订阅
+     * @param type 事件类型
+     * @param listener 回调函数
+     */
+    once<K extends keyof Events>(type: K, listener: Listener<Events[K]>): void;
+    cleanup(): void;
+}
+export {};
+//# sourceMappingURL=event-emitter.d.ts.map

package/output/events/event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../../source/events/event-emitter.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG,MAAM,IAAI,CAAA;AACvB,KAAK,QAAQ,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAA;AAE9C,qBAAa,YAAY,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM;IACtD,OAAO,CAAC,SAAS,CAAsD;;IAUvE;;;;OAIG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK;IASzE;;;;OAIG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAc1E;;;;OAIG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAQ5D;;;;OAIG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAQ1E,OAAO;CAGR"}

package/output/events/event-emitter.js

@@ -0,0 +1,66 @@
+export class EventEmitter {
+    listeners = {};
+    constructor() {
+        this.on = this.on.bind(this);
+        this.off = this.off.bind(this);
+        this.once = this.once.bind(this);
+        this.emit = this.emit.bind(this);
+        this.cleanup = this.cleanup.bind(this);
+    }
+    /**
+     * 订阅事件
+     * @param type 事件类型
+     * @param listener 回调函数
+     */
+    on(type, listener) {
+        if (!this.listeners[type]) {
+            this.listeners[type] = [];
+        }
+        this.listeners[type].push(listener);
+        return () => this.off(type, listener);
+    }
+    /**
+     * 取消订阅
+     * @param type 事件类型
+     * @param listener 要移除的回调函数（可选）
+     */
+    off(type, listener) {
+        if (!this.listeners[type])
+            return;
+        if (!listener) {
+            // 移除该事件的所有监听器
+            delete this.listeners[type];
+        }
+        else {
+            // 移除特定监听器
+            this.listeners[type] = this.listeners[type].filter((fn) => fn !== listener);
+        }
+    }
+    /**
+     * 触发事件
+     * @param type 事件类型
+     * @param data 要传递的数据
+     */
+    emit(type, data) {
+        const listeners = this.listeners[type];
+        // 复制数组避免回调中取消订阅导致的遍历问题
+        if (listeners) {
+            listeners.slice().forEach((fn) => fn(data));
+        }
+    }
+    /**
+     * 一次性订阅
+     * @param type 事件类型
+     * @param listener 回调函数
+     */
+    once(type, listener) {
+        const onceWrapper = (data) => {
+            listener(data);
+            this.off(type, onceWrapper);
+        };
+        this.on(type, onceWrapper);
+    }
+    cleanup() {
+        this.listeners = {};
+    }
+}

package/output/events/event-emitter.test.d.ts

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

package/output/events/event-emitter.test.d.ts.map

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