@taicode/common-base 3.0.1 → 3.1.0

package/output/scheduler/scheduler.test.js

@@ -0,0 +1,341 @@
+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);
+        });
+    });
+});

package/output/service/index.d.ts

@@ -1,2 +1,2 @@
-export { Service } from './service';
+export { Service } from './service.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA"}

package/output/service/index.js

@@ -1 +1 @@
-export { Service } from './service';
+export { Service } from './service.js';

package/output/string/index.d.ts

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

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

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

package/output/string/index.js

@@ -1 +1 @@
-export * from './string';
+export * from './string.js';

package/output/string/string.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { randomString } from './string';
+import { randomString } from './string.js';
 describe('randomString 函数', () => {
     beforeEach(() => {
         // 重置随机数生成器的模拟

package/output/throttle/index.d.ts

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

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

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

package/output/throttle/index.js

@@ -1 +1 @@
-export * from './throttle';
+export * from './throttle.js';

package/output/throttle/throttle.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { throttle, throttleFn } from './throttle';
+import { throttle, throttleFn } from './throttle.js';
 describe('throttle', () => {
     beforeEach(() => {
         vi.useFakeTimers();

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

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

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

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

package/output/ttl-cache/index.js

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

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { TtlCache } from './ttl-cache';
+import { TtlCache } from './ttl-cache.js';
 describe('TtlCache', () => {
     let cache;
     beforeEach(() => {

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@taicode/common-base",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "author": "Alain",
   "license": "ISC",
   "description": "",
+  "type": "module",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "main": "./output/index.js",
   "types": "./output/index.d.ts",
   "exports": {
     ".": {
       "types": "./output/index.d.ts",
-      "import": "./output/index.js",
-      "require": "./output/index.js"
+      "default": "./output/index.js"
     },
     "./*": {
       "types": "./output/*/index.d.ts",
-      "import": "./output/*/index.js",
-      "require": "./output/*/index.js"
+      "default": "./output/*/index.js"
     }
   },
   "scripts": {

package/output/events/disposer.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"disposer.d.ts","sourceRoot":"","sources":["../../source/events/disposer.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ;IACnB,OAAO,CAAC,gBAAgB,CAAyB;IAGjD,WAAW,CAAC,SAAS,EAAE,MAAM,OAAO,GAAG,IAAI;IAK3C,OAAO,IAAI,IAAI;CAUhB"}

package/output/events/disposer.js

@@ -1,19 +0,0 @@
-export class Disposer {
-    cleanupFunctions = [];
-    // 添加清理函数
-    addDisposer(cleanupFn) {
-        this.cleanupFunctions.push(cleanupFn);
-    }
-    // 执行所有清理函数
-    dispose() {
-        for (const cleanupFn of this.cleanupFunctions) {
-            try {
-                cleanupFn();
-            }
-            catch (error) {
-                console.error('Error during cleanup:', error);
-            }
-        }
-        this.cleanupFunctions = []; // 清空清理函数列表
-    }
-}

package/output/events/disposer.test.d.ts

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

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

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