@taicode/common-base 3.1.0 → 3.1.1

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);
-        });
-    });
-});