@zk-tech/bedrock 0.0.1 → 0.0.2

package/src/scheduler/core/actuator.ts

@@ -1,58 +0,0 @@
-import { ChunkScheduler } from './chunk-scheduler';
-import type { Scheduler } from './scheduler';
-import type { TaskQueue } from './task-queue';
-import { getCurrentTime } from './utils';
-
-export class Actuator {
-  constructor(
-    private readonly _taskQueue: TaskQueue,
-    private readonly _scheduler: Scheduler,
-  ) {}
-
-  workLoop(hasTimeRemaining: boolean, initialTime: number, deadline: number): boolean {
-    let currentTime = initialTime;
-    this._taskQueue.advance(currentTime);
-    let currentTask = this._taskQueue.waitingTasks.peek();
-
-    while (currentTask !== null) {
-      // 暂停执行需要满足的条件（1，2同时满足）
-      // 1. 不能超时了，超时的任务一定会执行
-      // 2. 没有剩余时间了，或者调度器认为需要释放资源
-      if (
-        currentTask.getExpirationTime() > currentTime &&
-        (!hasTimeRemaining || this._scheduler.shouldYieldToHost(deadline))
-      ) {
-        break;
-      }
-
-      if (currentTask.getCallback() === undefined) {
-        // 任务取消了
-        this._taskQueue.waitingTasks.remove();
-      } else {
-        const callback = currentTask.getCallback()!;
-        const didUserCallbackTimeout = currentTask.getExpirationTime() <= currentTime;
-        const remainingTime = deadline - currentTime;
-        currentTask.clearCallback();
-
-        const chunkInvoker = new ChunkScheduler(currentTask, this._scheduler);
-        callback(chunkInvoker, didUserCallbackTimeout, remainingTime);
-
-        if (!chunkInvoker.needContinue) {
-          this._taskQueue.waitingTasks.remove();
-        }
-
-        currentTime = getCurrentTime();
-        this._taskQueue.advance(currentTime);
-      }
-
-      currentTask = this._taskQueue.waitingTasks.peek();
-    }
-
-    if (currentTask !== null) {
-      return true;
-    }
-    // 如果等待队列结束了，要启动异步调度了
-    this._scheduler.requestHostTimeout(currentTime);
-    return false;
-  }
-}

package/src/scheduler/core/chunk-scheduler.test.ts

@@ -1,54 +0,0 @@
-import { ChunkScheduler } from './chunk-scheduler';
-import { getScheduler } from './scheduler';
-import { Task } from './task';
-
-const scheduler = getScheduler();
-
-describe('ChunkScheduler', () => {
-  beforeEach(() => {
-    scheduler.taskQueue.waitingTasks.clear();
-    scheduler.taskQueue.timerTasks.clear();
-  });
-
-  // 续上task执行
-  test('continueExecute1', () => {
-    const fn1 = vi.fn();
-    const fn2 = vi.fn();
-    const task = new Task(fn1, 10, 30);
-    scheduler.taskQueue.waitingTasks.insert(task);
-    task.clearCallback();
-
-    const chunkScheduler = new ChunkScheduler(task, scheduler);
-    chunkScheduler.continueExecute(fn2);
-
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
-    expect(task.getCallback()).toBe(fn2);
-  });
-
-  // task没有执行完，就进行continue，报错
-  test('continueExecute2', () => {
-    const fn1 = vi.fn();
-    const fn2 = vi.fn();
-    const task = new Task(fn1, 10, 30);
-    scheduler.taskQueue.waitingTasks.insert(task);
-
-    const chunkScheduler = new ChunkScheduler(task, scheduler);
-    expect(() => {
-      chunkScheduler.continueExecute(fn2);
-    }).toThrowError();
-  });
-
-  // task正常执行
-  test('execute', () => {
-    const fn1 = vi.fn();
-    const fn2 = vi.fn();
-    const task = new Task(fn1, 10, 30);
-    scheduler.taskQueue.waitingTasks.insert(task);
-    task.clearCallback();
-
-    const chunkScheduler = new ChunkScheduler(task, scheduler);
-    chunkScheduler.execute(fn2);
-
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
-  });
-});

