@taicode/common-base 1.7.2 → 1.7.3

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

package/output/events/event-emitter.test.js

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EventEmitter } from './event-emitter';
+describe('EventEmitter', () => {
+    let emitter;
+    beforeEach(() => {
+        emitter = new EventEmitter();
+    });
+    describe('on', () => {
+        it('应该能够订阅事件', () => {
+            const listener = vi.fn();
+            emitter.on('test', listener);
+            emitter.emit('test', 'hello');
+            expect(listener).toHaveBeenCalledOnce();
+            expect(listener).toHaveBeenCalledWith('hello');
+        });
+        it('应该能够订阅多个监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('test', listener1);
+            emitter.on('test', listener2);
+            emitter.emit('test', 'hello');
+            expect(listener1).toHaveBeenCalledOnce();
+            expect(listener2).toHaveBeenCalledOnce();
+            expect(listener1).toHaveBeenCalledWith('hello');
+            expect(listener2).toHaveBeenCalledWith('hello');
+        });
+        it('应该返回取消订阅函数', () => {
+            const listener = vi.fn();
+            const off = emitter.on('test', listener);
+            emitter.emit('test', 'hello');
+            expect(listener).toHaveBeenCalledOnce();
+            off();
+            emitter.emit('test', 'world');
+            expect(listener).toHaveBeenCalledOnce();
+        });
+        it('应该支持不同类型的事件数据', () => {
+            const stringListener = vi.fn();
+            const numberListener = vi.fn();
+            const objectListener = vi.fn();
+            const voidListener = vi.fn();
+            emitter.on('test', stringListener);
+            emitter.on('number', numberListener);
+            emitter.on('object', objectListener);
+            emitter.on('noData', voidListener);
+            const testObject = { id: 1, name: 'test' };
+            emitter.emit('test', 'hello');
+            emitter.emit('number', 42);
+            emitter.emit('object', testObject);
+            emitter.emit('noData', undefined);
+            expect(stringListener).toHaveBeenCalledWith('hello');
+            expect(numberListener).toHaveBeenCalledWith(42);
+            expect(objectListener).toHaveBeenCalledWith(testObject);
+            expect(voidListener).toHaveBeenCalledWith(undefined);
+        });
+    });
+    describe('off', () => {
+        it('应该能够取消订阅特定监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('test', listener1);
+            emitter.on('test', listener2);
+            emitter.off('test', listener1);
+            emitter.emit('test', 'hello');
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).toHaveBeenCalledOnce();
+        });
+        it('应该能够取消订阅所有监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('test', listener1);
+            emitter.on('test', listener2);
+            emitter.off('test');
+            emitter.emit('test', 'hello');
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).not.toHaveBeenCalled();
+        });
+        it('应该忽略不存在的事件类型', () => {
+            expect(() => {
+                emitter.off('test');
+            }).not.toThrow();
+        });
+        it('应该忽略不存在的监听器', () => {
+            const listener = vi.fn();
+            const anotherListener = vi.fn();
+            emitter.on('test', listener);
+            expect(() => {
+                emitter.off('test', anotherListener);
+            }).not.toThrow();
+            emitter.emit('test', 'hello');
+            expect(listener).toHaveBeenCalledOnce();
+        });
+    });
+    describe('emit', () => {
+        it('应该能够触发事件', () => {
+            const listener = vi.fn();
+            emitter.on('test', listener);
+            emitter.emit('test', 'hello');
+            expect(listener).toHaveBeenCalledWith('hello');
+        });
+        it('应该不抛出错误当没有监听器时', () => {
+            expect(() => {
+                emitter.emit('test', 'hello');
+            }).not.toThrow();
+        });
+        it('应该按顺序调用监听器', () => {
+            const calls = [];
+            emitter.on('test', () => calls.push(1));
+            emitter.on('test', () => calls.push(2));
+            emitter.on('test', () => calls.push(3));
+            emitter.emit('test', 'hello');
+            expect(calls).toEqual([1, 2, 3]);
+        });
+        it('应该处理监听器中的错误', () => {
+            const workingListener = vi.fn();
+            const errorListener = vi.fn(() => {
+                throw new Error('Test error');
+            });
+            const anotherWorkingListener = vi.fn();
+            emitter.on('test', workingListener);
+            emitter.on('test', errorListener);
+            emitter.on('test', anotherWorkingListener);
+            expect(() => {
+                emitter.emit('test', 'hello');
+            }).toThrow('Test error');
+            expect(workingListener).toHaveBeenCalled();
+            expect(errorListener).toHaveBeenCalled();
+            // 由于错误，后续监听器可能不会被调用
+        });
+        it('应该防止监听器修改监听器列表时的遍历问题', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn(() => {
+                // 在回调中取消订阅
+                emitter.off('test', listener3);
+            });
+            const listener3 = vi.fn();
+            emitter.on('test', listener1);
+            emitter.on('test', listener2);
+            emitter.on('test', listener3);
+            emitter.emit('test', 'hello');
+            expect(listener1).toHaveBeenCalled();
+            expect(listener2).toHaveBeenCalled();
+            expect(listener3).toHaveBeenCalled(); // 应该仍然被调用，因为使用了 slice()
+        });
+    });
+    describe('once', () => {
+        it('应该只执行一次监听器', () => {
+            const listener = vi.fn();
+            emitter.once('test', listener);
+            emitter.emit('test', 'first');
+            emitter.emit('test', 'second');
+            expect(listener).toHaveBeenCalledOnce();
+            expect(listener).toHaveBeenCalledWith('first');
+        });
+        it('应该在执行后自动取消订阅', () => {
+            const listener = vi.fn();
+            emitter.once('test', listener);
+            emitter.emit('test', 'hello');
+            // 验证监听器已被移除
+            emitter.emit('test', 'world');
+            expect(listener).toHaveBeenCalledOnce();
+        });
+        it('应该与普通监听器一起工作', () => {
+            const onceListener = vi.fn();
+            const normalListener = vi.fn();
+            emitter.once('test', onceListener);
+            emitter.on('test', normalListener);
+            emitter.emit('test', 'first');
+            emitter.emit('test', 'second');
+            expect(onceListener).toHaveBeenCalledOnce();
+            expect(normalListener).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('cleanup', () => {
+        it('应该清空所有监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('test', listener1);
+            emitter.on('number', listener2);
+            emitter.cleanup();
+            emitter.emit('test', 'hello');
+            emitter.emit('number', 42);
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).not.toHaveBeenCalled();
+        });
+        it('清理后应该能够重新添加监听器', () => {
+            const listener = vi.fn();
+            emitter.on('test', listener);
+            emitter.cleanup();
+            const newListener = vi.fn();
+            emitter.on('test', newListener);
+            emitter.emit('test', 'hello');
+            expect(listener).not.toHaveBeenCalled();
+            expect(newListener).toHaveBeenCalledWith('hello');
+        });
+    });
+    describe('方法绑定', () => {
+        it('方法应该绑定到实例', () => {
+            const { on, off, emit, once, cleanup } = emitter;
+            const listener = vi.fn();
+            on('test', listener);
+            emit('test', 'hello');
+            expect(listener).toHaveBeenCalledWith('hello');
+            off('test', listener);
+            emit('test', 'world');
+            expect(listener).toHaveBeenCalledOnce();
+            // 测试其他方法
+            once('test', listener);
+            emit('test', 'once');
+            expect(listener).toHaveBeenCalledTimes(2);
+            cleanup();
+        });
+    });
+});

package/output/events/index.d.ts

@@ -0,0 +1,3 @@
+export * from './event-emitter';
+export * from './disposer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/events/index.ts"],"names":[],"mappings":"AACA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA"}

package/output/events/index.js

@@ -0,0 +1,3 @@
+// 事件系统相关功能
+export * from './event-emitter';
+export * from './disposer';