@taicode/common-base 1.7.4 → 1.7.5

package/output/error/error.test.js

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { UserError, SystemError, UnknownError } from './error';
+import { UserError, SystemError } from './error';
 describe('UserError', () => {
     describe('constructor', () => {
         it('应该正确创建UserError实例', () => {
             const type = 'VALIDATION_ERROR';
             const message = '输入验证失败';
-            const error = new UserError(type, message);
+            const error = new UserError(type, undefined, message);
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(UserError);
             expect(error.name).toBe('UserError');
@@ -32,7 +32,7 @@ describe('UserError', () => {
         });
         it('应该在提供空字符串message时保持空字符串', () => {
             const type = 'VALIDATION_ERROR';
-            const error = new UserError(type, '');
+            const error = new UserError(type, {}, '');
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(UserError);
             expect(error.name).toBe('UserError');
@@ -43,34 +43,32 @@ describe('UserError', () => {
             const type = 'VALIDATION_ERROR';
             const message = '输入验证失败';
             const cause = new Error('原始错误');
-            const error = new UserError(type, message, { cause });
+            const error = new UserError(type, { cause }, message);
             expect(error.cause).toBe(cause);
         });
         it('应该支持ErrorOptions参数且message为可选', () => {
             const type = 'VALIDATION_ERROR';
             const cause = new Error('原始错误');
-            const error = new UserError(type, undefined, { cause });
+            const error = new UserError(type, { cause });
             expect(error.cause).toBe(cause);
             expect(error.message).toBe('');
         });
         it('应该正确设置错误堆栈信息', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(error.stack).toBeDefined();
             expect(error.stack).toContain('UserError');
         });
     });
     describe('is', () => {
         it('应该正确识别UserError实例', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(UserError.is(error)).toBe(true);
         });
         it('应该正确识别非UserError实例', () => {
             const regularError = new Error('普通错误');
-            const systemError = new SystemError('SYSTEM_ERROR', '系统错误');
-            const unknownError = new UnknownError('未知错误');
+            const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
             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);
@@ -78,7 +76,7 @@ describe('UserError', () => {
             expect(UserError.is({})).toBe(false);
         });
         it('应该支持类型守卫功能', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             if (UserError.is(error)) {
                 // 在类型守卫内部，error的类型应该被正确推断
                 expect(error.type).toBe('TEST_ERROR');
@@ -89,13 +87,13 @@ describe('UserError', () => {
     });
     describe('继承行为', () => {
         it('应该正确继承Error的所有属性和方法', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             expect(error.toString()).toContain('测试错误');
             expect(error.toString()).toContain('UserError');
             expect(error instanceof Error).toBe(true);
         });
         it('应该支持Error的标准用法', () => {
-            const error = new UserError('TEST_ERROR', '测试错误');
+            const error = new UserError('TEST_ERROR', undefined, '测试错误');
             try {
                 throw error;
             }
@@ -111,7 +109,7 @@ describe('SystemError', () => {
         it('应该正确创建SystemError实例', () => {
             const type = 'DATABASE_ERROR';
             const message = '数据库连接失败';
-            const error = new SystemError(type, message);
+            const error = new SystemError(type, undefined, message);
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(SystemError);
             expect(error.name).toBe('SystemError');
@@ -138,7 +136,7 @@ describe('SystemError', () => {
         });
         it('应该在提供空字符串message时保持空字符串', () => {
             const type = 'DATABASE_ERROR';
-            const error = new SystemError(type, '');
+            const error = new SystemError(type, {}, '');
             expect(error).toBeInstanceOf(Error);
             expect(error).toBeInstanceOf(SystemError);
             expect(error.name).toBe('SystemError');
@@ -149,34 +147,32 @@ describe('SystemError', () => {
             const type = 'NETWORK_ERROR';
             const message = '网络请求失败';
             const cause = new Error('连接超时');
-            const error = new SystemError(type, message, { cause });
+            const error = new SystemError(type, { cause }, message);
             expect(error.cause).toBe(cause);
         });
         it('应该支持ErrorOptions参数且message为可选', () => {
             const type = 'NETWORK_ERROR';
             const cause = new Error('连接超时');
-            const error = new SystemError(type, undefined, { cause });
+            const error = new SystemError(type, { cause });
             expect(error.cause).toBe(cause);
             expect(error.message).toBe('');
         });
         it('应该正确设置错误堆栈信息', () => {
-            const error = new SystemError('FILE_ERROR', '文件读取失败');
+            const error = new SystemError('FILE_ERROR', undefined, '文件读取失败');
             expect(error.stack).toBeDefined();
             expect(error.stack).toContain('SystemError');
         });
     });
     describe('is', () => {
         it('应该正确识别SystemError实例', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             expect(SystemError.is(error)).toBe(true);
         });
         it('应该正确识别非SystemError实例', () => {
             const regularError = new Error('普通错误');
-            const userError = new UserError('USER_ERROR', '用户错误');
-            const unknownError = new UnknownError('未知错误');
+            const userError = new UserError('USER_ERROR', undefined, '用户错误');
             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);
@@ -184,7 +180,7 @@ describe('SystemError', () => {
             expect(SystemError.is({})).toBe(false);
         });
         it('应该支持类型守卫功能', () => {
-            const error = new SystemError('DATABASE_ERROR', '数据库错误');
+            const error = new SystemError('DATABASE_ERROR', undefined, '数据库错误');
             if (SystemError.is(error)) {
                 // 在类型守卫内部，error的类型应该被正确推断
                 expect(error.type).toBe('DATABASE_ERROR');
@@ -195,13 +191,13 @@ describe('SystemError', () => {
     });
     describe('继承行为', () => {
         it('应该正确继承Error的所有属性和方法', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             expect(error.toString()).toContain('测试错误');
             expect(error.toString()).toContain('SystemError');
             expect(error instanceof Error).toBe(true);
         });
         it('应该支持Error的标准用法', () => {
-            const error = new SystemError('TEST_ERROR', '测试错误');
+            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
             try {
                 throw error;
             }
@@ -212,99 +208,176 @@ describe('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('未知错误');
+    it('两种错误类型应该是不同的类', () => {
+        const userError = new UserError('USER_ERROR', undefined, '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
         // 每种错误只能被自己的类型检查函数识别
         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('未知错误');
+        const userError = new UserError('USER_ERROR', undefined, '用户错误');
+        const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
         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', '字段必填');
+        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', '数据库连接失败');
+        const error = new SystemError('DATABASE_ERROR', {}, '数据库连接失败');
         expect(error.type).toBe('DATABASE_ERROR');
         expect(SystemError.is(error)).toBe(true);
     });
 });
+describe('define 工厂方法', () => {
+    describe('UserError.define', () => {
+        it('应该定义一个绑定了特定错误类型的 UserError 类', () => {
+            const MyUserError = UserError.define({
+                'validation-failed': {},
+                'permission-denied': {},
+                'not-found': {}
+            });
+            const error = new MyUserError('validation-failed', {
+                field: 'email',
+                value: 'invalid@'
+            }, '验证失败');
+            expect(error).toBeInstanceOf(Error);
+            expect(error.name).toBe('UserError');
+            expect(error.type).toBe('validation-failed');
+            expect(error.message).toBe('验证失败');
+            expect(error.context).toEqual({ field: 'email', value: 'invalid@' });
+        });
+        it('应该支持 is 类型守卫', () => {
+            const MyUserError = UserError.define({
+                'test-error': {}
+            });
+            const error = new MyUserError('test-error', { code: 123 }, '测试错误');
+            expect(MyUserError.is(error)).toBe(true);
+            expect(MyUserError.is(new Error('普通错误'))).toBe(false);
+            expect(MyUserError.is(null)).toBe(false);
+        });
+        it('应该支持多次调用 define 定义不同的错误类', () => {
+            const ValidationError = UserError.define({
+                'required': {},
+                'invalid': {}
+            });
+            const AuthError = UserError.define({
+                'unauthorized': {},
+                'forbidden': {}
+            });
+            const validationError = new ValidationError('required', { field: 'username' }, '必填字段');
+            const authError = new AuthError('unauthorized', { reason: 'token expired' }, '未授权');
+            expect(validationError.type).toBe('required');
+            expect(authError.type).toBe('unauthorized');
+            expect(ValidationError.is(validationError)).toBe(true);
+            expect(ValidationError.is(authError)).toBe(false); // 不同的类不会互相识别
+            expect(AuthError.is(authError)).toBe(true);
+            expect(AuthError.is(validationError)).toBe(false); // 不同的类不会互相识别
+        });
+        it('应该支持不传 context 参数', () => {
+            const MyUserError = UserError.define({
+                'simple-error': {}
+            });
+            const error = new MyUserError('simple-error', undefined, '简单错误');
+            expect(error.type).toBe('simple-error');
+            expect(error.message).toBe('简单错误');
+            expect(error.context).toBeUndefined();
+        });
+        it('应该支持不传 message 参数', () => {
+            const MyUserError = UserError.define({
+                'no-message': {}
+            });
+            const error = new MyUserError('no-message');
+            expect(error.type).toBe('no-message');
+            expect(error.message).toBe('');
+        });
+        it('应该暴露所有定义的错误类型', () => {
+            const MyUserError = UserError.define({
+                'validation-failed': {},
+                'permission-denied': {},
+                'not-found': {}
+            });
+            expect(MyUserError.types).toEqual(['validation-failed', 'permission-denied', 'not-found']);
+            expect(MyUserError.types).toHaveLength(3);
+        });
+    });
+    describe('SystemError.define', () => {
+        it('应该定义一个绑定了特定错误类型的 SystemError 类', () => {
+            const MySystemError = SystemError.define({
+                'database-error': {},
+                'network-error': {},
+                'service-unavailable': {}
+            });
+            const error = new MySystemError('database-error', {
+                query: 'SELECT * FROM users',
+                table: 'users'
+            }, '数据库错误');
+            expect(error).toBeInstanceOf(Error);
+            expect(error.name).toBe('SystemError');
+            expect(error.type).toBe('database-error');
+            expect(error.message).toBe('数据库错误');
+            expect(error.context).toEqual({ query: 'SELECT * FROM users', table: 'users' });
+        });
+        it('应该支持 is 类型守卫', () => {
+            const MySystemError = SystemError.define({
+                'test-error': {}
+            });
+            const error = new MySystemError('test-error', { code: 500 }, '测试错误');
+            expect(MySystemError.is(error)).toBe(true);
+            expect(MySystemError.is(new Error('普通错误'))).toBe(false);
+            expect(MySystemError.is(null)).toBe(false);
+        });
+        it('应该支持多次调用 define 定义不同的错误类', () => {
+            const DatabaseError = SystemError.define({
+                'connection-failed': {},
+                'query-timeout': {}
+            });
+            const NetworkError = SystemError.define({
+                'request-failed': {},
+                'timeout': {}
+            });
+            const dbError = new DatabaseError('connection-failed', { host: 'localhost', port: 5432 }, '连接失败');
+            const netError = new NetworkError('request-failed', { url: '/api/data', method: 'GET' }, '请求失败');
+            expect(dbError.type).toBe('connection-failed');
+            expect(netError.type).toBe('request-failed');
+            expect(DatabaseError.is(dbError)).toBe(true);
+            expect(DatabaseError.is(netError)).toBe(false); // 不同的类不会互相识别
+            expect(NetworkError.is(netError)).toBe(true);
+            expect(NetworkError.is(dbError)).toBe(false); // 不同的类不会互相识别
+        });
+        it('应该支持不传 context 参数', () => {
+            const MySystemError = SystemError.define({
+                'simple-error': {}
+            });
+            const error = new MySystemError('simple-error', undefined, '简单错误');
+            expect(error.type).toBe('simple-error');
+            expect(error.message).toBe('简单错误');
+            expect(error.context).toBeUndefined();
+        });
+        it('应该支持不传 message 参数', () => {
+            const MySystemError = SystemError.define({
+                'no-message': {}
+            });
+            const error = new MySystemError('no-message');
+            expect(error.type).toBe('no-message');
+            expect(error.message).toBe('');
+        });
+        it('应该暴露所有定义的错误类型', () => {
+            const MySystemError = SystemError.define({
+                'database-error': {},
+                'network-error': {},
+                'service-unavailable': {}
+            });
+            expect(MySystemError.types).toEqual(['database-error', 'network-error', 'service-unavailable']);
+            expect(MySystemError.types).toHaveLength(3);
+        });
+    });
+});

package/output/error/index.d.ts

@@ -1,2 +1,3 @@
-export { UserError, SystemError, UnknownError, UserErrorTypes, SystemErrorTypes, UserErrorType, SystemErrorType, UserErrorContext, SystemErrorContext } from './error';
+export { UserError, SystemError } from './error';
+export type { ErrorContext } from './error';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACX,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/error/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB,YAAY,EACV,YAAY,EACb,MAAM,SAAS,CAAA"}

package/output/error/index.js

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

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