@taicode/common-base 1.7.0 → 1.7.2

package/output/batching-buffer/batching-buffer.test.js

@@ -0,0 +1,358 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { BatchingBuffer } from './batching-buffer';
+describe('BatchingBuffer', () => {
+    let batchProcessor;
+    let itemProcessor;
+    beforeEach(() => {
+        batchProcessor = vi.fn();
+        itemProcessor = vi.fn();
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.clearAllMocks();
+    });
+    describe('构造函数', () => {
+        it('应该正确初始化批量处理模式', () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 10,
+                flushInterval: 5000
+            });
+            expect(buffer.size).toBe(0);
+            expect(buffer.isEmpty).toBe(true);
+            expect(buffer.destroyed).toBe(false);
+        });
+        it('应该正确初始化单个处理模式', () => {
+            const buffer = new BatchingBuffer({
+                itemProcessor: itemProcessor,
+                bufferSize: 5,
+                flushInterval: 3000
+            });
+            expect(buffer.size).toBe(0);
+            expect(buffer.isEmpty).toBe(true);
+            expect(buffer.destroyed).toBe(false);
+        });
+        it('应该使用默认配置', () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor
+            });
+            expect(buffer.size).toBe(0);
+            expect(buffer.isEmpty).toBe(true);
+        });
+        it('应该在没有提供处理器时抛出错误', () => {
+            expect(() => {
+                new BatchingBuffer({});
+            }).toThrow('必须提供 batchProcessor 或 itemProcessor 其中之一');
+        });
+        it('应该在同时提供两个处理器时抛出错误', () => {
+            expect(() => {
+                new BatchingBuffer({
+                    batchProcessor: batchProcessor,
+                    itemProcessor: itemProcessor
+                });
+            }).toThrow('只能选择 batchProcessor 或 itemProcessor 中的一个');
+        });
+        it('应该在 bufferSize 无效时抛出错误', () => {
+            expect(() => {
+                new BatchingBuffer({
+                    batchProcessor: batchProcessor,
+                    bufferSize: 0
+                });
+            }).toThrow('bufferSize 必须大于 0');
+            expect(() => {
+                new BatchingBuffer({
+                    batchProcessor: batchProcessor,
+                    bufferSize: -1
+                });
+            }).toThrow('bufferSize 必须大于 0');
+        });
+        it('应该在 flushInterval 无效时抛出错误', () => {
+            expect(() => {
+                new BatchingBuffer({
+                    batchProcessor: batchProcessor,
+                    flushInterval: 0
+                });
+            }).toThrow('flushInterval 必须大于 0');
+            expect(() => {
+                new BatchingBuffer({
+                    batchProcessor: batchProcessor,
+                    flushInterval: -1
+                });
+            }).toThrow('flushInterval 必须大于 0');
+        });
+    });
+    describe('批量处理模式', () => {
+        let buffer;
+        beforeEach(() => {
+            buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 3,
+                flushInterval: 1000
+            });
+        });
+        afterEach(async () => {
+            await buffer.destroy();
+        });
+        it('应该在达到缓冲区大小时触发批量处理', () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(batchProcessor).not.toHaveBeenCalled();
+            buffer.add('item3');
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2', 'item3']);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该在时间间隔到达时触发批量处理', async () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(batchProcessor).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(1000);
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该支持手动刷新', async () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            await buffer.flush();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该支持批量添加数据', () => {
+            buffer.addBatch(['item1', 'item2', 'item3', 'item4', 'item5']);
+            expect(batchProcessor).toHaveBeenCalledTimes(2);
+            expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
+            expect(batchProcessor).toHaveBeenNthCalledWith(2, ['item4', 'item5']);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该正确处理处理器异常', () => {
+            const error = new Error('处理失败');
+            batchProcessor.mockImplementationOnce(() => {
+                throw error;
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(() => {
+                buffer.add('item3');
+            }).toThrow('处理失败');
+            // 数据应该重新放回缓冲区
+            expect(buffer.size).toBe(3);
+        });
+    });
+    describe('单个处理模式', () => {
+        let buffer;
+        beforeEach(() => {
+            buffer = new BatchingBuffer({
+                itemProcessor: itemProcessor,
+                bufferSize: 3,
+                flushInterval: 1000
+            });
+        });
+        afterEach(async () => {
+            await buffer.destroy();
+        });
+        it('应该在达到缓冲区大小时触发单个处理', () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(itemProcessor).not.toHaveBeenCalled();
+            buffer.add('item3');
+            expect(itemProcessor).toHaveBeenCalledTimes(3);
+            expect(itemProcessor).toHaveBeenNthCalledWith(1, 'item1');
+            expect(itemProcessor).toHaveBeenNthCalledWith(2, 'item2');
+            expect(itemProcessor).toHaveBeenNthCalledWith(3, 'item3');
+            expect(buffer.size).toBe(0);
+        });
+        it('应该在时间间隔到达时触发单个处理', async () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(itemProcessor).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(1000);
+            await vi.runAllTimersAsync();
+            expect(itemProcessor).toHaveBeenCalledTimes(2);
+            expect(itemProcessor).toHaveBeenNthCalledWith(1, 'item1');
+            expect(itemProcessor).toHaveBeenNthCalledWith(2, 'item2');
+            expect(buffer.size).toBe(0);
+        });
+        it('应该正确处理单个处理器异常', () => {
+            const error = new Error('单个处理失败');
+            itemProcessor.mockImplementationOnce(() => {
+                throw error;
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(() => {
+                buffer.add('item3');
+            }).toThrow('单个处理失败');
+            // 数据应该重新放回缓冲区
+            expect(buffer.size).toBe(3);
+        });
+    });
+    describe('缓冲区状态', () => {
+        let buffer;
+        beforeEach(() => {
+            buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 2000
+            });
+        });
+        afterEach(async () => {
+            await buffer.destroy();
+        });
+        it('应该正确报告缓冲区大小', () => {
+            expect(buffer.size).toBe(0);
+            expect(buffer.isEmpty).toBe(true);
+            buffer.add(1);
+            expect(buffer.size).toBe(1);
+            expect(buffer.isEmpty).toBe(false);
+            buffer.add(2);
+            buffer.add(3);
+            expect(buffer.size).toBe(3);
+            expect(buffer.isEmpty).toBe(false);
+        });
+        it('应该正确报告距离上次刷新的时间', async () => {
+            const startTime = Date.now();
+            buffer.add(1);
+            vi.advanceTimersByTime(500);
+            expect(buffer.timeSinceLastFlush).toBeGreaterThanOrEqual(500);
+            await buffer.flush();
+            expect(buffer.timeSinceLastFlush).toBeLessThan(100);
+        });
+    });
+    describe('销毁功能', () => {
+        let buffer;
+        beforeEach(() => {
+            buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 1000
+            });
+        });
+        it('应该在销毁时处理剩余数据', async () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            await buffer.destroy();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            expect(buffer.destroyed).toBe(true);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该在销毁时丢弃剩余数据（如果指定）', async () => {
+            buffer.add('item1');
+            buffer.add('item2');
+            await buffer.destroy(false);
+            expect(batchProcessor).not.toHaveBeenCalled();
+            expect(buffer.destroyed).toBe(true);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该在销毁后拒绝添加新数据', async () => {
+            await buffer.destroy();
+            expect(() => {
+                buffer.add('item1');
+            }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
+            expect(() => {
+                buffer.addBatch(['item1', 'item2']);
+            }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
+        });
+        it('应该支持重复销毁', async () => {
+            await buffer.destroy();
+            await buffer.destroy();
+            expect(buffer.destroyed).toBe(true);
+        });
+    });
+    describe('自动刷新配置', () => {
+        it('应该在 autoFlush=false 时不自动启动定时器', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 1000,
+                autoFlush: false
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            vi.advanceTimersByTime(2000);
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).not.toHaveBeenCalled();
+            expect(buffer.size).toBe(2);
+            await buffer.destroy();
+        });
+        it('应该在 autoFlush=false 时仍支持基于大小的触发', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 2,
+                flushInterval: 1000,
+                autoFlush: false
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            await buffer.destroy();
+        });
+    });
+    describe('复杂数据类型', () => {
+        let buffer;
+        beforeEach(() => {
+            buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 2,
+                flushInterval: 1000
+            });
+        });
+        afterEach(async () => {
+            await buffer.destroy();
+        });
+        it('应该正确处理复杂对象', async () => {
+            const data1 = { id: 1, name: 'test1' };
+            const data2 = { id: 2, name: 'test2' };
+            buffer.add(data1);
+            buffer.add(data2);
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith([data1, data2]);
+        });
+    });
+    describe('异步处理器', () => {
+        let asyncBatchProcessor;
+        let asyncItemProcessor;
+        beforeEach(() => {
+            asyncBatchProcessor = vi.fn().mockImplementation(async (items) => {
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return `处理了 ${items.length} 个项目`;
+            });
+            asyncItemProcessor = vi.fn().mockImplementation(async (item) => {
+                await new Promise(resolve => setTimeout(resolve, 50));
+                return `处理了项目: ${item}`;
+            });
+        });
+        it('应该正确处理异步批量处理器', () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: asyncBatchProcessor,
+                bufferSize: 2,
+                flushInterval: 1000
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(asyncBatchProcessor).toHaveBeenCalledTimes(1);
+            expect(asyncBatchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            buffer.destroy();
+        });
+        it('应该正确处理异步单个处理器', () => {
+            const buffer = new BatchingBuffer({
+                itemProcessor: asyncItemProcessor,
+                bufferSize: 2,
+                flushInterval: 1000
+            });
+            buffer.add('item1');
+            buffer.add('item2');
+            expect(asyncItemProcessor).toHaveBeenCalledTimes(2);
+            expect(asyncItemProcessor).toHaveBeenNthCalledWith(1, 'item1');
+            expect(asyncItemProcessor).toHaveBeenNthCalledWith(2, 'item2');
+            buffer.destroy();
+        });
+    });
+});

