@taicode/common-base 3.7.5 → 3.7.7

package/output/error/error.test.js

@@ -1,420 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { UserError, SystemError } from './error.js';
-describe('UserError', () => {
-    describe('constructor', () => {
-        it('应该正确创建UserError实例', () => {
-            const type = 'VALIDATION_ERROR';
-            const message = '输入验证失败';
-            const error = new UserError(type, undefined, 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('应该在未提供message时使用空字符串作为默认message', () => {
-            const type = 'VALIDATION_ERROR';
-            const error = new UserError(type);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(UserError);
-            expect(error.name).toBe('UserError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该在提供undefined message时使用空字符串作为默认message', () => {
-            const type = 'VALIDATION_ERROR';
-            const error = new UserError(type, undefined);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(UserError);
-            expect(error.name).toBe('UserError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该在提供空字符串message时保持空字符串', () => {
-            const type = 'VALIDATION_ERROR';
-            const error = new UserError(type, {}, '');
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(UserError);
-            expect(error.name).toBe('UserError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该支持ErrorOptions参数', () => {
-            const type = 'VALIDATION_ERROR';
-            const message = '输入验证失败';
-            const cause = new Error('原始错误');
-            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, { cause });
-            expect(error.cause).toBe(cause);
-            expect(error.message).toBe('');
-        });
-        it('应该正确设置错误堆栈信息', () => {
-            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', undefined, '测试错误');
-            expect(UserError.is(error)).toBe(true);
-        });
-        it('应该正确识别非UserError实例', () => {
-            const regularError = new Error('普通错误');
-            const systemError = new SystemError('SYSTEM_ERROR', undefined, '系统错误');
-            expect(UserError.is(regularError)).toBe(false);
-            expect(UserError.is(systemError)).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', undefined, '测试错误');
-            if (UserError.is(error)) {
-                // 在类型守卫内部，error的类型应该被正确推断
-                expect(error.type).toBe('TEST_ERROR');
-                expect(error.message).toBe('测试错误');
-                expect(error.name).toBe('UserError');
-            }
-        });
-        it('在原型链丢失的情况下仍能通过品牌标记正确识别', () => {
-            const error = new UserError('TEST_ERROR', undefined, '测试错误');
-            // 模拟编译/序列化后原型链丢失的情况
-            const plainObj = Object.create(null);
-            Object.assign(plainObj, error);
-            // 手动复制品牌标记（Symbol.for 在不同模块实例中指向同一个 Symbol）
-            const brand = Symbol.for('@taicode/common/UserError');
-            Object.defineProperty(plainObj, brand, { value: true });
-            expect(plainObj instanceof UserError).toBe(false); // instanceof 失效
-            expect(UserError.is(plainObj)).toBe(true); // 品牌标记仍然有效
-        });
-    });
-    describe('继承行为', () => {
-        it('应该正确继承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', undefined, '测试错误');
-            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, undefined, 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('应该在未提供message时使用空字符串作为默认message', () => {
-            const type = 'DATABASE_ERROR';
-            const error = new SystemError(type);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(SystemError);
-            expect(error.name).toBe('SystemError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该在提供undefined message时使用空字符串作为默认message', () => {
-            const type = 'DATABASE_ERROR';
-            const error = new SystemError(type, undefined);
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(SystemError);
-            expect(error.name).toBe('SystemError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该在提供空字符串message时保持空字符串', () => {
-            const type = 'DATABASE_ERROR';
-            const error = new SystemError(type, {}, '');
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(SystemError);
-            expect(error.name).toBe('SystemError');
-            expect(error.type).toBe(type);
-            expect(error.message).toBe('');
-        });
-        it('应该支持ErrorOptions参数', () => {
-            const type = 'NETWORK_ERROR';
-            const message = '网络请求失败';
-            const cause = new Error('连接超时');
-            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, { cause });
-            expect(error.cause).toBe(cause);
-            expect(error.message).toBe('');
-        });
-        it('应该正确设置错误堆栈信息', () => {
-            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', undefined, '测试错误');
-            expect(SystemError.is(error)).toBe(true);
-        });
-        it('应该正确识别非SystemError实例', () => {
-            const regularError = new Error('普通错误');
-            const userError = new UserError('USER_ERROR', undefined, '用户错误');
-            expect(SystemError.is(regularError)).toBe(false);
-            expect(SystemError.is(userError)).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', undefined, '数据库错误');
-            if (SystemError.is(error)) {
-                // 在类型守卫内部，error的类型应该被正确推断
-                expect(error.type).toBe('DATABASE_ERROR');
-                expect(error.message).toBe('数据库错误');
-                expect(error.name).toBe('SystemError');
-            }
-        });
-        it('在原型链丢失的情况下仍能通过品牌标记正确识别', () => {
-            const error = new SystemError('TEST_ERROR', undefined, '测试错误');
-            // 模拟编译/序列化后原型链丢失的情况
-            const plainObj = Object.create(null);
-            Object.assign(plainObj, error);
-            const brand = Symbol.for('@taicode/common/SystemError');
-            Object.defineProperty(plainObj, brand, { value: true });
-            expect(plainObj instanceof SystemError).toBe(false); // instanceof 失效
-            expect(SystemError.is(plainObj)).toBe(true); // 品牌标记仍然有效
-        });
-    });
-    describe('继承行为', () => {
-        it('应该正确继承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', undefined, '测试错误');
-            try {
-                throw error;
-            }
-            catch (caught) {
-                expect(caught).toBe(error);
-                expect(caught).toBeInstanceOf(SystemError);
-            }
-        });
-    });
-});
-describe('错误类型区分', () => {
-    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(UserError.is(systemError)).toBe(false);
-        expect(SystemError.is(systemError)).toBe(true);
-    });
-    it('所有错误类型都应该是Error的实例', () => {
-        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);
-    });
-    it('define 创建的 BoundError 也能被基类 is 方法识别', () => {
-        const MyUserError = UserError.define({
-            'test': {}
-        });
-        const MySystemError = SystemError.define({
-            'test': {}
-        });
-        const userError = new MyUserError('test', { msg: 'hello' }, '测试');
-        const systemError = new MySystemError('test', { msg: 'world' }, '测试');
-        // 基类的 is 方法应该能识别 define 创建的子类实例
-        expect(UserError.is(userError)).toBe(true);
-        expect(SystemError.is(systemError)).toBe(true);
-        // 但不会互相匹配
-        expect(UserError.is(systemError)).toBe(false);
-        expect(SystemError.is(userError)).toBe(false);
-    });
-});
-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);
-    });
-});
-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,3 +0,0 @@
-export { UserError, SystemError } from './error.js';
-export type { ErrorContext } from './error.js';
-//# sourceMappingURL=index.d.ts.map

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

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

package/output/error/index.js

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

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

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

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

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

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

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

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