@taicode/common-base 1.0.2 → 1.1.1

package/output/error/error.test.js

@@ -0,0 +1,242 @@
+import { describe, it, expect } from 'vitest';
+import { UserError, SystemError, UnknownError } from './error';
+describe('UserError', () => {
+    describe('constructor', () => {
+        it('应该正确创建UserError实例', () => {
+            const type = 'VALIDATION_ERROR';
+            const message = '输入验证失败';
+            const error = new UserError(type, message);
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(UserError);
+            expect(error.name).toBe('UserError');
+            expect(error.type).toBe(type);
+            expect(error.message).toBe(message);
+        });
+        it('应该支持ErrorOptions参数', () => {
+            const type = 'VALIDATION_ERROR';
+            const message = '输入验证失败';
+            const cause = new Error('原始错误');
+            const error = new UserError(type, message, { cause });
+            expect(error.cause).toBe(cause);
+        });
+        it('应该正确设置错误堆栈信息', () => {
+            const error = new UserError('TEST_ERROR', '测试错误');
+            expect(error.stack).toBeDefined();
+            expect(error.stack).toContain('UserError');
+        });
+    });
+    describe('is', () => {
+        it('应该正确识别UserError实例', () => {
+            const error = new UserError('TEST_ERROR', '测试错误');
+            expect(UserError.is(error)).toBe(true);
+        });
+        it('应该正确识别非UserError实例', () => {
+            const regularError = new Error('普通错误');
+            const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
+            const unknownError = new UnknownError('未知错误');
+            expect(UserError.is(regularError)).toBe(false);
+            expect(UserError.is(systemError)).toBe(false);
+            expect(UserError.is(unknownError)).toBe(false);
+            expect(UserError.is(null)).toBe(false);
+            expect(UserError.is(undefined)).toBe(false);
+            expect(UserError.is('字符串')).toBe(false);
+            expect(UserError.is(123)).toBe(false);
+            expect(UserError.is({})).toBe(false);
+        });
+        it('应该支持类型守卫功能', () => {
+            const error = new UserError('TEST_ERROR', '测试错误');
+            if (UserError.is(error)) {
+                // 在类型守卫内部，error的类型应该被正确推断
+                expect(error.type).toBe('TEST_ERROR');
+                expect(error.message).toBe('测试错误');
+                expect(error.name).toBe('UserError');
+            }
+        });
+    });
+    describe('继承行为', () => {
+        it('应该正确继承Error的所有属性和方法', () => {
+            const error = new UserError('TEST_ERROR', '测试错误');
+            expect(error.toString()).toContain('测试错误');
+            expect(error.toString()).toContain('UserError');
+            expect(error instanceof Error).toBe(true);
+        });
+        it('应该支持Error的标准用法', () => {
+            const error = new UserError('TEST_ERROR', '测试错误');
+            try {
+                throw error;
+            }
+            catch (caught) {
+                expect(caught).toBe(error);
+                expect(caught).toBeInstanceOf(UserError);
+            }
+        });
+    });
+});
+describe('SystemError', () => {
+    describe('constructor', () => {
+        it('应该正确创建SystemError实例', () => {
+            const type = 'DATABASE_ERROR';
+            const message = '数据库连接失败';
+            const error = new SystemError(type, message);
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(SystemError);
+            expect(error.name).toBe('SystemError');
+            expect(error.type).toBe(type);
+            expect(error.message).toBe(message);
+        });
+        it('应该支持ErrorOptions参数', () => {
+            const type = 'NETWORK_ERROR';
+            const message = '网络请求失败';
+            const cause = new Error('连接超时');
+            const error = new SystemError(type, message, { cause });
+            expect(error.cause).toBe(cause);
+        });
+        it('应该正确设置错误堆栈信息', () => {
+            const error = new SystemError('FILE_ERROR', '文件读取失败');
+            expect(error.stack).toBeDefined();
+            expect(error.stack).toContain('SystemError');
+        });
+    });
+    describe('is', () => {
+        it('应该正确识别SystemError实例', () => {
+            const error = new SystemError('TEST_ERROR', '测试错误');
+            expect(SystemError.is(error)).toBe(true);
+        });
+        it('应该正确识别非SystemError实例', () => {
+            const regularError = new Error('普通错误');
+            const userError = new UserError('USER_ERROR', '用户错误');
+            const unknownError = new UnknownError('未知错误');
+            expect(SystemError.is(regularError)).toBe(false);
+            expect(SystemError.is(userError)).toBe(false);
+            expect(SystemError.is(unknownError)).toBe(false);
+            expect(SystemError.is(null)).toBe(false);
+            expect(SystemError.is(undefined)).toBe(false);
+            expect(SystemError.is('字符串')).toBe(false);
+            expect(SystemError.is(123)).toBe(false);
+            expect(SystemError.is({})).toBe(false);
+        });
+        it('应该支持类型守卫功能', () => {
+            const error = new SystemError('DATABASE_ERROR', '数据库错误');
+            if (SystemError.is(error)) {
+                // 在类型守卫内部，error的类型应该被正确推断
+                expect(error.type).toBe('DATABASE_ERROR');
+                expect(error.message).toBe('数据库错误');
+                expect(error.name).toBe('SystemError');
+            }
+        });
+    });
+    describe('继承行为', () => {
+        it('应该正确继承Error的所有属性和方法', () => {
+            const error = new SystemError('TEST_ERROR', '测试错误');
+            expect(error.toString()).toContain('测试错误');
+            expect(error.toString()).toContain('SystemError');
+            expect(error instanceof Error).toBe(true);
+        });
+        it('应该支持Error的标准用法', () => {
+            const error = new SystemError('TEST_ERROR', '测试错误');
+            try {
+                throw error;
+            }
+            catch (caught) {
+                expect(caught).toBe(error);
+                expect(caught).toBeInstanceOf(SystemError);
+            }
+        });
+    });
+});
+describe('UnknownError', () => {
+    describe('constructor', () => {
+        it('应该正确创建UnknownError实例', () => {
+            const message = '发生了未知错误';
+            const error = new UnknownError(message);
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(UnknownError);
+            expect(error.name).toBe('UnknownError');
+            expect(error.message).toBe(message);
+        });
+        it('应该支持ErrorOptions参数', () => {
+            const message = '未知错误';
+            const cause = new Error('原始未知错误');
+            const error = new UnknownError(message, { cause });
+            expect(error.cause).toBe(cause);
+        });
+        it('应该正确设置错误堆栈信息', () => {
+            const error = new UnknownError('测试未知错误');
+            expect(error.stack).toBeDefined();
+            expect(error.stack).toContain('UnknownError');
+        });
+    });
+    describe('is', () => {
+        it('应该正确识别UnknownError实例', () => {
+            const error = new UnknownError('测试错误');
+            expect(UnknownError.is(error)).toBe(true);
+        });
+        it('应该正确识别非UnknownError实例', () => {
+            const regularError = new Error('普通错误');
+            const userError = new UserError('USER_ERROR', '用户错误');
+            const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
+            expect(UnknownError.is(regularError)).toBe(false);
+            expect(UnknownError.is(userError)).toBe(false);
+            expect(UnknownError.is(systemError)).toBe(false);
+            expect(UnknownError.is(null)).toBe(false);
+            expect(UnknownError.is(undefined)).toBe(false);
+            expect(UnknownError.is('字符串')).toBe(false);
+            expect(UnknownError.is(123)).toBe(false);
+            expect(UnknownError.is({})).toBe(false);
+        });
+    });
+    describe('继承行为', () => {
+        it('应该正确继承Error的所有属性和方法', () => {
+            const error = new UnknownError('测试错误');
+            expect(error.toString()).toContain('测试错误');
+            expect(error instanceof Error).toBe(true);
+        });
+        it('应该支持Error的标准用法', () => {
+            const error = new UnknownError('测试错误');
+            try {
+                throw error;
+            }
+            catch (caught) {
+                expect(caught).toBe(error);
+                expect(caught).toBeInstanceOf(UnknownError);
+            }
+        });
+    });
+});
+describe('错误类型区分', () => {
+    it('三种错误类型应该是不同的类', () => {
+        const userError = new UserError('USER_ERROR', '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
+        const unknownError = new UnknownError('未知错误');
+        // 每种错误只能被自己的类型检查函数识别
+        expect(UserError.is(userError)).toBe(true);
+        expect(SystemError.is(userError)).toBe(false);
+        expect(UnknownError.is(userError)).toBe(false);
+        expect(UserError.is(systemError)).toBe(false);
+        expect(SystemError.is(systemError)).toBe(true);
+        expect(UnknownError.is(systemError)).toBe(false);
+        expect(UserError.is(unknownError)).toBe(false);
+        expect(SystemError.is(unknownError)).toBe(false);
+        expect(UnknownError.is(unknownError)).toBe(true);
+    });
+    it('所有错误类型都应该是Error的实例', () => {
+        const userError = new UserError('USER_ERROR', '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
+        const unknownError = new UnknownError('未知错误');
+        expect(userError instanceof Error).toBe(true);
+        expect(systemError instanceof Error).toBe(true);
+        expect(unknownError instanceof Error).toBe(true);
+    });
+});
+describe('泛型类型支持', () => {
+    it('UserError应该支持字符串字面量类型', () => {
+        const error = new UserError('REQUIRED_FIELD', '字段必填');
+        expect(error.type).toBe('REQUIRED_FIELD');
+        expect(UserError.is(error)).toBe(true);
+    });
+    it('SystemError应该支持字符串字面量类型', () => {
+        const error = new SystemError('DATABASE_ERROR', '数据库连接失败');
+        expect(error.type).toBe('DATABASE_ERROR');
+        expect(SystemError.is(error)).toBe(true);
+    });
+});

package/output/error/index.d.ts

@@ -0,0 +1,2 @@
+export { UserError, SystemError, UnknownError } from './error';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA"}

package/output/error/index.js

@@ -0,0 +1 @@
+export { UserError, SystemError, UnknownError } from './error';

package/output/event-emitter/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 type { OffFn, Listener };
+//# sourceMappingURL=event-emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../../source/event-emitter/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;AAED,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAA"}

package/output/event-emitter/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/event-emitter/event-emitter.test.d.ts

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

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

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

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

@@ -0,0 +1,177 @@
+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();
+            const off = emitter.on('data-update', listener);
+            expect(typeof off).toBe('function');
+            emitter.emit('data-update', 'test data');
+            expect(listener).toHaveBeenCalledWith('test data');
+        });
+        it('应该为同一事件注册多个监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('data-update', listener1);
+            emitter.on('data-update', listener2);
+            emitter.emit('data-update', 'test data');
+            expect(listener1).toHaveBeenCalledWith('test data');
+            expect(listener2).toHaveBeenCalledWith('test data');
+        });
+        it('应该允许同一监听器被多次注册', () => {
+            const listener = vi.fn();
+            emitter.on('data-update', listener);
+            emitter.on('data-update', listener);
+            emitter.emit('data-update', 'test data');
+            expect(listener).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('off 方法', () => {
+        it('应该移除特定的监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('data-update', listener1);
+            emitter.on('data-update', listener2);
+            emitter.off('data-update', listener1);
+            emitter.emit('data-update', 'test data');
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).toHaveBeenCalledWith('test data');
+        });
+        it('应该在没有提供特定监听器时移除所有监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('data-update', listener1);
+            emitter.on('data-update', listener2);
+            emitter.off('data-update');
+            emitter.emit('data-update', 'test data');
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).not.toHaveBeenCalled();
+        });
+        it('应该优雅地处理移除不存在的监听器', () => {
+            const listener = vi.fn();
+            // 不应该抛出错误
+            expect(() => {
+                emitter.off('data-update', listener);
+            }).not.toThrow();
+        });
+        it('应该与 on 方法返回的 off 函数配合使用', () => {
+            const listener = vi.fn();
+            const off = emitter.on('data-update', listener);
+            off();
+            emitter.emit('data-update', 'test data');
+            expect(listener).not.toHaveBeenCalled();
+        });
+    });
+    describe('emit 方法', () => {
+        it('应该用正确的数据调用所有注册的监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            const testData = { userId: 'user123', timestamp: Date.now() };
+            emitter.on('user-login', listener1);
+            emitter.on('user-login', listener2);
+            emitter.emit('user-login', testData);
+            expect(listener1).toHaveBeenCalledWith(testData);
+            expect(listener2).toHaveBeenCalledWith(testData);
+        });
+        it('应该优雅地处理没有监听器的事件', () => {
+            expect(() => {
+                emitter.emit('data-update', 'test data');
+            }).not.toThrow();
+        });
+        it('应该处理抛出错误的监听器', () => {
+            const goodListener = vi.fn();
+            const badListener = vi.fn(() => {
+                throw new Error('Listener error');
+            });
+            emitter.on('data-update', goodListener);
+            emitter.on('data-update', badListener);
+            expect(() => {
+                emitter.emit('data-update', 'test data');
+            }).toThrow('Listener error');
+            expect(goodListener).toHaveBeenCalledWith('test data');
+        });
+        it('应该创建监听器数组的副本以避免并发修改问题', () => {
+            const listeners = [];
+            // 创建一个监听器，它会在执行时移除自己
+            const selfRemovingListener = () => {
+                emitter.off('data-update', selfRemovingListener);
+            };
+            // 创建其他监听器
+            const otherListener = vi.fn();
+            emitter.on('data-update', selfRemovingListener);
+            emitter.on('data-update', otherListener);
+            // 发射事件，这应该不会导致问题
+            expect(() => {
+                emitter.emit('data-update', 'test data');
+            }).not.toThrow();
+            expect(otherListener).toHaveBeenCalledWith('test data');
+        });
+    });
+    describe('once 方法', () => {
+        it('应该注册一个只触发一次的监听器', () => {
+            const listener = vi.fn();
+            emitter.once('data-update', listener);
+            emitter.emit('data-update', 'first call');
+            emitter.emit('data-update', 'second call');
+            expect(listener).toHaveBeenCalledTimes(1);
+            expect(listener).toHaveBeenCalledWith('first call');
+        });
+        it('应该处理复杂的事件数据', () => {
+            const listener = vi.fn();
+            const testData = { userId: 'user123', timestamp: Date.now() };
+            emitter.once('user-login', listener);
+            emitter.emit('user-login', testData);
+            emitter.emit('user-login', { userId: 'user456', timestamp: Date.now() });
+            expect(listener).toHaveBeenCalledTimes(1);
+            expect(listener).toHaveBeenCalledWith(testData);
+        });
+    });
+    describe('cleanup 方法', () => {
+        it('应该移除所有监听器', () => {
+            const listener1 = vi.fn();
+            const listener2 = vi.fn();
+            emitter.on('data-update', listener1);
+            emitter.on('user-login', listener2);
+            emitter.cleanup();
+            emitter.emit('data-update', 'test data');
+            emitter.emit('user-login', { userId: 'user123', timestamp: Date.now() });
+            expect(listener1).not.toHaveBeenCalled();
+            expect(listener2).not.toHaveBeenCalled();
+        });
+    });
+    describe('方法绑定', () => {
+        it('应该将方法正确绑定到实例', () => {
+            const { on, off, once, emit, cleanup } = emitter;
+            const listener = vi.fn();
+            // 这些方法应该可以独立调用而不丢失上下文
+            expect(() => {
+                on('data-update', listener);
+                emit('data-update', 'test data');
+                off('data-update', listener);
+                once('data-update', listener);
+                cleanup();
+            }).not.toThrow();
+            expect(listener).toHaveBeenCalledWith('test data');
+        });
+    });
+    describe('类型安全', () => {
+        it('应该处理不同的事件类型', () => {
+            const loginListener = vi.fn();
+            const logoutListener = vi.fn();
+            const errorListener = vi.fn();
+            emitter.on('user-login', loginListener);
+            emitter.on('user-logout', logoutListener);
+            emitter.on('error', errorListener);
+            emitter.emit('user-login', { userId: 'user123', timestamp: Date.now() });
+            emitter.emit('user-logout', { userId: 'user123' });
+            emitter.emit('error', new Error('Test error'));
+            expect(loginListener).toHaveBeenCalledWith({ userId: 'user123', timestamp: expect.any(Number) });
+            expect(logoutListener).toHaveBeenCalledWith({ userId: 'user123' });
+            expect(errorListener).toHaveBeenCalledWith(expect.any(Error));
+        });
+    });
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/event-emitter/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA"}

package/output/event-emitter/index.js

@@ -0,0 +1 @@
+export * from './event-emitter';

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