hyper-scheduler 1.0.0

package/src/ui/store/dev-tools-store.ts

@@ -0,0 +1,191 @@
+import { TaskSnapshot, TaskControlAPI } from '../../types';
+import { setLanguage } from '../i18n';
+
+export interface DevToolsState {
+  isOpen: boolean;
+  activeTab: 'tasks' | 'timeline';
+  theme: 'light' | 'dark' | 'auto';
+  dockPosition: 'right' | 'bottom';
+  panelSize: { width: number; height: number };
+  language: 'en' | 'zh';
+  filterText: string;
+  selectedTaskId: string | null;
+  tasks: Map<string, TaskSnapshot>;
+  history: Map<string, any[]>; 
+  fps: number;
+  schedulerRunning: boolean;
+}
+
+type Listener<T> = (value: T) => void;
+
+export class DevToolsStore {
+  private state: DevToolsState;
+  private listeners: Map<keyof DevToolsState, Set<Listener<any>>>;
+  private scheduler?: TaskControlAPI;
+
+  constructor() {
+    this.state = {
+      isOpen: false,
+      activeTab: 'tasks',
+      theme: 'auto',
+      dockPosition: 'right',
+      panelSize: { width: 500, height: 500 },
+      language: 'en',
+      filterText: '',
+      selectedTaskId: null,
+      tasks: new Map(),
+      history: new Map(),
+      fps: 0,
+      schedulerRunning: false,
+    };
+    this.listeners = new Map();
+  }
+
+  setScheduler(scheduler: TaskControlAPI) {
+    this.scheduler = scheduler;
+  }
+
+  getState(): Readonly<DevToolsState> {
+    return this.state;
+  }
+
+  subscribe<K extends keyof DevToolsState>(
+    key: K,
+    callback: Listener<DevToolsState[K]>
+  ): () => void {
+    if (!this.listeners.has(key)) {
+      this.listeners.set(key, new Set());
+    }
+    this.listeners.get(key)!.add(callback);
+
+    return () => {
+      this.listeners.get(key)?.delete(callback);
+    };
+  }
+
+  private notify<K extends keyof DevToolsState>(key: K, value: DevToolsState[K]) {
+    this.listeners.get(key)?.forEach((cb) => cb(value));
+  }
+
+  toggle() {
+    this.state.isOpen = !this.state.isOpen;
+    this.notify('isOpen', this.state.isOpen);
+  }
+
+  setTheme(theme: 'light' | 'dark' | 'auto') {
+    this.state.theme = theme;
+    this.notify('theme', this.state.theme);
+  }
+
+  /**
+   * Set language synchronously without notifying listeners.
+   * Used during initialization before child components render.
+   */
+  setLanguageSync(lang: 'en' | 'zh') {
+    setLanguage(lang);
+    this.state.language = lang;
+  }
+
+  setLanguage(lang: 'en' | 'zh') {
+    setLanguage(lang);
+    this.state.language = lang;
+    this.notify('language', this.state.language);
+  }
+
+  setPanelSize(size: { width?: number; height?: number }) {
+    this.state.panelSize = { ...this.state.panelSize, ...size };
+    // Persist to localStorage?
+    try {
+      localStorage.setItem('hs-panel-size', JSON.stringify(this.state.panelSize));
+    } catch (e) { /* ignore */ }
+    
+    this.notify('panelSize', this.state.panelSize);
+  }
+
+  setTab(tab: 'tasks' | 'timeline') {
+    this.state.activeTab = tab;
+    this.notify('activeTab', this.state.activeTab);
+  }
+
+  setDockPosition(pos: 'right' | 'bottom') {
+    this.state.dockPosition = pos;
+    this.notify('dockPosition', this.state.dockPosition);
+  }
+
+  setFilterText(text: string) {
+    this.state.filterText = text;
+    this.notify('filterText', this.state.filterText);
+  }
+
+  updateTask(task: TaskSnapshot) {
+    // Create a new Map to ensure reference change for listeners
+    const newTasks = new Map(this.state.tasks);
+    newTasks.set(task.id, task);
+    this.state.tasks = newTasks;
+    this.notify('tasks', this.state.tasks);
+
+    // If task object contains history (Task interface), update it too
+    if ('history' in task && Array.isArray((task as any).history)) {
+      const newHistory = new Map(this.state.history);
+      newHistory.set(task.id, (task as any).history);
+      this.state.history = newHistory;
+      this.notify('history', this.state.history);
+    }
+  }
+
+  selectTask(id: string | null) {
+    this.state.selectedTaskId = id;
+    this.notify('selectedTaskId', id);
+  }
+
+  addHistory(taskId: string, record: any) {
+    const list = [...(this.state.history.get(taskId) || [])];
+    list.push(record);
+    // Limit history size (e.g. 50)
+    if (list.length > 50) {
+      list.splice(0, list.length - 50);
+    }
+    
+    const newHistory = new Map(this.state.history);
+    newHistory.set(taskId, list);
+    this.state.history = newHistory;
+    this.notify('history', newHistory);
+  }
+
+  async triggerTask(id: string) {
+    if (this.scheduler) {
+      await this.scheduler.trigger(id);
+    }
+  }
+
+  stopTask(id: string) {
+    console.log('[DevToolsStore] stopTask:', id);
+    if (this.scheduler) {
+      this.scheduler.pause(id); // pause maps to stopTask in scheduler
+    }
+  }
+
+  startTask(id: string) {
+    console.log('[DevToolsStore] startTask:', id);
+    if (this.scheduler) {
+      this.scheduler.resume(id); // resume maps to startTask in scheduler
+    }
+  }
+
+  removeTask(id: string) {
+    if (this.scheduler) {
+      this.scheduler.remove(id);
+      // Optimistic update or wait for event? 
+      // Wait for 'task_removed' event usually best, but we can remove from state too.
+      const newTasks = new Map(this.state.tasks);
+      newTasks.delete(id);
+      this.state.tasks = newTasks;
+      this.notify('tasks', this.state.tasks);
+    }
+  }
+
+  setSchedulerRunning(running: boolean) {
+    this.state.schedulerRunning = running;
+    this.notify('schedulerRunning', running);
+  }
+}