package/output/batching-buffer/index.d.ts

@@ -0,0 +1,3 @@
+export { BatchingBuffer } from './batching-buffer';
+export type { BatchingBufferOptions } from './batching-buffer';
+//# sourceMappingURL=index.d.ts.map

package/output/batching-buffer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/batching-buffer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,YAAY,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA"}

package/output/batching-buffer/index.js

@@ -0,0 +1 @@
+export { BatchingBuffer } from './batching-buffer';

package/output/index.d.ts

@@ -3,7 +3,10 @@ export * from './event-emitter';
 export * from './logger';
 export * from './error';
 export * from './service';
+export * from './ttl-cache';
 export * from './lru-cache';
+export * from './ring-cache';
+export * from './batching-buffer';
 export * from './string';
 export * from './color';
 export * from './object';

package/output/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAG1B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,UAAU,CAAA;AAGxB,cAAc,SAAS,CAAA;AAGvB,cAAc,WAAW,CAAA;AAGzB,cAAc,aAAa,CAAA;AAG3B,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AAGvB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAA;AAG1B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,UAAU,CAAA;AAGxB,cAAc,SAAS,CAAA;AAGvB,cAAc,WAAW,CAAA;AAGzB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAG5B,cAAc,mBAAmB,CAAA;AAGjC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AAGvB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/output/index.js

