@taicode/common-base 3.1.0 → 3.2.0

package/output/catch/catch.d.ts

@@ -13,6 +13,7 @@ export interface CatchSuccess<T> {
  */
 export interface CatchFailure<E> {
     error: E;
+    context: unknown;
 }
 /**
  * 捕获结果联合类型，使用判别联合类型以支持类型守卫

package/output/catch/catch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAExH;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;CACT;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;CACT;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAC9E;;;;OAIG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,CAAA;CACpD,CAAA;AA0BD;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAChG,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAExH;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;CACT;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;IACR,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAC9E;;;;OAIG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,CAAA;CACpD,CAAA;AA0BD;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAChG,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/output/disposer/disposer.d.ts

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

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

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

package/output/disposer/disposer.js

@@ -6,15 +6,16 @@ export class Disposer {
         this.cleanupFunctions.push(cleanupFn);
     }
     // 执行所有清理函数
-    dispose() {
-        for (const cleanupFn of this.cleanupFunctions) {
+    async dispose() {
+        const cleanupFunctions = this.cleanupFunctions;
+        this.cleanupFunctions = [];
+        for (const cleanupFn of cleanupFunctions) {
             try {
-                cleanupFn();
+                await cleanupFn();
             }
             catch (error) {
                 logger.error('Error during cleanup:', error);
             }
         }
-        this.cleanupFunctions = []; // 清空清理函数列表
     }
 }

package/output/disposer/disposer.test.js

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

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

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { FlowQueue } from './flow-queue.js';
+import { logger } from '../logger/index.js';
 describe('FlowQueue', () => {
     let flowQueue;
     let mockProcessor;
@@ -158,8 +159,8 @@ describe('FlowQueue', () => {
                 throw new Error('Callback error');
             });
             const normalCallback = vi.fn();
-            // Mock console.error 来验证错误被正确记录
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            // Mock logger.error 来验证错误被正确记录
+            const loggerErrorSpy = vi.spyOn(logger, 'error').mockImplementation(() => { });
             mockProcessor = vi.fn().mockResolvedValue(expectedOutput);
             flowQueue = new FlowQueue({ retry: { maxRetries: 3 } }, mockProcessor);
             flowQueue.onGenerate(faultyCallback);
@@ -168,8 +169,8 @@ describe('FlowQueue', () => {
             await new Promise(resolve => setTimeout(resolve, 50));
             expect(faultyCallback).toHaveBeenCalled();
             expect(normalCallback).toHaveBeenCalledWith(expectedOutput);
-            expect(consoleErrorSpy).toHaveBeenCalledWith('Error in onGenerate callback:', expect.any(Error));
-            consoleErrorSpy.mockRestore();
+            expect(loggerErrorSpy).toHaveBeenCalledWith('Error in onGenerate callback:', expect.any(Error));
+            loggerErrorSpy.mockRestore();
         });
         it('失败的处理不应该触发回调', async () => {
             const testInput = { id: 1, data: 'test' };

package/output/ring-cache/ring-cache.test.js

@@ -77,9 +77,10 @@ describe('RingCache', () => {
             expect(results.map(e => e.data)).toEqual(['apple', 'apricot']);
         });
         it('应该支持时间范围搜索', () => {
-            const now = new Date();
-            const future = new Date(now.getTime() + 1000);
-            const results = cache.getByTimeRange(now, future);
+            const entries = cache.getAll();
+            const start = new Date(entries[0].timestamp.getTime() - 1);
+            const end = new Date(entries[entries.length - 1].timestamp.getTime() + 1);
+            const results = cache.getByTimeRange(start, end);
             expect(results.length).toBe(3);
         });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-base",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "author": "Alain",
   "license": "ISC",
   "description": "",
@@ -22,15 +22,15 @@
   },
   "scripts": {
     "test": "vitest run",
-    "build": "tsc -p tsconfig.json",
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
-    "dev": "tsc -p tsconfig.json --watch"
+    "dev": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --watch"
   },
   "files": [
     "output"
   ],
   "devDependencies": {
     "vitest": "^3.2.4",
-    "mobx": "^6.0.0"
+    "mobx": "^6.15.0"
   }
 }

package/output/scheduler/index.d.ts

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

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

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

package/output/scheduler/index.js

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

package/output/scheduler/scheduler.d.ts

@@ -1,222 +0,0 @@
-import { EventEmitter } from '../event-emitter';
-import { type CatchResult } from '../catch';
-/**
- * 定时任务配置
- */
-export interface ScheduledTaskConfig {
-    /**
-     * 任务唯一标识
-     */
-    id: string;
-    /**
-     * 任务执行间隔（秒），必须是 10 的倍数
-     */
-    interval: number;
-    /**
-     * 任务处理函数
-     */
-    handler: () => Promise<void> | void;
-    /**
-     * 最大重试次数，默认 3
-     */
-    maxRetries?: number;
-    /**
-     * 重试间隔（毫秒），默认 1000
-     */
-    retryDelay?: number;
-    /**
-     * 是否在启动时立即执行一次，默认 false
-     */
-    immediate?: boolean;
-    /**
-     * 是否启用，默认 true
-     */
-    enabled?: boolean;
-}
-/**
- * 任务执行记录
- */
-export interface TaskExecution {
-    taskId: string;
-    startTime: number;
-    endTime?: number;
-    success: boolean;
-    error?: Error;
-    retryCount: number;
-}
-/**
- * 调度器事件
- */
-export interface SchedulerEvents {
-    'task:start': {
-        taskId: string;
-    };
-    'task:success': {
-        taskId: string;
-        duration: number;
-    };
-    'task:error': {
-        taskId: string;
-        error: Error;
-        retryCount: number;
-    };
-    'task:retry': {
-        taskId: string;
-        retryCount: number;
-        maxRetries: number;
-    };
-    'task:failed': {
-        taskId: string;
-        error: Error;
-    };
-    'scheduler:start': void;
-    'scheduler:stop': void;
-    'scheduler:tick': {
-        tick: number;
-    };
-}
-/**
- * 内部任务状态
- */
-interface TaskState {
-    config: Required<ScheduledTaskConfig>;
-    nextTick: number;
-    running: boolean;
-    retryCount: number;
-    lastError?: Error;
-    executions: TaskExecution[];
-}
-/**
- * 定时任务调度器
- *
- * 以 10 秒为基本时间单位，支持多个不同间隔的定时任务
- *
- * @example
- * ```ts
- * const scheduler = new Scheduler()
- *
- * // 添加每 30 秒执行一次的任务
- * scheduler.addTask({
- *   id: 'sync-data',
- *   interval: 30,
- *   handler: async () => {
- *     await syncDataToServer()
- *   },
- *   maxRetries: 3
- * })
- *
- * // 添加每 60 秒执行一次的任务
- * scheduler.addTask({
- *   id: 'cleanup',
- *   interval: 60,
- *   handler: async () => {
- *     await cleanupTempFiles()
- *   }
- * })
- *
- * // 启动调度器
- * scheduler.start()
- *
- * // 监听事件
- * scheduler.on('task:error', (taskId, error) => {
- *   console.error(`Task ${taskId} failed:`, error)
- * })
- *
- * // 停止调度器
- * scheduler.stop()
- * ```
- */
-export declare class Scheduler extends EventEmitter<SchedulerEvents> {
-    /**
-     * 基本时间单位（秒）
-     */
-    private static readonly TICK_INTERVAL;
-    /**
-     * 当前 tick 计数
-     */
-    private currentTick;
-    /**
-     * 定时器 ID
-     */
-    private timerId;
-    /**
-     * 是否正在运行
-     */
-    private running;
-    /**
-     * 任务状态映射
-     */
-    private tasks;
-    /**
-     * 添加定时任务
-     */
-    addTask(config: ScheduledTaskConfig): void;
-    /**
-     * 移除定时任务
-     */
-    removeTask(taskId: string): boolean;
-    /**
-     * 启用任务
-     */
-    enableTask(taskId: string): boolean;
-    /**
-     * 禁用任务
-     */
-    disableTask(taskId: string): boolean;
-    /**
-     * 获取任务状态
-     */
-    getTaskState(taskId: string): Readonly<TaskState> | undefined;
-    /**
-     * 获取所有任务 ID
-     */
-    getTaskIds(): string[];
-    /**
-     * 启动调度器
-     */
-    start(): void;
-    /**
-     * 停止调度器
-     */
-    stop(): void;
-    /**
-     * 是否正在运行
-     */
-    isRunning(): boolean;
-    /**
-     * 获取当前 tick
-     */
-    getCurrentTick(): number;
-    /**
-     * 手动触发任务执行（忽略时间间隔）
-     */
-    triggerTask(taskId: string): Promise<CatchResult<void, string>>;
-    /**
-     * 执行 tick
-     */
-    private tick;
-    /**
-     * 执行任务
-     */
-    private executeTask;
-    /**
-     * 获取任务执行历史
-     */
-    getTaskExecutions(taskId: string, limit?: number): TaskExecution[];
-    /**
-     * 获取调度器统计信息
-     */
-    getStats(): {
-        running: boolean;
-        currentTick: number;
-        totalTasks: number;
-        enabledTasks: number;
-        runningTasks: number;
-    };
-    /**
-     * 清理所有任务
-     */
-    clear(): void;
-}
-export {};
-//# sourceMappingURL=scheduler.d.ts.map

package/output/scheduler/scheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../source/scheduler/scheduler.ts"],"names":[],"mappings":"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"}

package/output/scheduler/scheduler.js

@@ -1,348 +0,0 @@
-import { EventEmitter } from '../event-emitter';
-import { catchIt } from '../catch';
-/**
- * 定时任务调度器
- *
- * 以 10 秒为基本时间单位，支持多个不同间隔的定时任务
- *
- * @example
- * ```ts
- * const scheduler = new Scheduler()
- *
- * // 添加每 30 秒执行一次的任务
- * scheduler.addTask({
- *   id: 'sync-data',
- *   interval: 30,
- *   handler: async () => {
- *     await syncDataToServer()
- *   },
- *   maxRetries: 3
- * })
- *
- * // 添加每 60 秒执行一次的任务
- * scheduler.addTask({
- *   id: 'cleanup',
- *   interval: 60,
- *   handler: async () => {
- *     await cleanupTempFiles()
- *   }
- * })
- *
- * // 启动调度器
- * scheduler.start()
- *
- * // 监听事件
- * scheduler.on('task:error', (taskId, error) => {
- *   console.error(`Task ${taskId} failed:`, error)
- * })
- *
- * // 停止调度器
- * scheduler.stop()
- * ```
- */
-export class Scheduler extends EventEmitter {
-    /**
-     * 基本时间单位（秒）
-     */
-    static TICK_INTERVAL = 10;
-    /**
-     * 当前 tick 计数
-     */
-    currentTick = 0;
-    /**
-     * 定时器 ID
-     */
-    timerId = null;
-    /**
-     * 是否正在运行
-     */
-    running = false;
-    /**
-     * 任务状态映射
-     */
-    tasks = new Map();
-    /**
-     * 添加定时任务
-     */
-    addTask(config) {
-        // 验证参数
-        if (!config.id) {
-            throw new Error('[Scheduler] Task id is required');
-        }
-        if (!config.interval || config.interval <= 0) {
-            throw new Error('[Scheduler] Task interval must be positive');
-        }
-        if (config.interval % Scheduler.TICK_INTERVAL !== 0) {
-            throw new Error(`[Scheduler] Task interval must be a multiple of ${Scheduler.TICK_INTERVAL} seconds`);
-        }
-        if (!config.handler) {
-            throw new Error('[Scheduler] Task handler is required');
-        }
-        if (this.tasks.has(config.id)) {
-            throw new Error(`[Scheduler] Task with id "${config.id}" already exists`);
-        }
-        // 创建任务状态
-        const taskState = {
-            config: {
-                id: config.id,
-                interval: config.interval,
-                handler: config.handler,
-                maxRetries: config.maxRetries ?? 3,
-                retryDelay: config.retryDelay ?? 1000,
-                immediate: config.immediate ?? false,
-                enabled: config.enabled ?? true,
-            },
-            nextTick: config.immediate ? 0 : Math.ceil(config.interval / Scheduler.TICK_INTERVAL),
-            running: false,
-            retryCount: 0,
-            executions: [],
-        };
-        this.tasks.set(config.id, taskState);
-        console.log(`[Scheduler] Task "${config.id}" added (interval: ${config.interval}s)`);
-    }
-    /**
-     * 移除定时任务
-     */
-    removeTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            return false;
-        }
-        if (task.running) {
-            console.warn(`[Scheduler] Cannot remove running task "${taskId}"`);
-            return false;
-        }
-        this.tasks.delete(taskId);
-        console.log(`[Scheduler] Task "${taskId}" removed`);
-        return true;
-    }
-    /**
-     * 启用任务
-     */
-    enableTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            return false;
-        }
-        task.config.enabled = true;
-        console.log(`[Scheduler] Task "${taskId}" enabled`);
-        return true;
-    }
-    /**
-     * 禁用任务
-     */
-    disableTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            return false;
-        }
-        task.config.enabled = false;
-        console.log(`[Scheduler] Task "${taskId}" disabled`);
-        return true;
-    }
-    /**
-     * 获取任务状态
-     */
-    getTaskState(taskId) {
-        const task = this.tasks.get(taskId);
-        return task ? { ...task } : undefined;
-    }
-    /**
-     * 获取所有任务 ID
-     */
-    getTaskIds() {
-        return Array.from(this.tasks.keys());
-    }
-    /**
-     * 启动调度器
-     */
-    start() {
-        if (this.running) {
-            console.warn('[Scheduler] Scheduler is already running');
-            return;
-        }
-        this.running = true;
-        this.currentTick = 0;
-        this.emit('scheduler:start', undefined);
-        console.log('[Scheduler] Scheduler started');
-        // 立即执行一次 tick
-        this.tick();
-        // 设置定时器
-        this.timerId = setInterval(() => {
-            this.tick();
-        }, Scheduler.TICK_INTERVAL * 1000);
-    }
-    /**
-     * 停止调度器
-     */
-    stop() {
-        if (!this.running) {
-            return;
-        }
-        if (this.timerId) {
-            clearInterval(this.timerId);
-            this.timerId = null;
-        }
-        this.running = false;
-        this.emit('scheduler:stop', undefined);
-        console.log('[Scheduler] Scheduler stopped');
-    }
-    /**
-     * 是否正在运行
-     */
-    isRunning() {
-        return this.running;
-    }
-    /**
-     * 获取当前 tick
-     */
-    getCurrentTick() {
-        return this.currentTick;
-    }
-    /**
-     * 手动触发任务执行（忽略时间间隔）
-     */
-    async triggerTask(taskId) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            return catchIt(async () => {
-                throw new Error(`Task "${taskId}" not found`);
-            });
-        }
-        return this.executeTask(task);
-    }
-    /**
-     * 执行 tick
-     */
-    tick() {
-        this.currentTick++;
-        this.emit('scheduler:tick', { tick: this.currentTick });
-        // 检查需要执行的任务
-        for (const task of this.tasks.values()) {
-            if (!task.config.enabled) {
-                continue;
-            }
-            if (task.running) {
-                continue;
-            }
-            // 检查是否到达执行时间
-            if (this.currentTick >= task.nextTick) {
-                // 异步执行任务，不阻塞 tick
-                this.executeTask(task).catch((error) => {
-                    console.error(`[Scheduler] Unexpected error in task "${task.config.id}":`, error);
-                });
-            }
-        }
-    }
-    /**
-     * 执行任务
-     */
-    async executeTask(task) {
-        const { config } = task;
-        const startTime = Date.now();
-        task.running = true;
-        this.emit('task:start', { taskId: config.id });
-        const execution = {
-            taskId: config.id,
-            startTime,
-            success: false,
-            retryCount: task.retryCount,
-        };
-        const result = await catchIt(async () => config.handler());
-        const endTime = Date.now();
-        const duration = endTime - startTime;
-        execution.endTime = endTime;
-        if (result.isError()) {
-            // 执行失败
-            const error = new Error(String(result.error));
-            execution.success = false;
-            execution.error = error;
-            task.lastError = error;
-            task.retryCount++;
-            this.emit('task:error', { taskId: config.id, error, retryCount: task.retryCount });
-            // 检查是否需要重试
-            if (task.retryCount <= config.maxRetries) {
-                this.emit('task:retry', {
-                    taskId: config.id,
-                    retryCount: task.retryCount,
-                    maxRetries: config.maxRetries,
-                });
-                console.warn(`[Scheduler] Task "${config.id}" failed, will retry (${task.retryCount}/${config.maxRetries})`);
-                // 延迟后重试
-                await new Promise((resolve) => setTimeout(resolve, config.retryDelay));
-                task.running = false;
-                return this.executeTask(task);
-            }
-            else {
-                // 超过最大重试次数
-                this.emit('task:failed', { taskId: config.id, error });
-                console.error(`[Scheduler] Task "${config.id}" failed after ${config.maxRetries} retries:`, error.message);
-                // 重置重试计数，计划下次执行
-                task.retryCount = 0;
-                task.nextTick = this.currentTick + Math.ceil(config.interval / Scheduler.TICK_INTERVAL);
-                task.running = false;
-                task.executions.push(execution);
-                return result;
-            }
-        }
-        else {
-            // 执行成功
-            execution.success = true;
-            task.retryCount = 0;
-            task.lastError = undefined;
-            this.emit('task:success', { taskId: config.id, duration });
-            // 计划下次执行
-            task.nextTick = this.currentTick + Math.ceil(config.interval / Scheduler.TICK_INTERVAL);
-            task.running = false;
-            task.executions.push(execution);
-            // 保留最近 100 条执行记录
-            if (task.executions.length > 100) {
-                task.executions = task.executions.slice(-100);
-            }
-            return result;
-        }
-    }
-    /**
-     * 获取任务执行历史
-     */
-    getTaskExecutions(taskId, limit = 10) {
-        const task = this.tasks.get(taskId);
-        if (!task) {
-            return [];
-        }
-        return task.executions.slice(-limit);
-    }
-    /**
-     * 获取调度器统计信息
-     */
-    getStats() {
-        let enabledTasks = 0;
-        let runningTasks = 0;
-        for (const task of this.tasks.values()) {
-            if (task.config.enabled) {
-                enabledTasks++;
-            }
-            if (task.running) {
-                runningTasks++;
-            }
-        }
-        return {
-            running: this.running,
-            currentTick: this.currentTick,
-            totalTasks: this.tasks.size,
-            enabledTasks,
-            runningTasks,
-        };
-    }
-    /**
-     * 清理所有任务
-     */
-    clear() {
-        if (this.running) {
-            console.warn('[Scheduler] Cannot clear tasks while scheduler is running');
-            return;
-        }
-        this.tasks.clear();
-        console.log('[Scheduler] All tasks cleared');
-    }
-}