package/src/ui/styles/theme.css.ts

@@ -0,0 +1,56 @@
+export const themeStyles = `
+  :host {
+    --hs-font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    --hs-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    --hs-font-size: 12px;
+    --hs-line-height: 1.5;
+    --hs-panel-width: 400px;
+    --hs-panel-height: 300px;
+    
+    /* Light Theme (Default) */
+    --hs-bg: #ffffff;
+    --hs-bg-secondary: #f3f4f6;
+    --hs-text: #1f2937;
+    --hs-text-secondary: #6b7280;
+    --hs-border: #e5e7eb;
+    --hs-primary: #3b82f6;
+    --hs-primary-hover: #2563eb;
+    --hs-danger: #ef4444;
+    --hs-danger-hover: #dc2626;
+    --hs-success: #10b981;
+    --hs-warning: #f59e0b;
+    
+    --hs-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+    --hs-radius: 6px;
+    --hs-header-height: 40px;
+    --hs-z-index: 9999;
+
+    /* Default display styles for the host itself */
+    background: var(--hs-bg);
+    color: var(--hs-text);
+    font-family: var(--hs-font-family);
+    font-size: var(--hs-font-size);
+    line-height: var(--hs-line-height);
+  }
+
+  :host([theme="dark"]) {
+    --hs-bg: #111827;
+    --hs-bg-secondary: #1f2937;
+    --hs-text: #f9fafb;
+    --hs-text-secondary: #9ca3af;
+    --hs-border: #374151;
+    --hs-primary: #60a5fa;
+    --hs-primary-hover: #3b82f6;
+    --hs-danger: #f87171;
+    --hs-danger-hover: #ef4444;
+    --hs-success: #34d399;
+    --hs-warning: #fbbf24;
+    
+    --hs-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.5), 0 2px 4px -1px rgba(0, 0, 0, 0.3);
+  }
+
+  :host {
+    background: var(--hs-bg);
+    color: var(--hs-text);
+  }
+`;

package/src/ui/styles.ts

