@taicode/common-base 1.7.3 → 1.7.5

package/output/flow-queue/flow-queue.js

@@ -75,6 +75,8 @@
  * - **流量控制**：可配置任务间延迟，避免资源竞争
  * - **状态追踪**：清晰的成功/失败状态管理
  * - **背压处理**：避免内存溢出的队列管理
+ * - **并发控制**：支持配置并发处理数量，默认为 1
+ * - **链式调用**：支持流畅的链式 API 调用
  */
 import { catchIt } from '../catch';
 function delay(arg0) {
@@ -94,7 +96,8 @@ function delay(arg0) {
  * const queue = new FlowQueue<InputType, OutputType>(
  *   {
  *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
- *     delay: { base: 100, jitter: true }
+ *     delay: { base: 100, jitter: true },
+ *     concurrency: 3 // 支持 3 个并发处理
  *   },
  *   async (input) => {
  *     // 处理逻辑
@@ -102,13 +105,25 @@ function delay(arg0) {
  *   }
  * );
  *
- * // 添加输入并监听输出
+ * // 传统方式
  * queue.input(data1, data2, data3);
  * queue.onGenerate(result => console.log('处理完成:', result));
- *
- * // 等待所有处理完成
  * queue.closeInput();
  * await queue.awaitCompletion();
+ *
+ * // 链式调用方式
+ * await queue
+ *   .input(data1, data2)
+ *   .input(data3)
+ *   .closeInput()
+ *   .awaitCompletion();
+ *
+ * // 重置并重新开始
+ * await queue
+ *   .reset()
+ *   .input(newData1, newData2)
+ *   .closeInput()
+ *   .awaitCompletion();
  * ```
  */
 export class FlowQueue {
@@ -118,7 +133,7 @@ export class FlowQueue {
     processedInputs = []; // 已处理
     successOutputs = new Map();
     erroredOutputs = new Map();
-    isProcessing = false; // 防止并发处理
+    processingCount = 0; // 当前正在处理的任务数量
     retryCount = new Map(); // 记录每个输入的重试次数
     onGenerates = new Map();
     isInputClosed = false; // 标记输入是否已关闭
@@ -134,14 +149,16 @@ export class FlowQueue {
      * - 可以在处理过程中通过 this.input() 动态添加新任务
      * - 支持异步处理，避免阻塞主线程
      * - 失败时会根据重试策略自动重试
+     * - 支持并发处理，默认并发数为 1
      *
      * @example
      * ```typescript
-     * // 处理嵌套文件结构的示例
+     * // 处理嵌套文件结构的示例（单线程）
      * const fileQueue = new FlowQueue<FileNode, ProcessedFile>(
      *   {
      *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 },
-     *     delay: { base: 100, jitter: true }
+     *     delay: { base: 100, jitter: true },
+     *     concurrency: 1 // 默认值，可省略
      *   },
      *   async (node) => {
      *     try {
@@ -158,6 +175,17 @@ export class FlowQueue {
      *     }
      *   }
      * );
+     *
+     * // 并发处理示例
+     * const concurrentQueue = new FlowQueue<Task, Result>(
+     *   {
+     *     concurrency: 5, // 同时处理 5 个任务
+     *     retry: { strategy: 'exponential', baseDelay: 1000, maxRetries: 3 }
+     *   },
+     *   async (task) => {
+     *     return await processTask(task);
+     *   }
+     * );
      * ```
      */
     constructor(options, processor) {
@@ -172,6 +200,8 @@ export class FlowQueue {
         this.options.delay.base = this.options.delay.base ?? 0;
         this.options.delay.jitter = this.options.delay.jitter ?? false;
         this.options.delay.jitterRange = this.options.delay.jitterRange ?? 0.1;
+        // 设置并发配置默认值
+        this.options.concurrency = this.options.concurrency ?? 1;
     }
     /**
      * 计算重试延迟时间
@@ -242,7 +272,9 @@ export class FlowQueue {
      * 调度下一个处理任务
      */
     scheduleNextProcessing() {
-        if (this.pendingInputs.length > 0) {
+        // 启动尽可能多的处理任务，直到达到并发限制
+        const tasksToStart = Math.min(this.pendingInputs.length, this.options.concurrency - this.processingCount);
+        for (let i = 0; i < tasksToStart; i++) {
             // 计算任务间延迟
             const taskDelay = this.calculateTaskDelay();
             if (taskDelay > 0) {
@@ -254,10 +286,8 @@ export class FlowQueue {
                 setTimeout(() => this.processFlow(), 0);
             }
         }
-        else {
-            // 没有更多待处理的输入，检查是否已标记为完成
-            this.checkAndTriggerCompletion();
-        }
+        // 检查是否已标记为完成
+        this.checkAndTriggerCompletion();
     }
     /**
      * 延迟执行重试
@@ -265,12 +295,14 @@ export class FlowQueue {
     scheduleRetry(input, delayTime) {
         this.pendingInputs.unshift(input);
         if (delayTime <= 0) {
-            // 立即重试
-            setTimeout(() => this.processFlow(), 0);
+            // 立即重试，启动调度
+            this.scheduleNextProcessing();
         }
         else {
             // 延迟重试
-            setTimeout(() => this.processFlow(), delayTime);
+            setTimeout(() => {
+                this.scheduleNextProcessing();
+            }, delayTime);
         }
     }
     /**
@@ -278,7 +310,7 @@ export class FlowQueue {
      */
     async checkAndTriggerCompletion() {
         await delay(0); // 确保在当前执行栈完成后再检查
-        if (this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing && this.completionResolve) {
+        if (this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0 && this.completionResolve) {
             this.completionResolve();
             this.completionResolve = null;
         }
@@ -290,19 +322,19 @@ export class FlowQueue {
      * 可以设置失败的重试次数，如果超过最大重试次数则不再重试
      */
     async processFlow() {
-        // 如果正在处理或没有待处理的输入，直接返回
-        if (this.isProcessing || this.pendingInputs.length === 0) {
-            // 检查是否已标记为完成且没有待处理的输入
+        // 检查并发限制
+        if (this.processingCount >= this.options.concurrency) {
+            return;
+        }
+        // 取出第一个待处理的输入
+        const input = this.pendingInputs.shift();
+        if (!input) {
             this.checkAndTriggerCompletion();
             return;
         }
-        this.isProcessing = true;
-        const processResult = await catchIt(async () => {
-            // 取出第一个待处理的输入
-            const input = this.pendingInputs.shift();
-            if (!input) {
-                return;
-            }
+        // 增加处理计数
+        this.processingCount++;
+        try {
             // 获取当前输入的重试次数
             const currentRetries = this.retryCount.get(input) || 0;
             // 使用 processor 处理输入
@@ -319,8 +351,6 @@ export class FlowQueue {
                     this.erroredOutputs.set(input, result.error);
                     this.processedInputs.push(input);
                     this.retryCount.delete(input);
-                    // 处理完当前输入后，继续处理下一个（如果有的话）
-                    this.scheduleNextProcessing();
                 }
             }
             else {
@@ -332,17 +362,17 @@ export class FlowQueue {
                 this.erroredOutputs.delete(input);
                 // 通知所有注册的回调
                 await this.notifyOnGenerates(result.value);
-                // 处理完当前输入后，继续处理下一个（如果有的话）
-                this.scheduleNextProcessing();
             }
-        });
-        // 处理 processFlow 中的错误
-        if (processResult.isError()) {
-            console.error('Error in processFlow:', processResult.error);
         }
-        // 确保在任何情况下都重置 isProcessing 状态
-        this.isProcessing = false;
-        this.checkAndTriggerCompletion();
+        catch (error) {
+            console.error('Error in processFlow:', error);
+        }
+        finally {
+            // 减少正在处理的任务计数
+            this.processingCount--;
+            // 处理完当前输入后，尝试启动更多处理任务
+            this.scheduleNextProcessing();
+        }
     }
     /**
      * 通知所有注册的回调函数
@@ -362,8 +392,10 @@ export class FlowQueue {
      * - 在 processor 函数内部可以动态添加新的输入
      * - 避免了深度递归调用栈
      * - 支持批量添加多个输入
+     * - 支持链式调用
      *
      * @param inputs 要处理的输入数据
+     * @returns 返回 FlowQueue 实例以支持链式调用
      *
      * @example
      * ```typescript
@@ -378,13 +410,20 @@ export class FlowQueue {
      *
      *   return result;
      * };
+     *
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .input(data3)
+     *   .closeInput();
      * ```
      */
     input(...inputs) {
         if (this.isInputClosed)
-            return;
+            return this;
         this.pendingInputs.push(...inputs);
         this.processFlow();
+        return this;
     }
     /**
      * 注册输出监听器
@@ -418,7 +457,7 @@ export class FlowQueue {
      * 只读标记，代表是否当前已经 closeInput 并且所有输入都已经处理完毕
      */
     get isCompleted() {
-        return this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing;
+        return this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0;
     }
     /**
      * 标记当前 FlowQueue 不会再有新的输入了
@@ -427,9 +466,12 @@ export class FlowQueue {
      * - 队列将不再接受新的输入
      * - 当所有现有输入处理完成后，队列将进入完成状态
      * - 可以通过 awaitCompletion() 等待所有处理完成
+     * - 支持链式调用
      *
      * 在深度循环解耦场景中，这是控制处理边界的重要方法。
      *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
      * @example
      * ```typescript
      * // 添加所有初始数据
@@ -441,12 +483,19 @@ export class FlowQueue {
      * // 等待所有处理完成
      * await queue.awaitCompletion();
      * console.log('所有数据处理完成');
+     *
+     * // 链式调用示例
+     * await queue
+     *   .input(data1, data2)
+     *   .closeInput()
+     *   .awaitCompletion();
      * ```
      */
     closeInput() {
         this.isInputClosed = true;
         // 使用统一的完成检查方法
         this.checkAndTriggerCompletion();
+        return this;
     }
     /**
      * 返回一个 Promise，代表当前已经标记为输入关闭状态、所有输入都已经处理完毕
@@ -476,8 +525,8 @@ export class FlowQueue {
         if (this.completionPromise) {
             return this.completionPromise;
         }
-        // 如果已经标记为输入关闭且没有待处理的输入，立即返回 resolved Promise
-        if (this.isInputClosed && this.pendingInputs.length === 0 && !this.isProcessing) {
+        // 如果已经标记为输入关闭且没有待处理的输入和正在处理的任务，立即返回 resolved Promise
+        if (this.isInputClosed && this.pendingInputs.length === 0 && this.processingCount === 0) {
             console.log('所有输入已处理完毕');
             return Promise.resolve();
         }
@@ -492,6 +541,17 @@ export class FlowQueue {
     }
     /**
      * 移除尚未处理的输入并调用 closeInput
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .input(data1, data2)
+     *   .cancel()
+     *   .reset();
+     * ```
      */
     cancel() {
         // 清除所有待处理的输入
@@ -500,11 +560,23 @@ export class FlowQueue {
         this.retryCount.clear();
         // 标记输入已关闭
         this.closeInput();
+        return this;
     }
     /**
      * 重置 FlowQueue 到初始状态
      * 清空所有数据，包括待处理、已处理、输出、重试计数等
      * 重置后可以重新开始处理
+     *
+     * @returns 返回 FlowQueue 实例以支持链式调用
+     *
+     * @example
+     * ```typescript
+     * // 链式调用示例
+     * queue
+     *   .reset()
+     *   .input(newData1, newData2)
+     *   .closeInput();
+     * ```
      */
     reset() {
         // 清空所有队列和状态
@@ -514,7 +586,7 @@ export class FlowQueue {
         this.pendingInputs.length = 0;
         this.processedInputs.length = 0;
         // 重置处理状态
-        this.isProcessing = false;
+        this.processingCount = 0;
         this.isInputClosed = false;
         // 重置完成状态
         if (this.completionResolve) {
@@ -522,6 +594,7 @@ export class FlowQueue {
             this.completionResolve = null;
         }
         this.completionPromise = null;
+        return this;
     }
     /**
      * 重试所有失败的输入

package/output/flow-queue/flow-queue.test.js

@@ -183,24 +183,98 @@ describe('FlowQueue', () => {
         });
     });
     describe('并发处理', () => {
-        it('应该防止并发处理', async () => {
+        it('应该支持配置的并发数量', async () => {
             const inputs = [
                 { id: 1, data: 'test1' },
-                { id: 2, data: 'test2' }
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' },
+                { id: 4, data: 'test4' }
             ];
-            // 模拟较慢的处理器
+            let processingCount = 0;
+            let maxConcurrentProcessing = 0;
+            // 模拟较慢的处理器，用来测试并发
             mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processingCount++;
+                maxConcurrentProcessing = Math.max(maxConcurrentProcessing, processingCount);
+                await new Promise(resolve => setTimeout(resolve, 50));
+                processingCount--;
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            // 创建支持 3 个并发的队列
+            flowQueue = new FlowQueue({
+                retry: { maxRetries: 3 },
+                concurrency: 3
+            }, mockProcessor);
+            // 添加所有输入
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证结果
+            expect(mockProcessor).toHaveBeenCalledTimes(4);
+            expect(flowQueue.successOutputs.size).toBe(4);
+            expect(maxConcurrentProcessing).toBe(3); // 应该达到配置的并发数
+        });
+        it('默认应该使用并发数 1（顺序处理）', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            let processingCount = 0;
+            let maxConcurrentProcessing = 0;
+            const processingOrder = [];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processingCount++;
+                maxConcurrentProcessing = Math.max(maxConcurrentProcessing, processingCount);
+                processingOrder.push(input.id);
                 await new Promise(resolve => setTimeout(resolve, 30));
+                processingCount--;
                 return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
             });
+            // 使用默认配置（并发数应该为 1）
             flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
-            // 快速添加两个输入
-            flowQueue.input(inputs[0]);
-            flowQueue.input(inputs[1]);
-            await new Promise(resolve => setTimeout(resolve, 100));
-            // 应该按顺序处理
-            expect(mockProcessor).toHaveBeenCalledTimes(2);
-            expect(flowQueue['processedInputs'].length).toBe(2);
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证顺序处理
+            expect(maxConcurrentProcessing).toBe(1);
+            expect(processingOrder).toEqual([1, 2, 3]); // 应该按顺序处理
+        });
+        it('应该在达到并发限制时等待', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' },
+                { id: 4, data: 'test4' },
+                { id: 5, data: 'test5' }
+            ];
+            let activeProcessing = 0;
+            let maxActiveProcessing = 0;
+            const processStartTimes = [];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                processStartTimes.push(Date.now());
+                activeProcessing++;
+                maxActiveProcessing = Math.max(maxActiveProcessing, activeProcessing);
+                await new Promise(resolve => setTimeout(resolve, 80));
+                activeProcessing--;
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            // 创建并发数为 2 的队列
+            flowQueue = new FlowQueue({
+                retry: { maxRetries: 3 },
+                concurrency: 2
+            }, mockProcessor);
+            const startTime = Date.now();
+            flowQueue.input(...inputs);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            // 验证并发限制生效
+            expect(maxActiveProcessing).toBe(2);
+            expect(flowQueue.successOutputs.size).toBe(5);
+            // 验证第3个任务等待了前面任务完成
+            // 由于并发数为2，第3个任务应该在第一批任务完成后才开始
+            const totalTime = Date.now() - startTime;
+            expect(totalTime).toBeGreaterThan(150); // 至少需要两轮处理
         });
     });
     describe('边界情况', () => {
@@ -676,7 +750,7 @@ describe('FlowQueue', () => {
                 expect(flowQueue['processedInputs'].length).toBe(0);
                 expect(flowQueue.successOutputs.size).toBe(0);
                 expect(flowQueue['retryCount'].size).toBe(0);
-                expect(flowQueue['isProcessing']).toBe(false);
+                expect(flowQueue['processingCount']).toBe(0);
                 expect(flowQueue['isInputClosed']).toBe(false);
                 expect(flowQueue['completionPromise']).toBe(null);
                 expect(flowQueue['completionResolve']).toBe(null);
@@ -1030,4 +1104,101 @@ describe('FlowQueue', () => {
             });
         });
     });
+    describe('链式调用', () => {
+        it('应该支持 input 方法的链式调用', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试链式调用并验证返回值
+            const returnValue = flowQueue
+                .input(inputs[0])
+                .input(inputs[1], inputs[2]);
+            expect(returnValue).toBe(flowQueue); // 验证返回的是同一个实例
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(3);
+        });
+        it('应该支持 closeInput 方法的链式调用', async () => {
+            const testInput = { id: 1, data: 'test' };
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试链式调用
+            const returnValue = flowQueue
+                .input(testInput)
+                .closeInput();
+            expect(returnValue).toBe(flowQueue);
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+        });
+        it('应该支持 reset 方法的链式调用', async () => {
+            const firstInput = { id: 1, data: 'first' };
+            const secondInput = { id: 2, data: 'second' };
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 第一轮处理
+            flowQueue.input(firstInput);
+            flowQueue.closeInput();
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+            // 测试链式调用重置并开始新处理
+            const returnValue = flowQueue
+                .reset()
+                .input(secondInput)
+                .closeInput();
+            expect(returnValue).toBe(flowQueue);
+            await flowQueue.awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+            expect(flowQueue.successOutputs.get(secondInput)?.result).toBe('processed_second');
+        });
+        it('应该支持 cancel 方法的链式调用', async () => {
+            const testInputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' }
+            ];
+            flowQueue.input(...testInputs);
+            // 测试链式调用
+            const returnValue = flowQueue.cancel();
+            expect(returnValue).toBe(flowQueue);
+            expect(flowQueue['pendingInputs'].length).toBe(0);
+            // 等待异步完成状态更新
+            await new Promise(resolve => setTimeout(resolve, 10));
+            expect(flowQueue.isCompleted).toBe(true);
+        });
+        it('应该支持完整的链式调用流程', async () => {
+            const inputs = [
+                { id: 1, data: 'test1' },
+                { id: 2, data: 'test2' },
+                { id: 3, data: 'test3' }
+            ];
+            mockProcessor = vi.fn().mockImplementation(async (input) => {
+                return { id: input.id, result: `processed_${input.data}`, timestamp: Date.now() };
+            });
+            flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
+            // 测试完整的链式调用流程
+            await flowQueue
+                .input(inputs[0], inputs[1])
+                .input(inputs[2])
+                .closeInput()
+                .awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(3);
+            expect(mockProcessor).toHaveBeenCalledTimes(3);
+            // 测试重置后的链式调用
+            await flowQueue
+                .reset()
+                .input(inputs[0])
+                .closeInput()
+                .awaitCompletion();
+            expect(flowQueue.successOutputs.size).toBe(1);
+        });
+    });
 });

package/output/logger/formatter.d.ts

@@ -52,7 +52,6 @@ export declare class DefaultLogFormatter implements LogFormatter {
     private formatError;
     private formatUserError;
     private formatSystemError;
-    private formatUnknownError;
     private formatGenericError;
     private formatUnknownValue;
     private formatContext;

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

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../source/logger/formatter.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC9B,eAAe;IACf,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAA;IAClC,aAAa;IACb,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAA;IAC7B,aAAa;IACb,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAA;IAC7B,aAAa;IACb,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,MAAM,CAAA;IAC9B,aAAa;IACb,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,MAAM,CAAA;IACnC,eAAe;IACf,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,cAAc;IACd,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAA;IACxB,cAAc;IACd,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,EAAE,CAAA;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gBAAgB;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,sBAAsB;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAA0C;gBAE5C,MAAM,GAAE,eAAoB,EAAE,YAAY,GAAE,qBAA0B;IAgBlF;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM;IAwBxB;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,EAAE;IAItC;;OAEG;IACH,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,kBAAkB;IAiB1B,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,WAAW;CAWpB;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,qBAA4B,CAAA"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../source/logger/formatter.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC9B,eAAe;IACf,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAA;IAClC,aAAa;IACb,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAA;IAC7B,aAAa;IACb,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAA;IAC7B,aAAa;IACb,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,MAAM,CAAA;IAC9B,aAAa;IACb,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,KAAK,MAAM,CAAA;IACnC,eAAe;IACf,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,cAAc;IACd,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAAA;IACxB,cAAc;IACd,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,EAAE,CAAA;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gBAAgB;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,sBAAsB;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAA0C;gBAE5C,MAAM,GAAE,eAAoB,EAAE,YAAY,GAAE,qBAA0B;IAgBlF;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM;IAwBxB;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,MAAM,EAAE;IAItC;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,QAAQ;IAehB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,WAAW;CAWpB;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,qBAA4B,CAAA"}

package/output/logger/formatter.js

@@ -2,7 +2,7 @@
  * 格式化器配置模块
  * 提供各种类型数据的格式化功能
  */
-import { UserError, SystemError, UnknownError } from '../error';
+import { UserError, SystemError } from '../error';
 /**
  * 日志格式化器
  * 负责根据配置格式化各种类型的参数
@@ -66,9 +66,6 @@ export class DefaultLogFormatter {
         if (SystemError.is(error)) {
             return this.formatSystemError(error, opts);
         }
-        if (UnknownError.is(error)) {
-            return this.formatUnknownError(error, opts);
-        }
         if (error instanceof Error) {
             return this.formatGenericError(error, opts);
         }
@@ -100,19 +97,6 @@ export class DefaultLogFormatter {
         }
         return lines.join('\n  ');
     }
-    formatUnknownError(error, opts) {
-        const lines = [
-            this.colorize('❓ Unknown Error', 'magenta', opts.useColors),
-            `Message: ${error.message}`,
-        ];
-        if (opts.showContext && error.context) {
-            lines.push(`Context: ${this.formatContext(error.context)}`);
-        }
-        if (opts.showStack && error.stack) {
-            lines.push(`Stack: ${error.stack}`);
-        }
-        return lines.join('\n  ');
-    }
     formatGenericError(error, opts) {
         const lines = [
             this.colorize(`💥 ${error.name}`, 'red', opts.useColors),

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

@@ -1,26 +1,2 @@
-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;
-        };
-        'network-error': {
-            url?: string;
-            method?: string;
-            status?: number;
-        };
-    }
-}
 export {};
 //# sourceMappingURL=formatter.test.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatter.test.d.ts","sourceRoot":"","sources":["../../source/logger/formatter.test.ts"],"names":[],"mappings":"AAKA,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;QACxE,eAAe,EAAE;YAAE,GAAG,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KACpE;CACF"}
+{"version":3,"file":"formatter.test.d.ts","sourceRoot":"","sources":["../../source/logger/formatter.test.ts"],"names":[],"mappings":""}