@taicode/common-base 1.7.3 → 1.7.4

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

@@ -183,24 +183,98 @@ describe('FlowQueue', () => {
         });
     });
     describe('并发处理', () => {
-        it('应该防止并发处理', async () => {
+        it('应该支持配置的并发数量', async () => {
             const inputs = [
                 { id: 1, data: 'test1' },
-                { id: 2, data: 'test2' }
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' },
+                { id: 4, data: 'test4' }
             ];
-            // 模拟较慢的处理器
+            let processingCount = 0;
+            let maxConcurrentProcessing = 0;
+            // 模拟较慢的处理器，用来测试并发
             mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processingCount++;
+                maxConcurrentProcessing = Math.max(maxConcurrentProcessing, processingCount);
+                await new Promise(resolve => setTimeout(resolve, 50));
+                processingCount--;
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            // 创建支持 3 个并发的队列
+            flowQueue = new FlowQueue({
+                retry: { maxRetries: 3 },
+                concurrency: 3
+            }, mockProcessor);
+            // 添加所有输入
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证结果
+            expect(mockProcessor).toHaveBeenCalledTimes(4);
+            expect(flowQueue.successOutputs.size).toBe(4);
+            expect(maxConcurrentProcessing).toBe(3); // 应该达到配置的并发数
+        });
+        it('默认应该使用并发数 1（顺序处理）', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            let processingCount = 0;
+            let maxConcurrentProcessing = 0;
+            const processingOrder = [];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processingCount++;
+                maxConcurrentProcessing = Math.max(maxConcurrentProcessing, processingCount);
+                processingOrder.push(input.id);
                 await new Promise(resolve => setTimeout(resolve, 30));
+                processingCount--;
                 return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
             });
+            // 使用默认配置（并发数应该为 1）
             flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
-            // 快速添加两个输入
-            flowQueue.input(inputs[0]);
-            flowQueue.input(inputs[1]);
-            await new Promise(resolve => setTimeout(resolve, 100));
-            // 应该按顺序处理
-            expect(mockProcessor).toHaveBeenCalledTimes(2);
-            expect(flowQueue['processedInputs'].length).toBe(2);
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证顺序处理
+            expect(maxConcurrentProcessing).toBe(1);
+            expect(processingOrder).toEqual([1, 2, 3]); // 应该按顺序处理
+        });
+        it('应该在达到并发限制时等待', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' },
+                { id: 4, data: 'test4' },
+                { id: 5, data: 'test5' }
+            ];
+            let activeProcessing = 0;
+            let maxActiveProcessing = 0;
+            const processStartTimes = [];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processStartTimes.push(Date.now());
+                activeProcessing++;
+                maxActiveProcessing = Math.max(maxActiveProcessing, activeProcessing);
+                await new Promise(resolve => setTimeout(resolve, 80));
+                activeProcessing--;
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            // 创建并发数为 2 的队列
+            flowQueue = new FlowQueue({
+                retry: { maxRetries: 3 },
+                concurrency: 2
+            }, mockProcessor);
+            const startTime = Date.now();
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证并发限制生效
+            expect(maxActiveProcessing).toBe(2);
+            expect(flowQueue.successOutputs.size).toBe(5);
+            // 验证第3个任务等待了前面任务完成
+            // 由于并发数为2，第3个任务应该在第一批任务完成后才开始
+            const totalTime = Date.now() - startTime;
+            expect(totalTime).toBeGreaterThan(150); // 至少需要两轮处理
         });
     });
     describe('边界情况', () => {
@@ -676,7 +750,7 @@ describe('FlowQueue', () => {
                 expect(flowQueue['processedInputs'].length).toBe(0);
                 expect(flowQueue.successOutputs.size).toBe(0);
                 expect(flowQueue['retryCount'].size).toBe(0);
-                expect(flowQueue['isProcessing']).toBe(false);
+                expect(flowQueue['processingCount']).toBe(0);
                 expect(flowQueue['isInputClosed']).toBe(false);
                 expect(flowQueue['completionPromise']).toBe(null);
                 expect(flowQueue['completionResolve']).toBe(null);
@@ -1030,4 +1104,101 @@ describe('FlowQueue', () => {
             });
         });
     });
+    describe('链式调用', () => {
+        it('应该支持 input 方法的链式调用', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试链式调用并验证返回值
+            const returnValue = flowQueue
+                .input(inputs[0])
+                .input(inputs[1], inputs[2]);
+            expect(returnValue).toBe(flowQueue); // 验证返回的是同一个实例
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(3);
+        });
+        it('应该支持 closeInput 方法的链式调用', async () => {
+            const testInput = { id: 1, data: 'test' };
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试链式调用
+            const returnValue = flowQueue
+                .input(testInput)
+                .closeInput();
+            expect(returnValue).toBe(flowQueue);
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+        });
+        it('应该支持 reset 方法的链式调用', async () => {
+            const firstInput = { id: 1, data: 'first' };
+            const secondInput = { id: 2, data: 'second' };
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 第一轮处理
+            flowQueue.input(firstInput);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+            // 测试链式调用重置并开始新处理
+            const returnValue = flowQueue
+                .reset()
+                .input(secondInput)
+                .closeInput();
+            expect(returnValue).toBe(flowQueue);
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+            expect(flowQueue.successOutputs.get(secondInput)?.result).toBe('processed_second');
+        });
+        it('应该支持 cancel 方法的链式调用', async () => {
+            const testInputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            flowQueue.input(...testInputs);
+            // 测试链式调用
+            const returnValue = flowQueue.cancel();
+            expect(returnValue).toBe(flowQueue);
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+            // 等待异步完成状态更新
+            await new Promise(resolve => setTimeout(resolve, 10));
+            expect(flowQueue.isCompleted).toBe(true);
+        });
+        it('应该支持完整的链式调用流程', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试完整的链式调用流程
+            await flowQueue
+                .input(inputs[0], inputs[1])
+                .input(inputs[2])
+                .closeInput()
+                .awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(3);
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            // 测试重置后的链式调用
+            await flowQueue
+                .reset()
+                .input(inputs[0])
+                .closeInput()
+                .awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-base",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "author": "Alain",
   "license": "ISC",
   "description": "",

package/output/events/disposer.d.ts

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,19 +0,0 @@
-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

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

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

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

package/output/events/disposer.test.js

@@ -1,192 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,66 +0,0 @@
-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

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

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

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