package/src/scheduler/core/chunk-scheduler.ts

@@ -1,28 +0,0 @@
-import type { Scheduler } from './scheduler';
-import { Task } from './task';
-import { type IChunkScheduler, type IScheduledCallback, type IOptions } from '../type';
-import { makeTask } from './utils';
-
-export class ChunkScheduler implements IChunkScheduler {
-  private _needContinue: boolean = false;
-
-  constructor(
-    private readonly _task: Task,
-    private readonly _scheduler: Scheduler,
-  ) {}
-
-  get needContinue() {
-    return this._needContinue;
-  }
-
-  continueExecute(callback: IScheduledCallback) {
-    this._needContinue = true;
-    // 该task还需要延续执行，更新一些信息
-    this._task.setCallback(callback);
-  }
-
-  execute(callback: IScheduledCallback, options: IOptions = {}) {
-    const newTask = makeTask(callback, options);
-    this._scheduler.addTask(newTask);
-  }
-}

package/src/scheduler/core/node_modules/.vitest/results.json

@@ -1 +0,0 @@
-{"version":"1.0.1","results":[[":task.test.ts",{"duration":0,"failed":true}],[":task-queue.test.ts",{"duration":0,"failed":true}],[":actuator.test.ts",{"duration":0,"failed":true}],[":actuator-args.test.ts",{"duration":0,"failed":true}],[":scheduler.test.ts",{"duration":0,"failed":true}],[":chunk-scheduler.test.ts",{"duration":0,"failed":true}]]}

package/src/scheduler/core/scheduler.test.ts

