hyper-scheduler 1.0.0

package/tests/integration/Debug.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Scheduler } from '../../src/index';
+    // The old DebugPanel logic (if any) is gone or replaced by DevTools plugin.
+    // We should update this test to test the new DevTools plugin.
+    import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+    import { Scheduler } from '../../src/index';
+    import { DevTools } from '../../src/plugins/dev-tools';
+    
+    describe('Debug Integration', () => {
+      beforeEach(() => {    document.body.innerHTML = ''; // Clear DOM
+    // Mock Worker globally for JSDOM
+    if (typeof window !== 'undefined') {
+        window.Worker = class MockWorker {
+            postMessage() {}
+            onmessage = null;
+            terminate() {}
+            addEventListener() {}
+            removeEventListener() {}
+            dispatchEvent() { return false; }
+        } as any;
+    }
+  });
+  
+  afterEach(() => {
+     // Cleanup if needed
+  });
+
+  it('should mount DebugPanel in Browser environment when debug is enabled', async () => {
+    // Ensure we are in jsdom
+    if (typeof window === 'undefined') {
+      console.warn('Skipping browser test in node env');
+      return;
+    }
+
+    // Intentionally blank - using git checkout to restore
+    // We should update this test to test the new DevTools plugin.
+
+    const scheduler = new Scheduler({ 
+      debug: true,
+      plugins: [new DevTools()] 
+    });
+    
+    // Wait for dynamic import or initialization
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    scheduler.createTask({
+      id: 'debug-dom-test',
+      schedule: '* * * * *',
+      handler: async () => {}
+    });
+
+    // New DevTools mounts <hs-devtools>
+    const panel = document.querySelector('hs-devtools');
+    expect(panel).not.toBeNull();
+    
+    scheduler.stop();
+  });
+});

package/tests/unit/Plugin.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect, vi } from 'vitest';
+import { HyperSchedulerPlugin } from '../../src/types';
+
+describe('HyperSchedulerPlugin', () => {
+  it('should define the correct interface', () => {
+    const plugin: HyperSchedulerPlugin = {
+      name: 'TestPlugin',
+      init: (scheduler) => {
+        // Init logic
+      }
+    };
+    
+    expect(plugin.name).toBe('TestPlugin');
+    expect(typeof plugin.init).toBe('function');
+  });
+});

package/tests/unit/RetryStrategy.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { RetryStrategy } from '../../src/core/retry-strategy';
+
+describe('RetryStrategy', () => {
+  it('should return -1 if no options are provided', () => {
+    expect(RetryStrategy.getDelay(0, undefined)).toBe(-1);
+  });
+
+  it('should return correct exponential backoff delay', () => {
+    const options = { maxAttempts: 3, initialDelay: 1000, factor: 2 };
+    
+    expect(RetryStrategy.getDelay(0, options)).toBe(1000); // 1000 * 2^0
+    expect(RetryStrategy.getDelay(1, options)).toBe(2000); // 1000 * 2^1
+    expect(RetryStrategy.getDelay(2, options)).toBe(4000); // 1000 * 2^2
+  });
+
+  it('should return -1 if attempts exceed maxAttempts', () => {
+    const options = { maxAttempts: 3, initialDelay: 1000, factor: 2 };
+    expect(RetryStrategy.getDelay(3, options)).toBe(-1);
+  });
+});

