@taicode/common-base 1.7.1 → 1.7.3

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';