package/output/scheduler/scheduler.test.d.ts

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

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

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

package/output/scheduler/scheduler.test.js

@@ -1,341 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { Scheduler } from './scheduler';
-describe('Scheduler', () => {
-    let scheduler;
-    beforeEach(() => {
-        scheduler = new Scheduler();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        scheduler.stop();
-        scheduler.clear();
-        vi.restoreAllMocks();
-        vi.useRealTimers();
-    });
-    describe('任务管理', () => {
-        it('应该成功添加任务', () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'test-task',
-                interval: 10,
-                handler,
-            });
-            expect(scheduler.getTaskIds()).toContain('test-task');
-        });
-        it('添加任务时 interval 必须是 10 的倍数', () => {
-            expect(() => {
-                scheduler.addTask({
-                    id: 'invalid-task',
-                    interval: 15,
-                    handler: vi.fn(),
-                });
-            }).toThrow('must be a multiple of 10');
-        });
-        it('不应该添加重复 id 的任务', () => {
-            scheduler.addTask({
-                id: 'test-task',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            expect(() => {
-                scheduler.addTask({
-                    id: 'test-task',
-                    interval: 20,
-                    handler: vi.fn(),
-                });
-            }).toThrow('already exists');
-        });
-        it('应该成功移除任务', () => {
-            scheduler.addTask({
-                id: 'test-task',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            const removed = scheduler.removeTask('test-task');
-            expect(removed).toBe(true);
-            expect(scheduler.getTaskIds()).not.toContain('test-task');
-        });
-        it('应该能够启用和禁用任务', () => {
-            scheduler.addTask({
-                id: 'test-task',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            expect(scheduler.disableTask('test-task')).toBe(true);
-            const state = scheduler.getTaskState('test-task');
-            expect(state?.config.enabled).toBe(false);
-            expect(scheduler.enableTask('test-task')).toBe(true);
-            const state2 = scheduler.getTaskState('test-task');
-            expect(state2?.config.enabled).toBe(true);
-        });
-    });
-    describe('任务调度', () => {
-        it('应该按照指定间隔执行任务', async () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'test-task',
-                interval: 10,
-                handler,
-            });
-            scheduler.start();
-            // 第一次 tick (0s)
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler).toHaveBeenCalledTimes(1);
-            // 第二次 tick (10s)
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler).toHaveBeenCalledTimes(2);
-            // 第三次 tick (20s)
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler).toHaveBeenCalledTimes(3);
-        });
-        it('应该支持不同间隔的多个任务', async () => {
-            const handler1 = vi.fn();
-            const handler2 = vi.fn();
-            scheduler.addTask({
-                id: 'task-10s',
-                interval: 10,
-                handler: handler1,
-            });
-            scheduler.addTask({
-                id: 'task-30s',
-                interval: 30,
-                handler: handler2,
-            });
-            scheduler.start();
-            // 10s
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler1).toHaveBeenCalledTimes(1);
-            expect(handler2).toHaveBeenCalledTimes(0);
-            // 20s
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler1).toHaveBeenCalledTimes(2);
-            expect(handler2).toHaveBeenCalledTimes(0);
-            // 30s
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler1).toHaveBeenCalledTimes(3);
-            expect(handler2).toHaveBeenCalledTimes(1);
-        });
-        it('immediate 参数应该使任务立即执行', async () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'immediate-task',
-                interval: 10,
-                handler,
-                immediate: true,
-            });
-            scheduler.start();
-            // 立即执行
-            await vi.runAllTimersAsync();
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it('禁用的任务不应该执行', async () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'disabled-task',
-                interval: 10,
-                handler,
-                enabled: false,
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(20000);
-            expect(handler).not.toHaveBeenCalled();
-        });
-    });
-    describe('重试机制', () => {
-        it('失败的任务应该自动重试', async () => {
-            let attemptCount = 0;
-            const handler = vi.fn(async () => {
-                attemptCount++;
-                if (attemptCount < 3) {
-                    throw new Error('Task failed');
-                }
-            });
-            const errorListener = vi.fn();
-            const retryListener = vi.fn();
-            const successListener = vi.fn();
-            scheduler.on('task:error', errorListener);
-            scheduler.on('task:retry', retryListener);
-            scheduler.on('task:success', successListener);
-            scheduler.addTask({
-                id: 'retry-task',
-                interval: 10,
-                handler,
-                maxRetries: 3,
-                retryDelay: 100,
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(10000);
-            await vi.advanceTimersByTimeAsync(500); // 等待重试
-            expect(handler).toHaveBeenCalledTimes(3);
-            expect(errorListener).toHaveBeenCalledTimes(2);
-            expect(retryListener).toHaveBeenCalledTimes(2);
-            expect(successListener).toHaveBeenCalledTimes(1);
-        });
-        it('超过最大重试次数后应该触发 task:failed 事件', async () => {
-            const handler = vi.fn(async () => {
-                throw new Error('Always fails');
-            });
-            const failedListener = vi.fn();
-            scheduler.on('task:failed', failedListener);
-            scheduler.addTask({
-                id: 'failing-task',
-                interval: 10,
-                handler,
-                maxRetries: 2,
-                retryDelay: 100,
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(10000);
-            await vi.advanceTimersByTimeAsync(500); // 等待重试
-            expect(handler).toHaveBeenCalledTimes(3); // 1 次初始 + 2 次重试
-            expect(failedListener).toHaveBeenCalledTimes(1);
-        });
-        it('失败后应该在下个周期重新执行', async () => {
-            let shouldFail = true;
-            const handler = vi.fn(async () => {
-                if (shouldFail) {
-                    throw new Error('First execution fails');
-                }
-            });
-            scheduler.addTask({
-                id: 'recover-task',
-                interval: 10,
-                handler,
-                maxRetries: 0, // 不重试
-            });
-            scheduler.start();
-            // 第一次执行 - 失败
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler).toHaveBeenCalledTimes(1);
-            shouldFail = false;
-            // 第二次执行 - 成功
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(handler).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('事件系统', () => {
-        it('应该触发 scheduler:start 事件', () => {
-            const listener = vi.fn();
-            scheduler.on('scheduler:start', listener);
-            scheduler.start();
-            expect(listener).toHaveBeenCalledTimes(1);
-        });
-        it('应该触发 scheduler:stop 事件', () => {
-            const listener = vi.fn();
-            scheduler.on('scheduler:stop', listener);
-            scheduler.start();
-            scheduler.stop();
-            expect(listener).toHaveBeenCalledTimes(1);
-        });
-        it('应该触发 scheduler:tick 事件', async () => {
-            const listener = vi.fn();
-            scheduler.on('scheduler:tick', listener);
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(listener).toHaveBeenCalledWith({ tick: 1 });
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(listener).toHaveBeenCalledWith({ tick: 2 });
-        });
-        it('应该触发 task:start 和 task:success 事件', async () => {
-            const startListener = vi.fn();
-            const successListener = vi.fn();
-            scheduler.on('task:start', startListener);
-            scheduler.on('task:success', successListener);
-            scheduler.addTask({
-                id: 'success-task',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(10000);
-            expect(startListener).toHaveBeenCalledWith({ taskId: 'success-task' });
-            expect(successListener).toHaveBeenCalledWith({
-                taskId: 'success-task',
-                duration: expect.any(Number)
-            });
-        });
-    });
-    describe('手动触发', () => {
-        it('应该能够手动触发任务执行', async () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'manual-task',
-                interval: 60,
-                handler,
-            });
-            const result = await scheduler.triggerTask('manual-task');
-            expect(result.isError()).toBe(false);
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-        it('手动触发不存在的任务应该返回错误', async () => {
-            const result = await scheduler.triggerTask('non-existent');
-            expect(result.isError()).toBe(true);
-        });
-    });
-    describe('统计信息', () => {
-        it('应该正确返回统计信息', () => {
-            scheduler.addTask({
-                id: 'task-1',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            scheduler.addTask({
-                id: 'task-2',
-                interval: 20,
-                handler: vi.fn(),
-                enabled: false,
-            });
-            const stats = scheduler.getStats();
-            expect(stats.totalTasks).toBe(2);
-            expect(stats.enabledTasks).toBe(1);
-            expect(stats.running).toBe(false);
-        });
-        it('应该记录任务执行历史', async () => {
-            const handler = vi.fn();
-            scheduler.addTask({
-                id: 'history-task',
-                interval: 10,
-                handler,
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(30000); // 执行 3 次
-            const executions = scheduler.getTaskExecutions('history-task', 10);
-            expect(executions.length).toBe(3);
-            expect(executions.every((e) => e.success)).toBe(true);
-        });
-    });
-    describe('边界情况', () => {
-        it('重复启动应该被忽略', () => {
-            scheduler.start();
-            scheduler.start();
-            expect(scheduler.isRunning()).toBe(true);
-        });
-        it('停止未启动的调度器应该正常处理', () => {
-            expect(() => scheduler.stop()).not.toThrow();
-        });
-        it('不应该移除正在运行的任务', async () => {
-            const handler = vi.fn(async () => {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            });
-            scheduler.addTask({
-                id: 'running-task',
-                interval: 10,
-                handler,
-            });
-            scheduler.start();
-            await vi.advanceTimersByTimeAsync(10000);
-            const removed = scheduler.removeTask('running-task');
-            expect(removed).toBe(false);
-        });
-        it('运行中不应该清空任务', () => {
-            scheduler.addTask({
-                id: 'task-1',
-                interval: 10,
-                handler: vi.fn(),
-            });
-            scheduler.start();
-            scheduler.clear();
-            expect(scheduler.getTaskIds().length).toBe(1);
-        });
-    });
-});