@taicode/common-base 1.1.0 → 1.1.2

package/output/debounce/debounce.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { debounce, debounceFn } from './debounce';
+describe('debounce', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.useRealTimers();
+    });
+    describe('debounceFn', () => {
+        it('应该延迟函数执行', async () => {
+            const mockFn = vi.fn().mockResolvedValue('result');
+            const debouncedFn = debounceFn(mockFn, 100);
+            const promise = debouncedFn('arg1', 'arg2');
+            // 函数不应该立即执行
+            expect(mockFn).not.toHaveBeenCalled();
+            // 推进时间
+            vi.advanceTimersByTime(100);
+            await promise;
+            expect(mockFn).toHaveBeenCalledOnce();
+            expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');
+        });
+        it('应该取消之前的调用', async () => {
+            const mockFn = vi.fn().mockResolvedValue('result');
+            const debouncedFn = debounceFn(mockFn, 100);
+            // 快速连续调用
+            debouncedFn('first');
+            debouncedFn('second');
+            const finalPromise = debouncedFn('third');
+            // 推进时间
+            vi.advanceTimersByTime(100);
+            await finalPromise;
+            // 只应该执行最后一次调用
+            expect(mockFn).toHaveBeenCalledOnce();
+            expect(mockFn).toHaveBeenCalledWith('third');
+        });
+        it('应该处理同步函数', async () => {
+            const mockFn = vi.fn().mockReturnValue('sync-result');
+            const debouncedFn = debounceFn(mockFn, 100);
+            const promise = debouncedFn('arg');
+            vi.advanceTimersByTime(100);
+            const result = await promise;
+            expect(result).toBe('sync-result');
+            expect(mockFn).toHaveBeenCalledWith('arg');
+        });
+        it('应该处理异步函数', async () => {
+            const mockFn = vi.fn().mockResolvedValue('async-result');
+            const debouncedFn = debounceFn(mockFn, 100);
+            const promise = debouncedFn('arg');
+            vi.advanceTimersByTime(100);
+            const result = await promise;
+            expect(result).toBe('async-result');
+        });
+        it('应该处理函数执行错误', async () => {
+            const error = new Error('Test error');
+            const mockFn = vi.fn().mockRejectedValue(error);
+            const debouncedFn = debounceFn(mockFn, 100);
+            const promise = debouncedFn('arg');
+            vi.advanceTimersByTime(100);
+            await expect(promise).rejects.toThrow('Test error');
+        });
+        it('应该保持 this 上下文', async () => {
+            class TestClass {
+                value = 'test-value';
+                getValue() {
+                    return this.value;
+                }
+            }
+            const instance = new TestClass();
+            const debouncedMethod = debounceFn(instance.getValue, 100);
+            const promise = debouncedMethod.call(instance);
+            vi.advanceTimersByTime(100);
+            const result = await promise;
+            expect(result).toBe('test-value');
+        });
+    });
+    describe('debounce decorator', () => {
+        it('应该装饰类方法', async () => {
+            class TestClass {
+                callCount = 0;
+                @debounce(100)
+                increment() {
+                    this.callCount++;
+                    return this.callCount;
+                }
+            }
+            const instance = new TestClass();
+            // 快速连续调用
+            instance.increment();
+            instance.increment();
+            instance.increment();
+            // 推进时间
+            vi.advanceTimersByTime(100);
+            // 只应该执行一次
+            expect(instance.callCount).toBe(1);
+        });
+        it('应该为每个实例独立工作', async () => {
+            class TestClass {
+                value = 0;
+                @debounce(100)
+                async setValue(newValue) {
+                    this.value = newValue;
+                    return this.value;
+                }
+            }
+            const instance1 = new TestClass();
+            const instance2 = new TestClass();
+            const promise1 = instance1.setValue(10);
+            const promise2 = instance2.setValue(20);
+            vi.advanceTimersByTime(100);
+            await Promise.all([promise1, promise2]);
+            expect(instance1.value).toBe(10);
+            expect(instance2.value).toBe(20);
+        });
+        it('应该处理带参数的方法', async () => {
+            class TestClass {
+                lastArgs = [];
+                @debounce(100)
+                async saveArgs(...args) {
+                    this.lastArgs = args;
+                    return args;
+                }
+            }
+            const instance = new TestClass();
+            instance.saveArgs(1, 2, 3);
+            instance.saveArgs(4, 5, 6);
+            const promise = instance.saveArgs(7, 8, 9);
+            vi.advanceTimersByTime(100);
+            const result = await promise;
+            expect(result).toEqual([7, 8, 9]);
+            expect(instance.lastArgs).toEqual([7, 8, 9]);
+        });
+    });
+});

package/output/debounce/index.d.ts

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

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

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

package/output/debounce/index.js

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

package/output/disposer/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/disposer/disposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/disposer/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/disposer/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/disposer/disposer.test.d.ts

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

package/output/disposer/disposer.test.d.ts.map

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

package/output/disposer/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/disposer/index.d.ts

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

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

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

package/output/disposer/index.js

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

package/output/error/error.d.ts

@@ -0,0 +1,23 @@
+interface ErrorOptions {
+    cause?: unknown;
+}
+/** 用户可见的错误 */
+export declare class UserError<T extends string> extends Error {
+    type: T;
+    message: string;
+    constructor(type: T, message: string, options?: ErrorOptions);
+    static is<T extends string>(error: unknown): error is UserError<T>;
+}
+/** 系统错误 */
+export declare class SystemError<T extends string> extends Error {
+    type: T;
+    message: string;
+    constructor(type: T, message: string, options?: ErrorOptions);
+    static is<T extends string>(error: unknown): error is SystemError<T>;
+}
+export declare class UnknownError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+    static is(error: unknown): boolean;
+}
+export {};
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../source/error/error.ts"],"names":[],"mappings":"AAAA,UAAU,YAAY;IACpB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,cAAc;AACd,qBAAa,SAAS,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,KAAK;IACjC,IAAI,EAAE,CAAC;IAAS,OAAO,EAAE,MAAM;gBAA/B,IAAI,EAAE,CAAC,EAAS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;IAK1E,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC;CAGnE;AAED,WAAW;AACX,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,KAAK;IACnC,IAAI,EAAE,CAAC;IAAS,OAAO,EAAE,MAAM;gBAA/B,IAAI,EAAE,CAAC,EAAS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;IAK1E,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC;CAGrE;AAED,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;IAKnD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAGnC"}

package/output/error/error.js

@@ -0,0 +1,37 @@
+/** 用户可见的错误 */
+export class UserError extends Error {
+    type;
+    message;
+    constructor(type, message, options) {
+        super(message, options);
+        this.type = type;
+        this.message = message;
+        this.name = 'UserError';
+    }
+    static is(error) {
+        return error instanceof UserError;
+    }
+}
+/** 系统错误 */
+export class SystemError extends Error {
+    type;
+    message;
+    constructor(type, message, options) {
+        super(message, options);
+        this.type = type;
+        this.message = message;
+        this.name = 'SystemError';
+    }
+    static is(error) {
+        return error instanceof SystemError;
+    }
+}
+export class UnknownError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'UnknownError';
+    }
+    static is(error) {
+        return error instanceof UnknownError;
+    }
+}

package/output/error/error.test.d.ts

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

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

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