@@ -0,0 +1,43 @@
+export const styles = `
+  #hyper-scheduler-debug-panel {
+    position: fixed;
+    bottom: 10px;
+    right: 10px;
+    width: 300px;
+    background: rgba(0, 0, 0, 0.8);
+    color: white;
+    font-family: monospace;
+    font-size: 12px;
+    z-index: 9999;
+    border-radius: 5px;
+    padding: 10px;
+    max-height: 300px;
+    overflow-y: auto;
+    box-shadow: 0 0 10px rgba(0,0,0,0.5);
+  }
+  .hs-header {
+    display: flex;
+    justify-content: space-between;
+    border-bottom: 1px solid #555;
+    padding-bottom: 5px;
+    margin-bottom: 5px;
+    font-weight: bold;
+  }
+  .hs-task-row {
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 3px;
+  }
+  .hs-status-running { color: #4caf50; }
+  .hs-status-stopped { color: #f44336; }
+  .hs-status-idle { color: #ffeb3b; }
+  .hs-status-error { color: #ff5722; }
+  .hs-toggle-btn {
+    background: none;
+    border: 1px solid #fff;
+    color: #fff;
+    cursor: pointer;
+    font-size: 10px;
+    margin-left: 5px;
+  }
+`;

package/src/utils/cron-lite.ts