package/tests/unit/Scheduler.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Scheduler } from '../../src/core/scheduler';
+import { NodeTimer } from '../../src/platform/node/node-timer';
+import { HyperSchedulerPlugin } from '../../src/types';
+
+describe('Scheduler Constructor Plugin Loading', () => {
+  it('should initialize plugins passed in config', () => {
+    const initSpy = vi.fn();
+    const plugin: HyperSchedulerPlugin = {
+      name: 'TestPlugin',
+      init: initSpy
+    };
+
+    const scheduler = new Scheduler(new NodeTimer(), {
+      plugins: [plugin]
+    });
+
+    expect(initSpy).toHaveBeenCalledTimes(1);
+    expect(initSpy).toHaveBeenCalledWith(scheduler);
+  });
+
+  it('should not crash if a plugin throws error during init', () => {
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const errorPlugin: HyperSchedulerPlugin = {
+      name: 'ErrorPlugin',
+      init: () => {
+        throw new Error('Plugin Init Failed');
+      }
+    };
+
+    const scheduler = new Scheduler(new NodeTimer(), {
+      plugins: [errorPlugin]
+    });
+
+    expect(consoleSpy).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+});

package/tests/unit/schedule.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest';
+import { parseSchedule, getNextRun } from '../../src/utils/schedule';
+
+describe('schedule.ts', () => {
+  describe('parseSchedule', () => {
+    it('should parse valid interval strings (s)', () => {
+      const result = parseSchedule('10s');
+      expect(result.type).toBe('interval');
+      expect(result.value).toBe(10 * 1000);
+    });
+
+    it('should parse valid interval strings (m)', () => {
+      const result = parseSchedule('5m');
+      expect(result.type).toBe('interval');
+      expect(result.value).toBe(5 * 60 * 1000);
+    });
+
+    it('should parse valid interval strings (h)', () => {
+      const result = parseSchedule('2h');
+      expect(result.type).toBe('interval');
+      expect(result.value).toBe(2 * 60 * 60 * 1000);
+    });
+
+    it('should parse valid interval strings (d)', () => {
+      const result = parseSchedule('1d');
+      expect(result.type).toBe('interval');
+      expect(result.value).toBe(1 * 24 * 60 * 60 * 1000);
+    });
+
+    it('should parse valid cron expressions', () => {
+      const result = parseSchedule('* * * * *');
+      expect(result.type).toBe('cron');
+      expect(result.value).toBe('* * * * *');
+    });
+
+    it('should throw error for invalid format', () => {
+      expect(() => parseSchedule('invalid')).toThrow(/无效的调度格式/);
+    });
+
+    it('should throw error for invalid cron after interval check', () => {
+      expect(() => parseSchedule('invalid-cron')).toThrow(/无效的调度格式/);
+    });
+  });
+
+  describe('getNextRun', () => {
+    it('should return next run for interval schedule', () => {
+      const now = Date.now();
+      vi.setSystemTime(now); // Mock current time
+      const schedule = parseSchedule('5s');
+      const nextRun = getNextRun(schedule, { lastRun: now });
+      expect(nextRun.getTime()).toBe(now + 5 * 1000);
+      vi.useRealTimers();
+    });
+
+    it('should return next run for cron schedule', () => {
+      const now = Date.now();
+      vi.setSystemTime(now);
+      const schedule = parseSchedule('* * * * *');
+      const nextRun = getNextRun(schedule);
+      // 应该返回下一分钟的 0 秒
+      expect(nextRun.getTime()).toBeGreaterThan(now);
+      expect(nextRun.getSeconds()).toBe(0);
+      vi.useRealTimers();
+    });
+
+    it('should throw error for invalid cron in getNextRun', () => {
+      expect(() => getNextRun('invalid-cron')).toThrow(/无效的调度格式/);
+    });
+  });
+});

package/tests/unit/ui/DevToolsStore.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DevToolsStore } from '../../../src/ui/store/dev-tools-store';
+
+describe('DevToolsStore', () => {
+  let store: DevToolsStore;
+
+  beforeEach(() => {
+    store = new DevToolsStore();
+  });
+
+  it('should initialize with default state', () => {
+    const state = store.getState();
+    expect(state.isOpen).toBe(false);
+    expect(state.activeTab).toBe('tasks');
+    expect(state.theme).toBe('auto');
+    expect(state.tasks.size).toBe(0);
+  });
+
+  it('should toggle visibility', () => {
+    store.toggle();
+    expect(store.getState().isOpen).toBe(true);
+    store.toggle();
+    expect(store.getState().isOpen).toBe(false);
+  });
+
+  it('should set theme', () => {
+    store.setTheme('dark');
+    expect(store.getState().theme).toBe('dark');
+  });
+
+  it('should update tasks', () => {
+    const mockTask = {
+      id: 't1',
+      status: 'running',
+      lastRun: null,
+      nextRun: null,
+      executionCount: 0,
+      schedule: '1s',
+      tags: [],
+      error: null
+    };
+    store.updateTask(mockTask);
+    expect(store.getState().tasks.get('t1')).toEqual(mockTask);
+  });
+
+  it('should notify subscribers on state change', () => {
+    const listener = vi.fn();
+    store.subscribe('isOpen', listener);
+
+    store.toggle();
+    expect(listener).toHaveBeenCalledWith(true);
+  });
+
+  it('should not notify removed subscribers', () => {
+    const listener = vi.fn();
+    const unsubscribe = store.subscribe('isOpen', listener);
+    
+    unsubscribe();
+    store.toggle();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('should switch tabs', () => {
+    store.setTab('timeline');
+    expect(store.getState().activeTab).toBe('timeline');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,51 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import { visualizer } from 'rollup-plugin-visualizer';
+
+export default defineConfig({
+  plugins: [
+    visualizer({
+      open: false,
+      gzipSize: true,
+      brotliSize: true,
+      filename: 'stats.html'
+    }),
+  ],
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'HyperScheduler',
+      fileName: 'index',
+      formats: ['es', 'cjs', 'umd'],
+    },
+    minify: 'terser',
+    terserOptions: {
+      compress: {
+        drop_console: false,
+        drop_debugger: true,
+      },
+      format: {
+        comments: false,
+      },
+    },
+    rollupOptions: {
+      // 确保外部化处理那些你不想打包进库的依赖
+      external: [],
+      output: {
+        // 在 UMD 构建模式下为这些外部化的依赖提供一个全局变量
+        globals: {},
+        // 确保 Tree-shaking
+        manualChunks: undefined,
+      },
+      treeshake: {
+        moduleSideEffects: true,
+        propertyReadSideEffects: false,
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, 'src'),
+    },
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom', // Use jsdom for browser-like environment (needed for Web Workers simulation in the future, though node env is default)
+    include: ['tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        'tests/',
+        '**/*.d.ts',
+        '**/*.config.ts',
+      ],
+    },
+    alias: {
+      '@': resolve(__dirname, 'src'),
+    },
+  },
+});