@@ -9,7 +9,11 @@ export * from './error';
 // === 服务管理 ===
 export * from './service';
 // === 缓存系统 ===
+export * from './ttl-cache';
 export * from './lru-cache';
+export * from './ring-cache';
+// === 数据管理 ===
+export * from './batching-buffer';
 // === 基础工具 ===
 export * from './string';
 export * from './color';

package/output/logger/logger.d.ts

@@ -1,5 +1,5 @@
-import { LogFormatter } from './formatter';
 import { LogTransport } from './transport';
+import { LogFormatter } from './formatter';
 export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 export interface LoggerOptions {
     level?: LogLevel;
@@ -12,8 +12,8 @@ export interface LoggerOptions {
 }
 export declare class Logger {
     private _level;
-    private transports;
     private formatter;
+    private transports;
     private print?;
     constructor(options?: LoggerOptions);
     private defaultPrint;
@@ -48,7 +48,7 @@ export declare class Logger {
     /**
      * 关闭所有 LogTransports
      */
-    close(): Promise<void>;
+    closeTransports(): Promise<void>;
     /**
      * Pino 兼容的 child 方法
      * 创建一个共享配置的子 logger

package/output/logger/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../source/logger/logger.ts"],"names":[],"mappings":"AACA,OAAO,EAA4C,YAAY,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,YAAY,EAAa,MAAM,aAAa,CAAA;AAErD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,oCAAoC;IACpC,UAAU,CAAC,EAAE,YAAY,EAAE,CAAA;IAC3B,aAAa;IACb,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;CAClD;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,KAAK,CAAC,CAA2C;gBAE7C,OAAO,GAAE,aAAkB;IAYvC,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2BvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,MAAM;IAIN;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAI3C;;OAEG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI5C;;OAEG;IACH,aAAa,IAAI,SAAS,YAAY,EAAE;IAIxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;OAGG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM;IAkB/E;;OAEG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED,IAAI,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAE3B;CACF;AAED,eAAO,MAAM,MAAM,QAAe,CAAA"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../source/logger/logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAa,MAAM,aAAa,CAAA;AACrD,OAAO,EAAuB,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/D,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,oCAAoC;IACpC,UAAU,CAAC,EAAE,YAAY,EAAE,CAAA;IAC3B,aAAa;IACb,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;CAClD;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,KAAK,CAAC,CAA2C;gBAE7C,OAAO,GAAE,aAAkB;IAYvC,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2BvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,MAAM;IAIN;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAI3C;;OAEG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI5C;;OAEG;IACH,aAAa,IAAI,SAAS,YAAY,EAAE;IAIxC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAQtC;;;OAGG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM;IAkB/E;;OAEG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED,IAAI,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAE3B;CACF;AAED,eAAO,MAAM,MAAM,QAAe,CAAA"}

package/output/logger/logger.js

@@ -1,9 +1,8 @@
-// 基础 Logger 实现，支持简单的日志输出和扩展能力
 import { defaultLogFormatter } from './formatter';
 export class Logger {
     _level;
-    transports;
     formatter;
+    transports;
     print;
     constructor(options = {}) {
         this._level = options.level || 'info';
@@ -143,7 +142,7 @@ export class Logger {
     /**
      * 关闭所有 LogTransports
      */
-    async close() {
+    async closeTransports() {
         const closePromises = this.transports
             .map(transport => transport.close?.())
             .filter(Boolean);

package/output/logger/logger.test.js

@@ -229,7 +229,7 @@ describe('Logger Transport 集成', () => {
             close: mockClose2
         };
         const logger = new Logger({ transports: [transport1, transport2] });
-        await logger.close();
+        await logger.closeTransports();
         expect(mockClose1).toHaveBeenCalled();
         expect(mockClose2).toHaveBeenCalled();
     });

package/output/ttl-cache/index.d.ts

@@ -0,0 +1,2 @@
+export { TtlCache, type TtlCacheOptions, type TtlCacheStats } from './ttl-cache';
+//# sourceMappingURL=index.d.ts.map

package/output/ttl-cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/ttl-cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/output/ttl-cache/index.js

@@ -0,0 +1 @@
+export { TtlCache } from './ttl-cache';

package/output/ttl-cache/ttl-cache.d.ts

@@ -0,0 +1,148 @@
+/**
+ * TTL 缓存配置选项
+ */
+export interface TtlCacheOptions {
+    /** 默认 TTL 时间（毫秒），默认为 5 分钟 */
+    defaultTtl?: number;
+    /** 清理间隔（毫秒），默认为 1 分钟 */
+    cleanupInterval?: number;
+    /** 最大缓存条目数量，默认无限制 */
+    maxSize?: number;
+    /** 是否启用自动清理，默认为 true */
+    enableCleanup?: boolean;
+}
+/**
+ * TTL 缓存统计信息
+ */
+export interface TtlCacheStats {
+    /** 当前条目数量 */
+    size: number;
+    /** 最大条目数量限制 */
+    maxSize?: number;
+    /** 命中次数 */
+    hits: number;
+    /** 未命中次数 */
+    misses: number;
+    /** 过期次数 */
+    expiredCount: number;
+    /** 命中率 */
+    hitRate: number;
+}
+/**
+ * TTL（Time To Live）缓存实现
+ * 支持过期时间、自动清理、统计信息等功能
+ *
+ * 特点：
+ * - 支持为每个条目设置独立的 TTL
+ * - 自动定期清理过期条目
+ * - 支持最大容量限制
+ * - 提供详细的统计信息
+ * - 优雅的资源清理机制
+ */
+export declare class TtlCache<T> {
+    private cache;
+    private cleanupTimer?;
+    private readonly options;
+    private stats;
+    constructor(options?: TtlCacheOptions);
+    /**
+     * 设置缓存项
+     * @param key 缓存键
+     * @param value 缓存值
+     * @param ttl 过期时间（毫秒），默认使用构造函数中的值
+     */
+    set(key: string, value: T, ttl?: number): void;
+    /**
+     * 获取缓存项
+     * @param key 缓存键
+     * @returns 缓存值或 undefined
+     */
+    get(key: string): T | undefined;
+    /**
+     * 检查缓存项是否存在且未过期
+     * @param key 缓存键
+     */
+    has(key: string): boolean;
+    /**
+     * 删除缓存项
+     * @param key 缓存键
+     * @returns 是否成功删除
+     */
+    delete(key: string): boolean;
+    /**
+     * 清空所有缓存
+     */
+    clear(): void;
+    /**
+     * 获取当前缓存大小
+     */
+    get size(): number;
+    /**
+     * 获取缓存容量
+     */
+    get capacity(): number;
+    /**
+     * 获取所有未过期的键
+     */
+    keys(): string[];
+    /**
+     * 获取所有未过期的值
+     */
+    values(): T[];
+    /**
+     * 获取所有未过期的键值对
+     */
+    entries(): Array<[string, T]>;
+    /**
+     * 获取或设置缓存（如果不存在）
+     * @param key 缓存键
+     * @param factory 工厂函数，用于生成缓存值
+     * @param ttl 过期时间（毫秒）
+     */
+    getOrSet(key: string, factory: () => Promise<T>, ttl?: number): Promise<T>;
+    getOrSet(key: string, factory: () => T, ttl?: number): T;
+    /**
+     * 获取缓存统计信息
+     */
+    getStats(): TtlCacheStats;
+    /**
+     * 重置统计信息
+     */
+    resetStats(): void;
+    /**
+     * 手动清理过期缓存
+     * @returns 清理的条目数量
+     */
+    cleanup(): number;
+    /**
+     * 获取指定键的剩余 TTL 时间
+     * @param key 缓存键
+     * @returns 剩余时间（毫秒），如果不存在或已过期返回 -1
+     */
+    getTtl(key: string): number;
+    /**
+     * 销毁缓存实例，清理所有资源
+     */
+    destroy(): void;
+    /**
+     * 启动定期清理过期缓存
+     */
+    private startCleanup;
+    /**
+     * 停止定期清理
+     */
+    private stopCleanup;
+    /**
+     * 驱逐最旧的缓存条目
+     */
+    private evictOldest;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 更新命中率
+     */
+    private updateHitRate;
+}
+//# sourceMappingURL=ttl-cache.d.ts.map

package/output/ttl-cache/ttl-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl-cache.d.ts","sourceRoot":"","sources":["../../source/ttl-cache/ttl-cache.ts"],"names":[],"mappings":"AAYA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,wBAAwB;IACxB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,qBAAqB;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,aAAa;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,WAAW;IACX,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU;IACV,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,YAAY,CAAC,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,KAAK,CAAe;gBAEhB,OAAO,GAAE,eAAoB;IAiCzC;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IA0B9C;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAuB/B;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAiBzB;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQ5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,IAAI,MAAM,EAAE;IAahB;;OAEG;IACH,MAAM,IAAI,CAAC,EAAE;IAab;;OAEG;IACH,OAAO,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAa7B;;;;;OAKG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAChF,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,CAAC;IAoBxD;;OAEG;IACH,QAAQ,IAAI,aAAa;IAKzB;;OAEG;IACH,UAAU,IAAI,IAAI;IAWlB;;;OAGG;IACH,OAAO,IAAI,MAAM;IAmBjB;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAc3B;;OAEG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,OAAO,CAAC,YAAY;IAUpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAOnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAgBnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,aAAa;CAItB"}