@taicode/common-base 1.6.3 → 1.7.1

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

@@ -0,0 +1,511 @@
+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.add('item1', 'item2', 'item3', 'item4', 'item5');
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
+            // 剩余的项目应该在缓冲区中
+            expect(buffer.size).toBe(2);
+        });
+        it('应该支持添加空参数', () => {
+            buffer.add();
+            expect(batchProcessor).not.toHaveBeenCalled();
+            expect(buffer.size).toBe(0);
+        });
+        it('应该支持混合添加单个和多个数据', () => {
+            buffer.add('item1'); // 单个
+            buffer.add('item2', 'item3'); // 多个
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2', 'item3']);
+            expect(buffer.size).toBe(0);
+        });
+        it('应该支持使用数组展开语法', () => {
+            const items = ['item1', 'item2', 'item3', 'item4', 'item5'];
+            buffer.add(...items);
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
+            // 剩余的项目应该在缓冲区中
+            expect(buffer.size).toBe(2);
+        });
+        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).toBe(500);
+            await buffer.flush();
+            expect(buffer.timeSinceLastFlush).toBe(0);
+        });
+    });
+    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.add('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();
+        });
+        it('应该正确处理定时器重置', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 1000,
+                autoFlush: true
+            });
+            // 添加第一个项目，启动定时器
+            buffer.add('item1');
+            vi.advanceTimersByTime(500);
+            // 添加第二个项目，应该重置定时器
+            buffer.add('item2');
+            vi.advanceTimersByTime(500);
+            // 此时应该还没触发（总共过了1000ms，但最后一次重置后只过了500ms）
+            expect(batchProcessor).not.toHaveBeenCalled();
+            // 再等500ms，现在应该触发了
+            vi.advanceTimersByTime(500);
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            await buffer.destroy();
+        });
+        it('应该在销毁时清除定时器避免内存泄漏', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 1000,
+                autoFlush: true
+            });
+            buffer.add('item1');
+            // 立即销毁，应该处理剩余数据但不会因为定时器再次触发
+            await buffer.destroy();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            // 等待原本的定时器时间，不应该再次触发
+            vi.advanceTimersByTime(1000);
+            await vi.runAllTimersAsync();
+            // 仍然只被调用一次
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+        });
+    });
+    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) => {
+                // 使用 fake timer 而不是真实的 setTimeout
+                return `处理了 ${items.length} 个项目`;
+            });
+            asyncItemProcessor = vi.fn().mockImplementation(async (item) => {
+                // 使用 fake timer 而不是真实的 setTimeout
+                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();
+        });
+    });
+    describe('错误处理回调', () => {
+        it('应该支持配置错误处理回调', () => {
+            const onError = vi.fn();
+            const buffer = new BatchingBuffer({
+                batchProcessor: vi.fn(),
+                bufferSize: 10,
+                flushInterval: 1000,
+                onError
+            });
+            expect(buffer).toBeDefined();
+            buffer.destroy();
+        });
+        it('错误处理回调应该可以正确配置', () => {
+            const onError = vi.fn();
+            const buffer = new BatchingBuffer({
+                batchProcessor: vi.fn(),
+                bufferSize: 10,
+                flushInterval: 1000,
+                onError
+            });
+            // 验证缓冲区正常工作
+            buffer.add('item1');
+            expect(buffer.size).toBe(1);
+            buffer.destroy();
+        });
+    });
+    describe('边界条件测试', () => {
+        it('应该正确处理极小的 bufferSize', () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 1,
+                flushInterval: 1000
+            });
+            buffer.add('item1');
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1']);
+            buffer.destroy();
+        });
+        it('应该正确处理极小的 flushInterval', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 5,
+                flushInterval: 1 // 1ms
+            });
+            buffer.add('item1');
+            vi.advanceTimersByTime(1);
+            await vi.runAllTimersAsync();
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1']);
+            await buffer.destroy();
+        });
+        it('应该正确处理同时达到大小和时间限制', async () => {
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessor,
+                bufferSize: 2,
+                flushInterval: 100
+            });
+            buffer.add('item1');
+            // 在时间限制之前添加第二个项目，应该立即触发
+            buffer.add('item2');
+            expect(batchProcessor).toHaveBeenCalledTimes(1);
+            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
+            await buffer.destroy();
+        });
+        it('应该正确处理在处理过程中继续添加数据', () => {
+            const processedBatches = [];
+            let processingCount = 0;
+            const batchProcessorWithCallback = vi.fn().mockImplementation((items) => {
+                processingCount++;
+                processedBatches.push([...items]);
+                // 在第一次处理过程中添加新数据
+                if (processingCount === 1) {
+                    buffer.add('item4');
+                }
+            });
+            const buffer = new BatchingBuffer({
+                batchProcessor: batchProcessorWithCallback,
+                bufferSize: 2,
+                flushInterval: 1000
+            });
+            buffer.add('item1', 'item2', 'item3');
+            // 验证处理次数
+            expect(batchProcessorWithCallback).toHaveBeenCalledTimes(2);
+            // 验证第一次处理了前两个项目
+            expect(processedBatches[0]).toEqual(['item1', 'item2']);
+            // 第二次处理的顺序可能是 ['item4', 'item3'] 或 ['item3', 'item4']
+            // 这取决于具体实现，我们验证包含了正确的项目
+            expect(processedBatches[1]).toHaveLength(2);
+            expect(processedBatches[1]).toContain('item3');
+            expect(processedBatches[1]).toContain('item4');
+            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

@@ -4,6 +4,8 @@ export * from './logger';
 export * from './error';
 export * from './service';
 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,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

@@ -10,6 +10,9 @@ export * from './error';
 export * from './service';
 // === 缓存系统 ===
 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,6 +1,6 @@
 import { LogFormatter } from './formatter';
 import { LogTransport } from './transport';
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 export interface LoggerOptions {
     level?: LogLevel;
     /** LogTransport 实例数组，用于处理结构化日志数据 */
@@ -11,7 +11,7 @@ export interface LoggerOptions {
     print?: (level: LogLevel, ...args: any[]) => void;
 }
 export declare class Logger {
-    private level;
+    private _level;
     private transports;
     private formatter;
     private print?;
@@ -26,10 +26,13 @@ export declare class Logger {
      * 使用传统 print 方式记录日志（向后兼容）
      */
     private logToPrint;
+    trace(...args: any[]): void;
     debug(...args: any[]): void;
     info(...args: any[]): void;
     warn(...args: any[]): void;
     error(...args: any[]): void;
+    fatal(...args: any[]): void;
+    silent(): void;
     /**
      * 添加 LogTransport
      */
@@ -46,6 +49,16 @@ export declare class Logger {
      * 关闭所有 LogTransports
      */
     close(): Promise<void>;
+    /**
+     * Pino 兼容的 child 方法
+     * 创建一个共享配置的子 logger
+     */
+    child(bindings?: Record<string, any>, options?: Partial<LoggerOptions>): Logger;
+    /**
+     * Pino 兼容的 level getter/setter
+     */
+    get level(): LogLevel;
+    set level(newLevel: LogLevel);
 }
 export declare const logger: Logger;
 //# sourceMappingURL=logger.d.ts.map

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,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAE1D,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,KAAK,CAAU;IACvB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,KAAK,CAAC,CAA2C;gBAE7C,OAAO,GAAE,aAAkB;IAYvC,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2BvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB,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;;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;CAO7B;AAED,eAAO,MAAM,MAAM,QAAe,CAAA"}
+{"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"}