@taicode/common-base 1.2.0 → 1.5.0

package/output/logger/formatter.test.js

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DefaultLogFormatter } from './formatter';
+import { UserError, SystemError, UnknownError } from '../error';
+describe('DefaultLogFormatter', () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new DefaultLogFormatter();
+    });
+    describe('基本格式化功能', () => {
+        it('应该格式化字符串', () => {
+            const result = formatter.format('测试字符串');
+            expect(result).toBe('测试字符串');
+        });
+        it('应该格式化数字', () => {
+            const result = formatter.format(123);
+            expect(result).toBe("123");
+        });
+        it('应该格式化布尔值', () => {
+            const trueResult = formatter.format(true);
+            const falseResult = formatter.format(false);
+            expect(trueResult).toBe("true");
+            expect(falseResult).toBe("false");
+        });
+        it('应该格式化 null', () => {
+            const result = formatter.format(null);
+            expect(result).toBe('[null]');
+        });
+        it('应该格式化 undefined', () => {
+            const result = formatter.format(undefined);
+            expect(result).toBe('[undefined]');
+        });
+        it('应该格式化 Symbol', () => {
+            const symbol = Symbol('test');
+            const result = formatter.format(symbol);
+            expect(result).toBe(`[symbol] ${symbol.toString()}`);
+        });
+        it('应该格式化 BigInt', () => {
+            const bigint = BigInt(123);
+            const result = formatter.format(bigint);
+            expect(result).toBe('[bigint] 123n');
+        });
+    });
+    describe('日期格式化', () => {
+        it('应该格式化日期为 ISO 字符串', () => {
+            const date = new Date('2023-01-01T00:00:00.000Z');
+            const result = formatter.format(date);
+            expect(result).toBe('2023-01-01T00:00:00.000Z');
+        });
+        it('应该支持自定义日期格式化器', () => {
+            const customFormatter = new DefaultLogFormatter({
+                date: (date) => date.toLocaleDateString()
+            });
+            const date = new Date('2023-01-01T00:00:00.000Z');
+            const result = customFormatter.format(date);
+            expect(result).toBe(date.toLocaleDateString());
+        });
+    });
+    describe('对象格式化', () => {
+        it('应该格式化普通对象', () => {
+            const obj = { name: '测试', age: 25 };
+            const result = formatter.format(obj);
+            expect(result).toBe(JSON.stringify(obj, null, 2));
+        });
+        it('应该处理循环引用对象', () => {
+            const obj = { name: '测试' };
+            obj.self = obj;
+            const result = formatter.format(obj);
+            expect(typeof result).toBe('string');
+            expect(result).toBe('[object Object]');
+        });
+        it('应该支持自定义对象格式化器', () => {
+            const customFormatter = new DefaultLogFormatter({
+                object: (obj) => `Custom: ${JSON.stringify(obj)}`
+            });
+            const obj = { name: '测试' };
+            const result = customFormatter.format(obj);
+            expect(result).toBe('Custom: {"name":"测试"}');
+        });
+    });
+    describe('数组格式化', () => {
+        it('应该格式化数组', () => {
+            const arr = [1, '测试', true];
+            const result = formatter.format(arr);
+            expect(result).toBe(JSON.stringify(arr, null, 2));
+        });
+        it('应该格式化空数组', () => {
+            const arr = [];
+            const result = formatter.format(arr);
+            expect(result).toBe('[]');
+        });
+        it('应该支持自定义数组格式化器', () => {
+            const customFormatter = new DefaultLogFormatter({
+                array: (arr) => `Array[${arr.length}]: ${arr.join(', ')}`
+            });
+            const arr = [1, 2, 3];
+            const result = customFormatter.format(arr);
+            expect(result).toBe('Array[3]: 1, 2, 3');
+        });
+    });
+    describe('函数格式化', () => {
+        it('应该格式化命名函数', () => {
+            function testFunction() { }
+            const result = formatter.format(testFunction);
+            expect(result).toBe('[Function: testFunction]');
+        });
+        it('应该格式化匿名函数', () => {
+            const result = formatter.format((() => { }));
+            expect(result).toBe('[Function: anonymous]');
+        });
+        it('应该支持自定义函数格式化器', () => {
+            const customFormatter = new DefaultLogFormatter({
+                function: (fn) => `Custom Function: ${fn.name || 'unnamed'}`
+            });
+            function namedFunction() { }
+            const result = customFormatter.format(namedFunction);
+            expect(result).toBe('Custom Function: namedFunction');
+        });
+    });
+    describe('错误格式化', () => {
+        describe('UserError 格式化', () => {
+            it('应该格式化带有完整信息的 UserError', () => {
+                const error = new UserError('validation-failed', '验证失败', {
+                    field: 'email',
+                    value: 'invalid-email',
+                    rule: 'email-format'
+                });
+                const result = formatter.format(error);
+                expect(result).toContain('🚫 User Error [validation-failed]');
+                expect(result).toContain('Message: 验证失败');
+                expect(result).toContain('Context:');
+                expect(result).toContain('Stack:');
+            });
+            it('应该在禁用颜色时不包含 ANSI 代码', () => {
+                const formatterWithoutColors = new DefaultLogFormatter({}, { useColors: false });
+                const error = new UserError('test-error', '测试错误');
+                const result = formatterWithoutColors.format(error);
+                expect(result).not.toContain('\x1b[');
+                expect(result).toContain('🚫 User Error [test-error]');
+                expect(result).toContain('Message: 测试错误');
+            });
+            it('应该在禁用堆栈时不显示堆栈信息', () => {
+                const formatterWithoutStack = new DefaultLogFormatter({}, { showStack: false });
+                const error = new UserError('test-error', '测试错误');
+                const result = formatterWithoutStack.format(error);
+                expect(result).not.toContain('Stack:');
+                expect(result).toContain('Message: 测试错误');
+            });
+            it('应该在禁用上下文时不显示上下文信息', () => {
+                const formatterWithoutContext = new DefaultLogFormatter({}, { showContext: false });
+                const error = new UserError('test-error', '测试错误', { field: 'test' });
+                const result = formatterWithoutContext.format(error);
+                expect(result).not.toContain('Context:');
+                expect(result).toContain('Message: 测试错误');
+            });
+        });
+        describe('SystemError 格式化', () => {
+            it('应该格式化带有完整信息的 SystemError', () => {
+                const error = new SystemError('database-error', '数据库连接失败', {
+                    table: 'users',
+                    query: 'SELECT * FROM users',
+                    operation: 'select'
+                });
+                const result = formatter.format(error);
+                expect(result).toContain('⚠️ System Error [database-error]');
+                expect(result).toContain('Message: 数据库连接失败');
+                expect(result).toContain('Context:');
+                expect(result).toContain('Stack:');
+            });
+            it('应该在禁用颜色时不包含 ANSI 代码', () => {
+                const formatterWithoutColors = new DefaultLogFormatter({}, { useColors: false });
+                const error = new SystemError('network-error', '网络错误');
+                const result = formatterWithoutColors.format(error);
+                expect(result).not.toContain('\x1b[');
+                expect(result).toContain('⚠️ System Error [network-error]');
+            });
+        });
+        describe('UnknownError 格式化', () => {
+            it('应该格式化带有完整信息的 UnknownError', () => {
+                const error = new UnknownError('未知错误', {
+                    cause: 'something went wrong'
+                });
+                const result = formatter.format(error);
+                expect(result).toContain('❓ Unknown Error');
+                expect(result).toContain('Message: 未知错误');
+                expect(result).toContain('Context:');
+                expect(result).toContain('Stack:');
+            });
+            it('应该在禁用颜色时不包含 ANSI 代码', () => {
+                const formatterWithoutColors = new DefaultLogFormatter({}, { useColors: false });
+                const error = new UnknownError('测试未知错误');
+                const result = formatterWithoutColors.format(error);
+                expect(result).not.toContain('\x1b[');
+                expect(result).toContain('❓ Unknown Error');
+            });
+        });
+        describe('通用 Error 格式化', () => {
+            it('应该格式化普通 Error', () => {
+                const error = new Error('普通错误');
+                const result = formatter.format(error);
+                expect(result).toContain('💥 Error');
+                expect(result).toContain('Message: 普通错误');
+                expect(result).toContain('Stack:');
+            });
+            it('应该格式化带有额外属性的 Error', () => {
+                const error = new Error('测试错误');
+                error.code = 'TEST_ERROR';
+                error.statusCode = 500;
+                const result = formatter.format(error);
+                expect(result).toContain('💥 Error');
+                expect(result).toContain('Message: 测试错误');
+                expect(result).toContain('Additional:');
+                expect(result).toContain('code: TEST_ERROR');
+                expect(result).toContain('statusCode: 500');
+            });
+            it('应该格式化自定义错误类型', () => {
+                class CustomError extends Error {
+                    code;
+                    constructor(message, code) {
+                        super(message);
+                        this.code = code;
+                        this.name = 'CustomError';
+                    }
+                }
+                const error = new CustomError('自定义错误', 'CUSTOM_001');
+                const result = formatter.format(error);
+                expect(result).toContain('💥 CustomError');
+                expect(result).toContain('Message: 自定义错误');
+                expect(result).toContain('Additional:');
+                expect(result).toContain('code: CUSTOM_001');
+            });
+        });
+        describe('未知值格式化', () => {
+            it('应该格式化非错误对象', () => {
+                const unknownValue = { message: '这不是错误对象' };
+                const result = formatter.format(unknownValue);
+                expect(result).toBe(JSON.stringify(unknownValue, null, 2));
+            });
+        });
+    });
+    describe('参数数组格式化', () => {
+        it('应该格式化混合类型参数数组', () => {
+            const args = [
+                '字符串',
+                123,
+                true,
+                { name: '对象' },
+                [1, 2, 3],
+                new Date('2023-01-01T00:00:00.000Z'),
+                new Error('测试错误')
+            ];
+            const result = formatter.formatArguments(args);
+            expect(result).toHaveLength(7);
+            expect(result[0]).toBe('字符串');
+            expect(result[1]).toBe('123');
+            expect(result[2]).toBe('true');
+            expect(result[3]).toBe(JSON.stringify({ name: '对象' }, null, 2));
+            expect(result[4]).toBe(JSON.stringify([1, 2, 3], null, 2));
+            expect(result[5]).toBe('2023-01-01T00:00:00.000Z');
+            expect(result[6]).toContain('💥 Error');
+        });
+        it('应该格式化空参数数组', () => {
+            const result = formatter.formatArguments([]);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('自定义格式化器配置', () => {
+        it('应该支持完全自定义的格式化器', () => {
+            const customFormatter = new DefaultLogFormatter({
+                date: (date) => `日期: ${date.getFullYear()}`,
+                object: (obj) => `对象: ${Object.keys(obj).join(', ')}`,
+                array: (arr) => `数组长度: ${arr.length}`,
+                function: (fn) => `函数名: ${fn.name}`,
+                other: (value) => `其他类型: ${typeof value}`
+            });
+            const date = new Date('2023-01-01');
+            const obj = { a: 1, b: 2 };
+            const arr = [1, 2, 3];
+            const fn = function testFn() { };
+            const symbol = Symbol('test');
+            expect(customFormatter.format(date)).toBe('日期: 2023');
+            expect(customFormatter.format(obj)).toBe('对象: a, b');
+            expect(customFormatter.format(arr)).toBe('数组长度: 3');
+            expect(customFormatter.format(fn)).toBe('函数名: testFn');
+            expect(customFormatter.format(symbol)).toBe('其他类型: symbol');
+        });
+    });
+    describe('错误选项配置', () => {
+        it('应该支持完全禁用错误格式化选项', () => {
+            const minimalistFormatter = new DefaultLogFormatter({}, {
+                showStack: false,
+                showContext: false,
+                useColors: false
+            });
+            const error = new UserError('test-error', '测试错误', { field: 'test' });
+            const result = minimalistFormatter.format(error);
+            expect(result).not.toContain('Stack:');
+            expect(result).not.toContain('Context:');
+            expect(result).not.toContain('\x1b[');
+            expect(result).toContain('🚫 User Error [test-error]');
+            expect(result).toContain('Message: 测试错误');
+        });
+        it('应该支持只显示特定错误信息', () => {
+            const stackOnlyFormatter = new DefaultLogFormatter({}, {
+                showStack: true,
+                showContext: false,
+                useColors: false
+            });
+            const error = new SystemError('database-error', '数据库错误', { table: 'users' });
+            const result = stackOnlyFormatter.format(error);
+            expect(result).toContain('Stack:');
+            expect(result).not.toContain('Context:');
+            expect(result).not.toContain('\x1b[');
+        });
+    });
+});

package/output/logger/index.d.ts

@@ -1,18 +1,4 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface LoggerOptions {
-    level?: LogLevel;
-    handler?: (level: LogLevel, ...args: any[]) => void;
-}
-export declare class Logger {
-    private level;
-    private handler;
-    constructor(options?: LoggerOptions);
-    private defaultHandler;
-    private shouldLog;
-    debug(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-}
-export declare const logger: Logger;
+export * from './logger';
+export * from './formatter';
+export * from './transport';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/logger/index.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACrD;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,OAAO,CAA4C;gBAE/C,OAAO,GAAE,aAAkB;IAKvC,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,SAAS;IAKjB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAGpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAGnB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAGnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAGrB;AAED,eAAO,MAAM,MAAM,QAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/logger/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA"}

package/output/logger/index.js

@@ -1,34 +1,3 @@
-export class Logger {
-    level;
-    handler;
-    constructor(options = {}) {
-        this.level = options.level || 'info';
-        this.handler = options.handler || this.defaultHandler;
-    }
-    defaultHandler(level, ...args) {
-        const prefix = `[${level.toUpperCase()}]`;
-        // eslint-disable-next-line no-console
-        (console[level] || console.log)(prefix, ...args);
-    }
-    shouldLog(level) {
-        const order = ['debug', 'info', 'warn', 'error'];
-        return order.indexOf(level) >= order.indexOf(this.level);
-    }
-    debug(...args) {
-        if (this.shouldLog('debug'))
-            this.handler('debug', ...args);
-    }
-    info(...args) {
-        if (this.shouldLog('info'))
-            this.handler('info', ...args);
-    }
-    warn(...args) {
-        if (this.shouldLog('warn'))
-            this.handler('warn', ...args);
-    }
-    error(...args) {
-        if (this.shouldLog('error'))
-            this.handler('error', ...args);
-    }
-}
-export const logger = new Logger();
+export * from './logger';
+export * from './formatter';
+export * from './transport';

package/output/logger/logger.d.ts

@@ -0,0 +1,51 @@
+import { LogFormatter } from './formatter';
+import { LogTransport } from './transport';
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LoggerOptions {
+    level?: LogLevel;
+    /** LogTransport 实例数组，用于处理结构化日志数据 */
+    transports?: LogTransport[];
+    /** 格式化器实例 */
+    formatter?: LogFormatter;
+    /** 传统的 print 函数，用于向后兼容 */
+    print?: (level: LogLevel, ...args: any[]) => void;
+}
+export declare class Logger {
+    private level;
+    private transports;
+    private formatter;
+    private print?;
+    constructor(options?: LoggerOptions);
+    private defaultPrint;
+    private shouldLog;
+    /**
+     * 记录日志到所有 transports
+     */
+    private logToTransports;
+    /**
+     * 使用传统 print 方式记录日志（向后兼容）
+     */
+    private logToPrint;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    /**
+     * 添加 LogTransport
+     */
+    addTransport(transport: LogTransport): void;
+    /**
+     * 移除 LogTransport
+     */
+    removeTransport(transportName: string): void;
+    /**
+     * 获取所有 LogTransports
+     */
+    getTransports(): readonly LogTransport[];
+    /**
+     * 关闭所有 LogTransports
+     */
+    close(): Promise<void>;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

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

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

package/output/logger/logger.js

@@ -0,0 +1,118 @@
+// 基础 Logger 实现，支持简单的日志输出和扩展能力
+import { defaultLogFormatter } from './formatter';
+export class Logger {
+    level;
+    transports;
+    formatter;
+    print;
+    constructor(options = {}) {
+        this.level = options.level || 'info';
+        this.formatter = options.formatter || defaultLogFormatter;
+        this.transports = options.transports || [];
+        this.print = options.print;
+        // 如果没有 transports 且没有 print，使用默认的控制台输出
+        if (this.transports.length === 0 && !this.print) {
+            this.print = this.defaultPrint;
+        }
+    }
+    defaultPrint(level, ...args) {
+        const prefix = `[${level.toUpperCase()}]`;
+        // eslint-disable-next-line no-console
+        (console[level] || console.log)(prefix, ...args);
+    }
+    shouldLog(level) {
+        const order = ['debug', 'info', 'warn', 'error'];
+        return order.indexOf(level) >= order.indexOf(this.level);
+    }
+    /**
+     * 记录日志到所有 transports
+     */
+    logToTransports(level, args) {
+        if (this.transports.length === 0) {
+            return;
+        }
+        const record = {
+            level,
+            timestamp: new Date(),
+            args: [...args] // 创建副本避免引用问题
+        };
+        // 并行发送到所有 transports
+        this.transports.forEach(transport => {
+            try {
+                const result = transport.log(record);
+                // 如果返回 Promise，静默处理错误
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => {
+                        // 静默处理 transport 错误，避免影响主程序
+                    });
+                }
+            }
+            catch {
+                // 静默处理 transport 错误，避免影响主程序
+            }
+        });
+    }
+    /**
+     * 使用传统 print 方式记录日志（向后兼容）
+     */
+    logToPrint(level, args) {
+        if (!this.print) {
+            return;
+        }
+        // 为了向后兼容，保持原始行为：传递格式化后的参数
+        const formattedArgs = this.formatter.formatArguments(args);
+        this.print(level, ...formattedArgs);
+    }
+    debug(...args) {
+        if (this.shouldLog('debug')) {
+            this.logToTransports('debug', args);
+            this.logToPrint('debug', args);
+        }
+    }
+    info(...args) {
+        if (this.shouldLog('info')) {
+            this.logToTransports('info', args);
+            this.logToPrint('info', args);
+        }
+    }
+    warn(...args) {
+        if (this.shouldLog('warn')) {
+            this.logToTransports('warn', args);
+            this.logToPrint('warn', args);
+        }
+    }
+    error(...args) {
+        if (this.shouldLog('error')) {
+            this.logToTransports('error', args);
+            this.logToPrint('error', args);
+        }
+    }
+    /**
+     * 添加 LogTransport
+     */
+    addTransport(transport) {
+        this.transports.push(transport);
+    }
+    /**
+     * 移除 LogTransport
+     */
+    removeTransport(transportName) {
+        this.transports = this.transports.filter(t => t.name !== transportName);
+    }
+    /**
+     * 获取所有 LogTransports
+     */
+    getTransports() {
+        return [...this.transports];
+    }
+    /**
+     * 关闭所有 LogTransports
+     */
+    async close() {
+        const closePromises = this.transports
+            .map(transport => transport.close?.())
+            .filter(Boolean);
+        await Promise.all(closePromises);
+    }
+}
+export const logger = new Logger();

package/output/logger/logger.test.d.ts

@@ -1,2 +1,21 @@
+declare module '../error' {
+    interface UserErrorTypes {
+        'validation-failed': {
+            field?: string;
+            value?: unknown;
+            rule?: string;
+        };
+        'test-error': {
+            field?: string;
+        };
+    }
+    interface SystemErrorTypes {
+        'database-error': {
+            query?: string;
+            table?: string;
+            operation?: string;
+        };
+    }
+}
 export {};
 //# sourceMappingURL=logger.test.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../source/logger/logger.test.ts"],"names":[],"mappings":""}
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../source/logger/logger.test.ts"],"names":[],"mappings":"AAOA,OAAO,QAAQ,UAAU,CAAC;IACxB,UAAU,cAAc;QACtB,mBAAmB,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,OAAO,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;QACvE,YAAY,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACjC;IAED,UAAU,gBAAgB;QACxB,gBAAgB,EAAE;YAAE,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACzE;CACF"}