@@ -1,328 +0,0 @@
-/* eslint-disable max-lines-per-function */
-import { Task } from './task';
-import { getScheduler } from './scheduler';
-import { getCurrentTime } from './utils';
-
-const scheduler = getScheduler();
-
-function pending(timeMs: number) {
-  const now = getCurrentTime();
-  vi.useRealTimers();
-  const fakeNow = now + timeMs;
-  vi.useFakeTimers({ now: fakeNow });
-}
-
-describe('Scheduler', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    scheduler.taskQueue.waitingTasks.clear();
-    scheduler.taskQueue.timerTasks.clear();
-  });
-
-  // 添加单个及时任务
-  it('add callback task1', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    scheduler.addTask(task);
-
-    vi.advanceTimersByTime(10);
-
-    expect(data).toStrictEqual([1]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个及时任务，顺序不变
-  it('add callback task2', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time,
-      time + 15,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-
-    vi.advanceTimersByTime(10);
-
-    expect(data).toStrictEqual([1, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个及时任务，触发插队
-  it('add callback task3', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    scheduler.addTask(task1);
-
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time,
-      time + 5,
-    );
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-
-    vi.advanceTimersByTime(10);
-
-    expect(data).toStrictEqual([2, 1]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个及时任务，分两次执行
-  it('add callback task4', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        pending(20);
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time,
-      time + 30,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-
-    vi.advanceTimersByTime(5);
-
-    expect(data).toStrictEqual([1]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-
-    vi.advanceTimersByTime(10);
-
-    expect(data).toStrictEqual([1, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加单个延迟任务
-  it('add timeout task1', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time + 100,
-      time + 20,
-    );
-    scheduler.addTask(task);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
-
-    vi.advanceTimersByTime(10);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
-    expect(data).toStrictEqual([]);
-
-    vi.advanceTimersByTime(200);
-    expect(data).toStrictEqual([1]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个延迟任务
-  it('add timeout task2', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time + 10,
-      time + 20,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time + 10,
-      time + 20,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
-
-    vi.advanceTimersByTime(100);
-
-    expect(data).toStrictEqual([1, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个延迟任务，顺序变化
-  it('add timeout task3', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time + 10,
-      time + 20,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time + 10,
-      time + 10,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
-
-    vi.advanceTimersByTime(100);
-
-    expect(data).toStrictEqual([2, 1]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加多个延迟任务，分两次执行
-  it('add timeout task4', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time + 10,
-      time + 20,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time + 100,
-      time + 120,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(2);
-
-    vi.advanceTimersByTime(30);
-    expect(data).toStrictEqual([1]);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
-
-    vi.advanceTimersByTime(200);
-
-    expect(data).toStrictEqual([1, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加及时任务与延迟任务
-  it('add mix task1', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time + 10,
-      time + 20,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(1);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
-
-    vi.advanceTimersByTime(50);
-
-    expect(data).toStrictEqual([1, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-
-  // 添加及时任务与延迟任务，延迟任务会插队
-  it('add mix task2', () => {
-    const data: number[] = [];
-    const time = getCurrentTime();
-    const task1 = new Task(
-      vi.fn(() => {
-        pending(20);
-        data.push(1);
-      }),
-      time,
-      time + 10,
-    );
-    const task2 = new Task(
-      vi.fn(() => {
-        data.push(2);
-      }),
-      time,
-      time + 30,
-    );
-    const task3 = new Task(
-      vi.fn(() => {
-        data.push(3);
-      }),
-      time + 10,
-      time + 20,
-    );
-    scheduler.addTask(task1);
-    scheduler.addTask(task2);
-    scheduler.addTask(task3);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(2);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(1);
-
-    // 因为要触发两次scheduler的requestHostCallback，用fakeTime就得这么写
-    vi.advanceTimersByTime(50);
-    vi.advanceTimersByTime(0);
-
-    expect(data).toStrictEqual([1, 3, 2]);
-    expect(scheduler.taskQueue.waitingTasks.size()).toBe(0);
-    expect(scheduler.taskQueue.timerTasks.size()).toBe(0);
-  });
-});

package/src/scheduler/core/scheduler.ts

@@ -1,172 +0,0 @@
-import { Actuator } from './actuator';
-import { TaskQueue } from './task-queue';
-import { Task } from './task';
-import { getCurrentTime } from './utils';
-import { lvAssert } from '../../assert';
-import type { IExecutor } from '../executor/executor.interface';
-import { makeExecutor } from '../executor/make-executor';
-
-declare const global: {
-  navigator:
-    | (Navigator & {
-        scheduling?: {
-          isInputPending?: () => boolean;
-        };
-      })
-    | undefined;
-};
-
-/**
- * 调度器
- * 负责推动任务的执行，闲时和非闲时的处理
- */
-export class Scheduler {
-  private _isHostTimeoutScheduled: boolean = false;
-  private _isHostCallbackScheduled: boolean = false;
-  private _isWorking: boolean = false;
-  private _enableInputPending: boolean = true;
-  private readonly _executor: IExecutor = makeExecutor();
-
-  private readonly _taskQueue: TaskQueue = new TaskQueue();
-  private readonly _actuator: Actuator = new Actuator(this._taskQueue, this);
-
-  public get taskQueue() {
-    return this._taskQueue;
-  }
-
-  public get executor() {
-    return this._executor;
-  }
-
-  /**
-   * 是否需要让出事件给宿主
-   */
-  public shouldYieldToHost = (() => {
-    try {
-      if (global.navigator?.scheduling?.isInputPending !== undefined) {
-        const { scheduling } = global.navigator;
-        return (deadline: number) => {
-          if (this._enableInputPending && scheduling.isInputPending!()) {
-            // 当遇到inputPending时，认为需要释放时间片
-            return true;
-          }
-          return getCurrentTime() >= deadline;
-        };
-      }
-    } catch (e) {
-      // ...
-    }
-    return (deadline: number) => {
-      // 如果不考虑isInputPending的情况下
-      // 当前时间已经超了，认为需要释放时间片，返回true
-      return getCurrentTime() >= deadline;
-    };
-  })();
-
-  /**
-   * 设置是否开启InputPending
-   */
-  public setEnableInputPending(val: boolean) {
-    this._enableInputPending = val;
-  }
-
-  /**
-   * 调度器中添加任务
-   */
-  public addTask(task: Task) {
-    const currentTime = getCurrentTime();
-    if (task.getStartTime() > currentTime) {
-      task.setSortIndex(task.getStartTime());
-      this._taskQueue.timerTasks.insert(task);
-
-      // 如果等待队列为空，延迟队列队首是该任务，进行延迟调度
-      if (this._taskQueue.waitingTasks.peek() === null && task === this._taskQueue.timerTasks.peek()) {
-        // 如果之前已经有延迟调度了，取消再重新延迟调度
-        // 有可能之前延迟10s
-        // 最新的任务只需要延迟3s
-        if (this._isHostTimeoutScheduled) {
-          this._executor.cancelHostTimeout();
-        } else {
-          this._isHostTimeoutScheduled = true;
-        }
-        this._executor.requestHostTimeout(this._handleHostTimeout, task.getStartTime() - currentTime);
-      }
-    } else {
-      task.setSortIndex(task.getExpirationTime());
-      this._taskQueue.waitingTasks.insert(task);
-
-      // 如果当前没有在及时调度或者执行中，进行及时调度
-      if (!this._isHostCallbackScheduled && !this._isWorking) {
-        this._isHostCallbackScheduled = true;
-        this._executor.requestHostCallback(this._handleHostCallback);
-      }
-    }
-  }
-
-  /**
-   * 尝试启动异步任务调度
-   */
-  public requestHostTimeout(currentTime: number) {
-    this._requestHostTimeout(currentTime);
-  }
-
-  private readonly _handleHostTimeout = () => {
-    this._isHostTimeoutScheduled = false;
-    const currentTime = getCurrentTime();
-    this._taskQueue.advance(currentTime);
-
-    if (this._isHostCallbackScheduled) {
-      return;
-    }
-
-    if (this._taskQueue.waitingTasks.peek() !== null) {
-      this._isHostCallbackScheduled = true;
-      this._executor.requestHostCallback(this._handleHostCallback);
-      return;
-    }
-
-    this._requestHostTimeout(currentTime);
-  };
-
-  private readonly _handleHostCallback = (
-    hasTimeRemaining: boolean,
-    initialTime: number,
-    deadline: number,
-  ) => {
-    this._isHostCallbackScheduled = false;
-
-    if (this._isHostTimeoutScheduled) {
-      // 如果有异步任务调度中，直接取消，应该没必要了
-      this._isHostTimeoutScheduled = false;
-      this._executor.cancelHostTimeout();
-    }
-
-    // 进入work状态
-    this._isWorking = true;
-    try {
-      return this._actuator.workLoop(hasTimeRemaining, initialTime, deadline);
-    } finally {
-      this._isWorking = false;
-    }
-  };
-
-  private _requestHostTimeout(currentTime: number) {
-    // 调用该函数时，一定不在及时调度和异步调度的状态中
-    lvAssert(!this._isHostCallbackScheduled);
-    lvAssert(!this._isHostTimeoutScheduled);
-    const firstTimerTask = this._taskQueue.timerTasks.peek();
-    if (firstTimerTask !== null) {
-      this._isHostTimeoutScheduled = true;
-      this._executor.requestHostTimeout(this._handleHostTimeout, firstTimerTask.getStartTime() - currentTime);
-    }
-  }
-}
-
-// 考虑到外界复杂的场景，不编译时构造，按需构造
-let scheduler: Scheduler | undefined;
-export function getScheduler() {
-  if (!scheduler) {
-    scheduler = new Scheduler();
-  }
-  return scheduler;
-}