@@ -0,0 +1,221 @@
+/**
+ * 轻量级 Cron 解析器
+ * 支持标准 5 位和 6 位 cron 表达式
+ * 格式: [秒] 分 时 日 月 周
+ */
+
+interface CronFields {
+  second: number[];
+  minute: number[];
+  hour: number[];
+  dayOfMonth: number[];
+  month: number[];
+  dayOfWeek: number[];
+}
+
+/**
+ * 解析单个 cron 字段
+ */
+function parseField(field: string, min: number, max: number): number[] {
+  const values: Set<number> = new Set();
+
+  // 处理 * (所有值)
+  if (field === '*') {
+    for (let i = min; i <= max; i++) {
+      values.add(i);
+    }
+    return Array.from(values).sort((a, b) => a - b);
+  }
+
+  // 处理逗号分隔的多个值: 1,3,5
+  const parts = field.split(',');
+  for (const part of parts) {
+    // 处理步长: */5 或 1-10/2
+    if (part.includes('/')) {
+      const [range, step] = part.split('/');
+      const stepNum = parseInt(step, 10);
+      
+      if (range === '*') {
+        for (let i = min; i <= max; i += stepNum) {
+          values.add(i);
+        }
+      } else if (range.includes('-')) {
+        const [start, end] = range.split('-').map(Number);
+        if (start < min || end > max) {
+          throw new Error(`Value out of range: ${start}-${end} (expected ${min}-${max})`);
+        }
+        for (let i = start; i <= end; i += stepNum) {
+          values.add(i);
+        }
+      } else {
+        const start = parseInt(range, 10);
+        if (start < min || start > max) {
+          throw new Error(`Value out of range: ${start} (expected ${min}-${max})`);
+        }
+        for (let i = start; i <= max; i += stepNum) {
+          values.add(i);
+        }
+      }
+    }
+    // 处理范围: 1-5
+    else if (part.includes('-')) {
+      const [start, end] = part.split('-').map(Number);
+      if (start < min || end > max) {
+        throw new Error(`Value out of range: ${start}-${end} (expected ${min}-${max})`);
+      }
+      for (let i = start; i <= end; i++) {
+        values.add(i);
+      }
+    }
+    // 处理单个值: 5
+    else {
+      const val = parseInt(part, 10);
+      if (val < min || val > max) {
+        throw new Error(`Value out of range: ${val} (expected ${min}-${max})`);
+      }
+      values.add(val);
+    }
+  }
+
+  return Array.from(values).sort((a, b) => a - b);
+}
+
+/**
+ * 解析 cron 表达式
+ */
+function parseCronExpression(expression: string): CronFields {
+  const parts = expression.trim().split(/\s+/);
+  
+  // 支持 5 位 (分 时 日 月 周) 和 6 位 (秒 分 时 日 月 周)
+  let second: number[], minute: number[], hour: number[], dayOfMonth: number[], month: number[], dayOfWeek: number[];
+  
+  if (parts.length === 5) {
+    // 5 位格式: 分 时 日 月 周
+    second = [0]; // 默认在 0 秒执行
+    [minute, hour, dayOfMonth, month, dayOfWeek] = [
+      parseField(parts[0], 0, 59),
+      parseField(parts[1], 0, 23),
+      parseField(parts[2], 1, 31),
+      parseField(parts[3], 1, 12),
+      parseField(parts[4], 0, 6),
+    ];
+  } else if (parts.length === 6) {
+    // 6 位格式: 秒 分 时 日 月 周
+    [second, minute, hour, dayOfMonth, month, dayOfWeek] = [
+      parseField(parts[0], 0, 59),
+      parseField(parts[1], 0, 59),
+      parseField(parts[2], 0, 23),
+      parseField(parts[3], 1, 31),
+      parseField(parts[4], 1, 12),
+      parseField(parts[5], 0, 6),
+    ];
+  } else {
+    throw new Error(`Invalid cron expression: expected 5 or 6 fields, got ${parts.length}`);
+  }
+
+  return { second, minute, hour, dayOfMonth, month, dayOfWeek };
+}
+
+/**
+ * 验证 cron 表达式
+ */
+export function validateCron(expression: string): void {
+  try {
+    parseCronExpression(expression);
+  } catch (err) {
+    throw new Error(`Invalid cron expression: ${expression}`);
+  }
+}
+
+/**
+ * 检查日期是否匹配 cron 字段
+ */
+function matchesCron(date: Date, fields: CronFields): boolean {
+  const second = date.getSeconds();
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1; // JS 月份从 0 开始
+  const dayOfWeek = date.getDay(); // 0 = 周日
+
+  return (
+    fields.second.includes(second) &&
+    fields.minute.includes(minute) &&
+    fields.hour.includes(hour) &&
+    fields.month.includes(month) &&
+    (fields.dayOfMonth.includes(dayOfMonth) || fields.dayOfWeek.includes(dayOfWeek))
+  );
+}
+
+/**
+ * 计算下一次运行时间
+ */
+export function getNextRun(expression: string, _timezone?: string): Date {
+  const fields = parseCronExpression(expression);
+  const now = new Date();
+  
+  // 从下一秒开始查找
+  let candidate = new Date(now.getTime() + 1000);
+  candidate.setMilliseconds(0);
+  
+  // 最多向前查找 4 年（避免无限循环）
+  const maxIterations = 4 * 365 * 24 * 60 * 60; // 4 年的秒数
+  let iterations = 0;
+  
+  while (iterations < maxIterations) {
+    if (matchesCron(candidate, fields)) {
+      return candidate;
+    }
+    
+    // 优化：跳到下一个可能的时间点
+    const second = candidate.getSeconds();
+    const minute = candidate.getMinutes();
+    const hour = candidate.getHours();
+    
+    // 如果秒不匹配，跳到下一个匹配的秒
+    if (!fields.second.includes(second)) {
+      const nextSecond = fields.second.find(s => s > second) ?? fields.second[0];
+      if (nextSecond > second) {
+        candidate.setSeconds(nextSecond);
+      } else {
+        candidate.setMinutes(minute + 1, nextSecond);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    
+    // 如果分钟不匹配，跳到下一个匹配的分钟
+    if (!fields.minute.includes(minute)) {
+      const nextMinute = fields.minute.find(m => m > minute) ?? fields.minute[0];
+      if (nextMinute > minute) {
+        candidate.setMinutes(nextMinute, fields.second[0]);
+      } else {
+        candidate.setHours(hour + 1, nextMinute, fields.second[0]);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    
+    // 如果小时不匹配，跳到下一个匹配的小时
+    if (!fields.hour.includes(hour)) {
+      const nextHour = fields.hour.find(h => h > hour) ?? fields.hour[0];
+      if (nextHour > hour) {
+        candidate.setHours(nextHour, fields.minute[0], fields.second[0]);
+      } else {
+        candidate.setDate(candidate.getDate() + 1);
+        candidate.setHours(nextHour, fields.minute[0], fields.second[0]);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    
+    // 如果都不匹配，跳到下一秒
+    candidate = new Date(candidate.getTime() + 1000);
+    iterations++;
+  }
+  
+  throw new Error(`Could not find next run time for cron expression: ${expression}`);
+}

package/src/utils/cron.ts

@@ -0,0 +1,20 @@
+import { validateCron as validate, getNextRun as getNext } from './cron-lite';
+
+/**
+ * 验证 Cron 表达式是否有效。
+ * @param cronExpression Cron 表达式
+ * @throws Error 如果表达式无效
+ */
+export function validateCron(cronExpression: string): void {
+  validate(cronExpression);
+}
+
+/**
+ * 根据 Cron 表达式计算下一次运行时间。
+ * @param cronExpression Cron 表达式
+ * @param timezone 可选的时区（暂不支持，保留接口兼容性）
+ * @returns 下一次运行的 Date 对象
+ */
+export function getNextRun(cronExpression: string, timezone?: string): Date {
+  return getNext(cronExpression, timezone);
+}

package/src/utils/id.ts

@@ -0,0 +1,10 @@
+/**
+ * 验证任务 ID 是否为非空字符串。
+ * @param id 待验证的 ID
+ * @throws Error 如果 ID 无效
+ */
+export function validateId(id: string): void {
+  if (!id || typeof id !== 'string' || id.trim() === '') {
+    throw new Error('Task ID must be a non-empty string.');
+  }
+}

package/src/utils/schedule.ts

@@ -0,0 +1,93 @@
+import { validateCron, getNextRun as getCronNextRun } from './cron-lite';
+
+export type ScheduleType = 'cron' | 'interval';
+
+export interface ParsedSchedule {
+  type: ScheduleType;
+  value: any | number;
+}
+
+/**
+ * 解析调度规则字符串，将其转换为 Cron 表达式对象或毫秒级间隔。
+ * 支持的间隔格式: "10s", "5m", "2h", "1d"。
+ * @param schedule 调度规则字符串
+ * @returns 解析后的调度对象
+ * @throws Error 如果字符串格式无效
+ */
+export function parseSchedule(schedule: string): ParsedSchedule {
+  // 1. 尝试作为间隔字符串解析
+  const intervalRegex = /^(\d+)(s|m|h|d)$/;
+  const match = schedule.match(intervalRegex);
+
+  if (match) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    let multiplier = 1000;
+
+    switch (unit) {
+      case 's':
+        multiplier = 1000;
+        break;
+      case 'm':
+        multiplier = 60 * 1000;
+        break;
+      case 'h':
+        multiplier = 60 * 60 * 1000;
+        break;
+      case 'd':
+        multiplier = 24 * 60 * 60 * 1000;
+        break;
+    }
+
+    return {
+      type: 'interval',
+      value: value * multiplier,
+    };
+  }
+
+  // 2. 尝试作为 Cron 表达式解析
+  try {
+    validateCron(schedule);
+    // 对于 Cron，我们返回原始字符串，以便后续根据上下文（如时区）重新解析
+    return {
+      type: 'cron',
+      value: schedule, 
+    };
+  } catch (err) {
+    // 解析失败
+    throw new Error(`无效的调度格式: "${schedule}". 必须是有效的 Cron 表达式或间隔字符串 (例如 "10s")。`);
+  }
+}
+
+/**
+ * 计算下一次运行时间。
+ * @param schedule 调度规则字符串或已解析的对象
+ * @param options 可选配置 (cron 的时区，interval 的上次运行时间)
+ * @returns 下一次运行的 Date 对象
+ */
+export function getNextRun(
+  schedule: string | ParsedSchedule,
+  options?: { timezone?: string; lastRun?: number }
+): Date {
+  let parsed: ParsedSchedule;
+
+  if (typeof schedule === 'string') {
+    parsed = parseSchedule(schedule);
+  } else {
+    parsed = schedule;
+  }
+
+  if (parsed.type === 'interval') {
+    const intervalMs = parsed.value as number;
+    const lastRun = options?.lastRun || Date.now();
+    return new Date(lastRun + intervalMs);
+  } else {
+    // Cron
+    const cronExpression = parsed.value as string;
+    try {
+      return getCronNextRun(cronExpression, options?.timezone);
+    } catch (err) {
+       throw new Error(`无法计算下一次 Cron 运行时间: ${cronExpression}`);
+    }
+  }
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />