@taicode/common-base 3.7.5 → 3.7.7

package/output/color/color.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { getRandomColor, getRandomColors, interpolateColors } from './color.js';
-describe('getRandomColor 函数', () => {
-    // Mock console.log to avoid noise in tests
-    beforeEach(() => {
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('应该为相同的种子生成一致的颜色', () => {
-        const colorFunc = getRandomColor(123);
-        const color1 = colorFunc(0);
-        const color2 = colorFunc(0);
-        expect(color1).toBe(color2);
-        expect(color1).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
-    });
-    it('应该处理数字种子', () => {
-        const colorFunc = getRandomColor(42);
-        const color = colorFunc(0);
-        expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
-    });
-    it('应该处理字符串种子', () => {
-        const colorFunc = getRandomColor('test');
-        const color = colorFunc(0);
-        expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
-    });
-    it('应该处理 null 种子', () => {
-        const colorFunc = getRandomColor(null);
-        const color = colorFunc(0);
-        expect(color).toBe('hsl(0, 80%, 45%)');
-    });
-    it('应该为不同的偏移量生成不同的颜色', () => {
-        const colorFunc = getRandomColor(123);
-        const color1 = colorFunc(0);
-        const color2 = colorFunc(100);
-        expect(color1).not.toBe(color2);
-    });
-    it('应该遵守自定义范围参数', () => {
-        const colorFunc = getRandomColor(123);
-        const color = colorFunc(50, 180);
-        // 解析HSL值
-        const match = color.match(/hsl\((\d+), 80%, 45%\)/);
-        expect(match).toBeTruthy();
-        const hue = parseInt(match[1]);
-        expect(hue).toBeLessThan(180);
-    });
-});
-describe('getRandomColors 函数', () => {
-    beforeEach(() => {
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('应该生成指定数量的颜色', () => {
-        const colors = getRandomColors(123, 50, 5);
-        expect(colors).toHaveLength(5);
-        colors.forEach(color => {
-            expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
-        });
-    });
-    it('应该以间隔生成不同的颜色', () => {
-        const colors = getRandomColors(123, 50, 3);
-        expect(colors[0]).not.toBe(colors[1]);
-        expect(colors[1]).not.toBe(colors[2]);
-    });
-    it('应该处理零计数', () => {
-        const colors = getRandomColors(123, 50, 0);
-        expect(colors).toHaveLength(0);
-    });
-});
-describe('interpolateColors 函数', () => {
-    it('应该在两个 HSL 颜色之间插值', () => {
-        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 2);
-        const color0 = interpolate(0);
-        const color1 = interpolate(1);
-        const color2 = interpolate(2);
-        expect(color0).toBe('hsl(0, 80%, 45%)');
-        expect(color1).toBe('hsl(60, 80%, 45%)');
-        expect(color2).toBe('hsl(120, 80%, 45%)');
-    });
-    it('应该处理不同的饱和度和明度值', () => {
-        const interpolate = interpolateColors('hsl(0, 50%, 30%)', 'hsl(0, 90%, 70%)', 1);
-        const color0 = interpolate(0);
-        const color1 = interpolate(1);
-        expect(color0).toBe('hsl(0, 50%, 30%)');
-        expect(color1).toBe('hsl(0, 90%, 70%)');
-    });
-    it('应该为无效的 HSL 颜色格式抛出错误', () => {
-        expect(() => {
-            interpolateColors('invalid-color', 'hsl(120, 80%, 45%)', 2);
-        }).toThrow('Invalid HSL color: invalid-color');
-    });
-    it('应该为索引超出边界抛出错误', () => {
-        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 2);
-        expect(() => {
-            interpolate(-1);
-        }).toThrow('Index out of bounds: -1. Valid range is 0 to 2.');
-        expect(() => {
-            interpolate(3);
-        }).toThrow('Index out of bounds: 3. Valid range is 0 to 2.');
-    });
-    it('应该处理零步骤', () => {
-        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 0);
-        const color = interpolate(0);
-        // 当步骤为0时，应该返回第一个颜色
-        expect(color).toBe('hsl(0, 80%, 45%)');
-    });
-});

package/output/color/index.d.ts

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

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

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

package/output/color/index.js

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

package/output/debounce/debounce.d.ts

@@ -1,7 +0,0 @@
-/**
- * 防抖装饰器 - 基于 TC39 Stage 3 Decorators 提案
- * 在最后一次调用后等待指定时间才执行函数
- */
-export declare function debounceFn<T extends (...args: any[]) => any>(fn: T, wait: number): T;
-export declare function debounce<T extends (...args: any[]) => any>(wait: number): (originalMethod: T, context: ClassMethodDecoratorContext) => T;
-//# sourceMappingURL=debounce.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../source/debounce/debounce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1D,EAAE,EAAE,CAAC,EACL,IAAI,EAAE,MAAM,GACX,CAAC,CAmBH;AAGD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,EAAE,MAAM,IACrD,gBAAgB,CAAC,EAAE,SAAS,2BAA2B,KAAG,CAAC,CAS7E"}

package/output/debounce/debounce.js

@@ -1,36 +0,0 @@
-/**
- * 防抖装饰器 - 基于 TC39 Stage 3 Decorators 提案
- * 在最后一次调用后等待指定时间才执行函数
- */
-// 通用防抖函数
-export function debounceFn(fn, wait) {
-    let timeout = null;
-    function debounced(...args) {
-        return new Promise((resolve, reject) => {
-            if (timeout)
-                clearTimeout(timeout);
-            timeout = setTimeout(async () => {
-                try {
-                    const result = await Promise.resolve(fn.apply(this, args));
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            }, wait);
-        });
-    }
-    return debounced;
-}
-// TC39 Stage 3 装饰器实现
-export function debounce(wait) {
-    return function (originalMethod, context) {
-        // 每个实例独立
-        context.addInitializer(function () {
-            const self = this;
-            const debouncedMethod = debounceFn(originalMethod.bind(self), wait);
-            self[context.name] = debouncedMethod;
-        });
-        return originalMethod;
-    };
-}

package/output/debounce/debounce.test.d.ts

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

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

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

package/output/debounce/debounce.test.js

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { debounce, debounceFn } from './debounce.js';
-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

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

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

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

package/output/debounce/index.js

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

package/output/disposer/disposer.d.ts

@@ -1,8 +0,0 @@
-type CleanupFunction = () => unknown | Promise<unknown>;
-export declare class Disposer {
-    private cleanupFunctions;
-    addDisposer(cleanupFn: CleanupFunction): void;
-    dispose(): Promise<void>;
-}
-export {};
-//# sourceMappingURL=disposer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/disposer/disposer.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;AAEvD,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAwB;IAGhD,WAAW,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI;IAKvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAY/B"}

package/output/disposer/disposer.js

@@ -1,21 +0,0 @@
-import { logger } from '../logger/index.js';
-export class Disposer {
-    cleanupFunctions = [];
-    // 添加清理函数
-    addDisposer(cleanupFn) {
-        this.cleanupFunctions.push(cleanupFn);
-    }
-    // 执行所有清理函数
-    async dispose() {
-        const cleanupFunctions = this.cleanupFunctions;
-        this.cleanupFunctions = [];
-        for (const cleanupFn of cleanupFunctions) {
-            try {
-                await cleanupFn();
-            }
-            catch (error) {
-                logger.error('Error during cleanup:', error);
-            }
-        }
-    }
-}

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

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

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

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

package/output/disposer/disposer.test.js

@@ -1,216 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Disposer } from './disposer.js';
-import { logger } from '../logger/index.js';
-describe('Disposer', () => {
-    let disposer;
-    beforeEach(() => {
-        disposer = new Disposer();
-    });
-    describe('addDisposer', () => {
-        it('应该能够添加清理函数', () => {
-            const cleanupFn = vi.fn();
-            expect(() => {
-                disposer.addDisposer(cleanupFn);
-            }).not.toThrow();
-        });
-        it('应该能够添加多个清理函数', async () => {
-            const cleanupFn1 = vi.fn();
-            const cleanupFn2 = vi.fn();
-            const cleanupFn3 = vi.fn();
-            disposer.addDisposer(cleanupFn1);
-            disposer.addDisposer(cleanupFn2);
-            disposer.addDisposer(cleanupFn3);
-            await disposer.dispose();
-            expect(cleanupFn1).toHaveBeenCalledOnce();
-            expect(cleanupFn2).toHaveBeenCalledOnce();
-            expect(cleanupFn3).toHaveBeenCalledOnce();
-        });
-        it('应该能够添加返回不同类型的清理函数', async () => {
-            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);
-            await disposer.dispose();
-            expect(voidFn).toHaveBeenCalled();
-            expect(stringFn).toHaveBeenCalled();
-            expect(numberFn).toHaveBeenCalled();
-            expect(promiseFn).toHaveBeenCalled();
-        });
-    });
-    describe('dispose', () => {
-        it('应该执行所有清理函数', async () => {
-            const cleanupFn1 = vi.fn();
-            const cleanupFn2 = vi.fn();
-            const cleanupFn3 = vi.fn();
-            disposer.addDisposer(cleanupFn1);
-            disposer.addDisposer(cleanupFn2);
-            disposer.addDisposer(cleanupFn3);
-            await disposer.dispose();
-            expect(cleanupFn1).toHaveBeenCalledOnce();
-            expect(cleanupFn2).toHaveBeenCalledOnce();
-            expect(cleanupFn3).toHaveBeenCalledOnce();
-        });
-        it('应该按添加顺序执行清理函数', async () => {
-            const executionOrder = [];
-            disposer.addDisposer(() => executionOrder.push(1));
-            disposer.addDisposer(() => executionOrder.push(2));
-            disposer.addDisposer(() => executionOrder.push(3));
-            await disposer.dispose();
-            expect(executionOrder).toEqual([1, 2, 3]);
-        });
-        it('应该按添加顺序执行异步清理函数', async () => {
-            const executionOrder = [];
-            disposer.addDisposer(async () => {
-                await Promise.resolve();
-                executionOrder.push(1);
-            });
-            disposer.addDisposer(async () => {
-                await Promise.resolve();
-                executionOrder.push(2);
-            });
-            disposer.addDisposer(async () => {
-                await Promise.resolve();
-                executionOrder.push(3);
-            });
-            await disposer.dispose();
-            expect(executionOrder).toEqual([1, 2, 3]);
-        });
-        it('应该处理清理函数中的错误', async () => {
-            const workingFn1 = vi.fn();
-            const errorFn = vi.fn(() => {
-                throw new Error('Cleanup error');
-            });
-            const workingFn2 = vi.fn();
-            // 模拟 logger.error
-            const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => { });
-            disposer.addDisposer(workingFn1);
-            disposer.addDisposer(errorFn);
-            disposer.addDisposer(workingFn2);
-            // dispose 不应该抛出错误
-            await expect(disposer.dispose()).resolves.toBeUndefined();
-            // 所有函数都应该被调用
-            expect(workingFn1).toHaveBeenCalled();
-            expect(errorFn).toHaveBeenCalled();
-            expect(workingFn2).toHaveBeenCalled();
-            // 错误应该被记录
-            expect(loggerErrorSpy).toHaveBeenCalledWith('Error during cleanup:', expect.any(Error));
-            loggerErrorSpy.mockRestore();
-        });
-        it('应该在执行后清空清理函数列表', async () => {
-            const cleanupFn = vi.fn();
-            disposer.addDisposer(cleanupFn);
-            await disposer.dispose();
-            expect(cleanupFn).toHaveBeenCalledOnce();
-            // 再次调用 dispose 不应该执行任何函数
-            await disposer.dispose();
-            expect(cleanupFn).toHaveBeenCalledOnce();
-        });
-        it('应该能够在清空后重新添加清理函数', async () => {
-            const firstCleanup = vi.fn();
-            const secondCleanup = vi.fn();
-            disposer.addDisposer(firstCleanup);
-            await disposer.dispose();
-            disposer.addDisposer(secondCleanup);
-            await disposer.dispose();
-            expect(firstCleanup).toHaveBeenCalledOnce();
-            expect(secondCleanup).toHaveBeenCalledOnce();
-        });
-        it('应该在没有清理函数时安全执行', async () => {
-            await expect(disposer.dispose()).resolves.toBeUndefined();
-        });
-        it('应该能够多次调用 dispose', async () => {
-            const cleanupFn = vi.fn();
-            disposer.addDisposer(cleanupFn);
-            await disposer.dispose();
-            await disposer.dispose();
-            await disposer.dispose();
-            expect(cleanupFn).toHaveBeenCalledOnce();
-        });
-    });
-    describe('实际使用场景', () => {
-        it('应该能够清理事件监听器', async () => {
-            const removeEventListener = vi.fn();
-            const unsubscribe = vi.fn();
-            disposer.addDisposer(removeEventListener);
-            disposer.addDisposer(unsubscribe);
-            await disposer.dispose();
-            expect(removeEventListener).toHaveBeenCalled();
-            expect(unsubscribe).toHaveBeenCalled();
-        });
-        it('应该能够清理定时器', async () => {
-            const clearTimeout = vi.fn();
-            const clearInterval = vi.fn();
-            disposer.addDisposer(() => clearTimeout(123));
-            disposer.addDisposer(() => clearInterval(456));
-            await disposer.dispose();
-            expect(clearTimeout).toHaveBeenCalledWith(123);
-            expect(clearInterval).toHaveBeenCalledWith(456);
-        });
-        it('应该能够清理资源连接', async () => {
-            const closeConnection = vi.fn();
-            const releaseResource = vi.fn();
-            disposer.addDisposer(() => closeConnection());
-            disposer.addDisposer(() => releaseResource());
-            await disposer.dispose();
-            expect(closeConnection).toHaveBeenCalled();
-            expect(releaseResource).toHaveBeenCalled();
-        });
-        it('应该与 EventEmitter 配合使用', async () => {
-            // 模拟 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());
-            await disposer.dispose();
-            expect(offFunction1).toHaveBeenCalled();
-            expect(offFunction2).toHaveBeenCalled();
-            expect(mockEventEmitter.cleanup).toHaveBeenCalled();
-        });
-    });
-    describe('错误处理', () => {
-        it('应该捕获并记录同步错误', async () => {
-            const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => { });
-            const error = new Error('Sync error');
-            disposer.addDisposer(() => {
-                throw error;
-            });
-            await disposer.dispose();
-            expect(loggerErrorSpy).toHaveBeenCalledWith('Error during cleanup:', error);
-            loggerErrorSpy.mockRestore();
-        });
-        it('应该处理不同类型的错误', async () => {
-            const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => { });
-            disposer.addDisposer(() => {
-                throw new TypeError('Type error');
-            });
-            disposer.addDisposer(() => {
-                throw 'String error';
-            });
-            disposer.addDisposer(() => {
-                throw { message: 'Object error' };
-            });
-            await disposer.dispose();
-            expect(loggerErrorSpy).toHaveBeenCalledTimes(3);
-            loggerErrorSpy.mockRestore();
-        });
-        it('应该捕获并记录异步错误', async () => {
-            const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => { });
-            const asyncError = new Error('Async error');
-            disposer.addDisposer(async () => {
-                throw asyncError;
-            });
-            await disposer.dispose();
-            expect(loggerErrorSpy).toHaveBeenCalledWith('Error during cleanup:', asyncError);
-            loggerErrorSpy.mockRestore();
-        });
-    });
-});

package/output/disposer/index.d.ts

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

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

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

package/output/disposer/index.js

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