@zk-tech/bedrock 0.0.1

package/dist/scheduler/index.d.cts

@@ -0,0 +1,57 @@
+import { I as IDisposable } from '../dispose-base-CAeXDpjg.cjs';
+
+declare enum PriorityLevel {
+    /** 立即执行任务的优先级 */
+    ImmediatePriority = 0,
+    /** 用户阻塞的优先级 */
+    UserBlockingPriority = 1,
+    /** 普通优先级 */
+    NormalPriority = 2,
+    /** 低优先级 */
+    LowPriority = 3,
+    /** 闲置优先级 */
+    IdlePriority = 4
+}
+interface IOptions {
+    delay?: number;
+    priorityLevel?: PriorityLevel;
+}
+interface IConfig {
+    fps?: number;
+    enableInputPending?: boolean;
+}
+interface IScheduledCallback {
+    /**
+     * @param chunkScheduler 分片调度器
+     * @param didUserCallbackTimeout 该callback执行时，是否已经超过了注册时设置的过期时间
+     * @param remainingTime 该callback执行时，当前调度loop中剩余的可用时间
+     */
+    (chunkScheduler: IChunkScheduler, didUserCallbackTimeout: boolean, remainingTime: number): void;
+}
+/**
+ * 分片调度器
+ * 支持将某个大的宏任务，拆成小的粒度执行
+ */
+interface IChunkScheduler {
+    /**
+     * 在分片结束状态下，启动一个新的任务进入调度器
+     */
+    execute: (callback: IScheduledCallback, options?: IOptions) => void;
+    /**
+     * 在分片结束状态下，延续当前任务（本质上是立即执行任务）
+     */
+    continueExecute: (callback: IScheduledCallback) => void;
+}
+
+interface ILvCallbackToken extends IDisposable {
+    /**
+     * 更新优先级
+     */
+    updatePriorityLevel: (priorityLevel: PriorityLevel) => void;
+}
+declare function lvSchedulerCallback(callback: IScheduledCallback, options?: IOptions): ILvCallbackToken;
+
+declare function lvSchedulerConfig(config: IConfig): void;
+declare function lvSchedulerResetConfig(): void;
+
+export { type IChunkScheduler, type ILvCallbackToken, type IOptions as ISchedulerCallbackOptions, PriorityLevel, lvSchedulerCallback, lvSchedulerConfig, lvSchedulerResetConfig };

package/dist/scheduler/index.d.ts

@@ -0,0 +1,57 @@
+import { I as IDisposable } from '../dispose-base-CAeXDpjg.js';
+
+declare enum PriorityLevel {
+    /** 立即执行任务的优先级 */
+    ImmediatePriority = 0,
+    /** 用户阻塞的优先级 */
+    UserBlockingPriority = 1,
+    /** 普通优先级 */
+    NormalPriority = 2,
+    /** 低优先级 */
+    LowPriority = 3,
+    /** 闲置优先级 */
+    IdlePriority = 4
+}
+interface IOptions {
+    delay?: number;
+    priorityLevel?: PriorityLevel;
+}
+interface IConfig {
+    fps?: number;
+    enableInputPending?: boolean;
+}
+interface IScheduledCallback {
+    /**
+     * @param chunkScheduler 分片调度器
+     * @param didUserCallbackTimeout 该callback执行时，是否已经超过了注册时设置的过期时间
+     * @param remainingTime 该callback执行时，当前调度loop中剩余的可用时间
+     */
+    (chunkScheduler: IChunkScheduler, didUserCallbackTimeout: boolean, remainingTime: number): void;
+}
+/**
+ * 分片调度器
+ * 支持将某个大的宏任务，拆成小的粒度执行
+ */
+interface IChunkScheduler {
+    /**
+     * 在分片结束状态下，启动一个新的任务进入调度器
+     */
+    execute: (callback: IScheduledCallback, options?: IOptions) => void;
+    /**
+     * 在分片结束状态下，延续当前任务（本质上是立即执行任务）
+     */
+    continueExecute: (callback: IScheduledCallback) => void;
+}
+
+interface ILvCallbackToken extends IDisposable {
+    /**
+     * 更新优先级
+     */
+    updatePriorityLevel: (priorityLevel: PriorityLevel) => void;
+}
+declare function lvSchedulerCallback(callback: IScheduledCallback, options?: IOptions): ILvCallbackToken;
+
+declare function lvSchedulerConfig(config: IConfig): void;
+declare function lvSchedulerResetConfig(): void;
+
+export { type IChunkScheduler, type ILvCallbackToken, type IOptions as ISchedulerCallbackOptions, PriorityLevel, lvSchedulerCallback, lvSchedulerConfig, lvSchedulerResetConfig };

package/dist/scheduler/index.js

@@ -0,0 +1,594 @@
+// src/scheduler/type.ts
+var PriorityLevel = /* @__PURE__ */ ((PriorityLevel2) => {
+  PriorityLevel2[PriorityLevel2["ImmediatePriority"] = 0] = "ImmediatePriority";
+  PriorityLevel2[PriorityLevel2["UserBlockingPriority"] = 1] = "UserBlockingPriority";
+  PriorityLevel2[PriorityLevel2["NormalPriority"] = 2] = "NormalPriority";
+  PriorityLevel2[PriorityLevel2["LowPriority"] = 3] = "LowPriority";
+  PriorityLevel2[PriorityLevel2["IdlePriority"] = 4] = "IdlePriority";
+  return PriorityLevel2;
+})(PriorityLevel || {});
+
+// src/assert/assert.ts
+function abort(reason) {
+  throw new Error(`lvAssert(${reason})`);
+}
+function lvAssert(expr, reason) {
+  if (!expr) {
+    abort(reason ?? "#expr is false");
+  }
+}
+
+// src/scheduler/core/task.ts
+var Task = class {
+  constructor(callback, _startTime, _expirationTime) {
+    this._startTime = _startTime;
+    this._expirationTime = _expirationTime;
+    this._sortIndex = -1;
+    this._callback = callback;
+  }
+  getCallback() {
+    return this._callback;
+  }
+  setCallback(callback) {
+    lvAssert(this._callback === void 0, "cant overlay callback.");
+    this._callback = callback;
+  }
+  clearCallback() {
+    this._callback = void 0;
+  }
+  getStartTime() {
+    return this._startTime;
+  }
+  setStartTime(startTime) {
+    this._startTime = startTime;
+  }
+  getExpirationTime() {
+    return this._expirationTime;
+  }
+  setExpirationTime(expirationTime) {
+    this._expirationTime = expirationTime;
+  }
+  setSortIndex(index) {
+    this._sortIndex = index;
+  }
+  getSortIndex() {
+    return this._sortIndex;
+  }
+};
+
+// src/scheduler/core/utils.ts
+var maxSigned31BitInt = 1073741823;
+var IMMEDIATE_PRIORITY_TIMEOUT = -1;
+var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5e3;
+var LOW_PRIORITY_TIMEOUT = 1e4;
+var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt;
+function getCurrentTime() {
+  return Date.now();
+}
+function getTimeout(priorityLevel = 2 /* NormalPriority */) {
+  switch (priorityLevel) {
+    case 0 /* ImmediatePriority */:
+      return IMMEDIATE_PRIORITY_TIMEOUT;
+    case 1 /* UserBlockingPriority */:
+      return USER_BLOCKING_PRIORITY_TIMEOUT;
+    case 4 /* IdlePriority */:
+      return IDLE_PRIORITY_TIMEOUT;
+    case 3 /* LowPriority */:
+      return LOW_PRIORITY_TIMEOUT;
+    case 2 /* NormalPriority */:
+    default:
+      return NORMAL_PRIORITY_TIMEOUT;
+  }
+}
+function makeTask(callback, options = {}) {
+  const currentTime = getCurrentTime();
+  const delay = options.delay ?? 0;
+  const timeout = getTimeout(options.priorityLevel);
+  const startTime = delay + currentTime;
+  const expirationTime = startTime + timeout;
+  const newTask = new Task(callback, startTime, expirationTime);
+  return newTask;
+}
+
+// src/scheduler/core/chunk-scheduler.ts
+var ChunkScheduler = class {
+  constructor(_task, _scheduler) {
+    this._task = _task;
+    this._scheduler = _scheduler;
+    this._needContinue = false;
+  }
+  get needContinue() {
+    return this._needContinue;
+  }
+  continueExecute(callback) {
+    this._needContinue = true;
+    this._task.setCallback(callback);
+  }
+  execute(callback, options = {}) {
+    const newTask = makeTask(callback, options);
+    this._scheduler.addTask(newTask);
+  }
+};
+
+// src/scheduler/core/actuator.ts
+var Actuator = class {
+  constructor(_taskQueue, _scheduler) {
+    this._taskQueue = _taskQueue;
+    this._scheduler = _scheduler;
+  }
+  workLoop(hasTimeRemaining, initialTime, deadline) {
+    let currentTime = initialTime;
+    this._taskQueue.advance(currentTime);
+    let currentTask = this._taskQueue.waitingTasks.peek();
+    while (currentTask !== null) {
+      if (currentTask.getExpirationTime() > currentTime && (!hasTimeRemaining || this._scheduler.shouldYieldToHost(deadline))) {
+        break;
+      }
+      if (currentTask.getCallback() === void 0) {
+        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;
+  }
+};
+
+// src/structure/min-heap.ts
+var MinHeap = class {
+  constructor(compareFunction) {
+    this._heap = [];
+    if (compareFunction) {
+      this._compare = compareFunction;
+    } else {
+      this._compare = (a, b) => {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+      };
+    }
+  }
+  insert(value) {
+    this._heap.push(value);
+    this._siftUp();
+  }
+  peek() {
+    return this._heap.length > 0 ? this._heap[0] : null;
+  }
+  remove() {
+    if (this._heap.length === 0) return null;
+    if (this._heap.length === 1) return this._heap.pop();
+    const item = this._heap[0];
+    this._heap[0] = this._heap.pop();
+    this._siftDown();
+    return item;
+  }
+  size() {
+    return this._heap.length;
+  }
+  clear() {
+    this._heap.length = 0;
+  }
+  _getLeftChildIndex(parentIndex) {
+    return 2 * parentIndex + 1;
+  }
+  _getRightChildIndex(parentIndex) {
+    return 2 * parentIndex + 2;
+  }
+  _getParentIndex(childIndex) {
+    return Math.floor((childIndex - 1) / 2);
+  }
+  _swap(indexOne, indexTwo) {
+    [this._heap[indexOne], this._heap[indexTwo]] = [this._heap[indexTwo], this._heap[indexOne]];
+  }
+  _siftUp() {
+    let index = this._heap.length - 1;
+    while (index > 0 && this._compare(this._heap[this._getParentIndex(index)], this._heap[index]) > 0) {
+      const parentIndex = this._getParentIndex(index);
+      this._swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+  _siftDown() {
+    let index = 0;
+    let smallerChildIndex = this._getLeftChildIndex(index);
+    while (smallerChildIndex < this._heap.length) {
+      const rightChildIndex = this._getRightChildIndex(index);
+      if (rightChildIndex < this._heap.length && this._compare(this._heap[rightChildIndex], this._heap[smallerChildIndex]) < 0) {
+        smallerChildIndex = rightChildIndex;
+      }
+      if (this._compare(this._heap[index], this._heap[smallerChildIndex]) <= 0) {
+        break;
+      }
+      this._swap(index, smallerChildIndex);
+      index = smallerChildIndex;
+      smallerChildIndex = this._getLeftChildIndex(index);
+    }
+  }
+};
+
+// src/scheduler/core/task-queue.ts
+function compare(lhs, rhs) {
+  return lhs.getSortIndex() - rhs.getSortIndex();
+}
+var TaskQueue = class {
+  constructor() {
+    // 延时任务
+    this._timerTasks = new MinHeap(compare);
+    // 等待执行的任务
+    this._waitingTasks = new MinHeap(compare);
+  }
+  get timerTasks() {
+    return this._timerTasks;
+  }
+  get waitingTasks() {
+    return this._waitingTasks;
+  }
+  advance(currentTime) {
+    let task = this._timerTasks.peek();
+    while (task !== null) {
+      if (task.getCallback() === null) {
+        this._timerTasks.remove();
+      } else if (task.getStartTime() <= currentTime) {
+        this._timerTasks.remove();
+        task.setSortIndex(task.getExpirationTime());
+        this._waitingTasks.insert(task);
+      } else {
+        return;
+      }
+      task = this._timerTasks.peek();
+    }
+  }
+};
+
+// src/scheduler/executor/abstract-executor.ts
+var AbstractExecutor = class {
+  constructor() {
+    this._timeoutId = -1;
+    this._deadline = 0;
+    this._yieldInterval = 16;
+  }
+  get deadline() {
+    return this._deadline;
+  }
+  setFrameRate(fps) {
+    lvAssert(fps > 0 && fps <= 125);
+    this._yieldInterval = Math.floor(1e3 / fps);
+  }
+  resetFrameRate() {
+    this._yieldInterval = 16;
+  }
+  requestHostTimeout(fn, delayMs) {
+    lvAssert(this._timeoutId === -1, "has request host timeout.");
+    clearTimeout(this._timeoutId);
+    this._timeoutId = setTimeout(() => {
+      this._timeoutId = -1;
+      fn();
+    }, delayMs);
+  }
+  cancelHostTimeout() {
+    clearTimeout(this._timeoutId);
+    this._timeoutId = -1;
+  }
+};
+
+// src/scheduler/executor/idle-callback-executor.ts
+var IdleCallbackExecutor = class extends AbstractExecutor {
+  constructor() {
+    super();
+    this._flushCallback = () => {
+      if (!this._scheduledCallback) {
+        return;
+      }
+      const currentTime = getCurrentTime();
+      const deadline = currentTime + this._yieldInterval;
+      try {
+        const hasMoreWork = this._scheduledCallback(true, currentTime, deadline);
+        if (!hasMoreWork) {
+          this._scheduledCallback = void 0;
+          this._disposable = void 0;
+        } else {
+          this._disposable = this._runWhenIdle(this._flushCallback);
+        }
+      } catch (err) {
+        this._disposable = this._runWhenIdle(this._flushCallback);
+        throw err;
+      }
+    };
+    if (typeof requestIdleCallback !== "function" || typeof cancelIdleCallback !== "function") {
+      this._runWhenIdle = (runner) => {
+        let disposed = false;
+        setTimeout(() => {
+          if (disposed) {
+            return;
+          }
+          const end = Date.now() + 15;
+          runner(
+            Object.freeze({
+              didTimeout: true,
+              timeRemaining() {
+                return Math.max(0, end - Date.now());
+              }
+            })
+          );
+        });
+        return {
+          dispose() {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+          }
+        };
+      };
+    } else {
+      this._runWhenIdle = (runner, timeout) => {
+        const handle = requestIdleCallback(
+          runner,
+          typeof timeout === "number" ? { timeout } : void 0
+        );
+        let disposed = false;
+        return {
+          dispose() {
+            if (disposed) {
+              return;
+            }
+            disposed = true;
+            cancelIdleCallback(handle);
+          }
+        };
+      };
+    }
+  }
+  requestHostCallback(fn) {
+    this._scheduledCallback = fn;
+    if (!this._disposable) {
+      this._disposable = this._runWhenIdle(this._flushCallback);
+    }
+  }
+  cancelHostCallback() {
+    this._disposable?.dispose();
+    this._scheduledCallback = void 0;
+    this._disposable = void 0;
+  }
+};
+
+// src/scheduler/executor/post-message-executor.ts
+var PostMessageExecutor = class extends AbstractExecutor {
+  constructor() {
+    super();
+    this._isMessageLoopRunning = false;
+    this._channel = new MessageChannel();
+    this._flushCallback = () => {
+      if (!this._scheduledCallback) {
+        this._isMessageLoopRunning = false;
+        return;
+      }
+      const currentTime = getCurrentTime();
+      const deadline = currentTime + this._yieldInterval;
+      try {
+        const hasMoreWork = this._scheduledCallback(true, currentTime, deadline);
+        if (!hasMoreWork) {
+          this._isMessageLoopRunning = false;
+          this._scheduledCallback = void 0;
+        } else {
+          this._channel.port2.postMessage(null);
+        }
+      } catch (err) {
+        this._channel.port2.postMessage(null);
+        throw err;
+      }
+    };
+    this._channel.port1.onmessage = () => {
+      this._flushCallback();
+    };
+  }
+  requestHostCallback(fn) {
+    this._scheduledCallback = fn;
+    if (!this._isMessageLoopRunning) {
+      this._isMessageLoopRunning = true;
+      this._channel.port2.postMessage(null);
+    }
+  }
+  cancelHostCallback() {
+    this._scheduledCallback = void 0;
+  }
+};
+
+// src/scheduler/executor/make-executor.ts
+function makeExecutor() {
+  try {
+    if (global.window) {
+      return new PostMessageExecutor();
+    }
+  } catch (e) {
+  }
+  return new IdleCallbackExecutor();
+}
+
+// src/scheduler/core/scheduler.ts
+var Scheduler = class {
+  constructor() {
+    this._isHostTimeoutScheduled = false;
+    this._isHostCallbackScheduled = false;
+    this._isWorking = false;
+    this._enableInputPending = true;
+    this._executor = makeExecutor();
+    this._taskQueue = new TaskQueue();
+    this._actuator = new Actuator(this._taskQueue, this);
+    /**
+     * 是否需要让出事件给宿主
+     */
+    this.shouldYieldToHost = (() => {
+      try {
+        if (global.navigator?.scheduling?.isInputPending !== void 0) {
+          const { scheduling } = global.navigator;
+          return (deadline) => {
+            if (this._enableInputPending && scheduling.isInputPending()) {
+              return true;
+            }
+            return getCurrentTime() >= deadline;
+          };
+        }
+      } catch (e) {
+      }
+      return (deadline) => {
+        return getCurrentTime() >= deadline;
+      };
+    })();
+    this._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);
+    };
+    this._handleHostCallback = (hasTimeRemaining, initialTime, deadline) => {
+      this._isHostCallbackScheduled = false;
+      if (this._isHostTimeoutScheduled) {
+        this._isHostTimeoutScheduled = false;
+        this._executor.cancelHostTimeout();
+      }
+      this._isWorking = true;
+      try {
+        return this._actuator.workLoop(hasTimeRemaining, initialTime, deadline);
+      } finally {
+        this._isWorking = false;
+      }
+    };
+  }
+  get taskQueue() {
+    return this._taskQueue;
+  }
+  get executor() {
+    return this._executor;
+  }
+  /**
+   * 设置是否开启InputPending
+   */
+  setEnableInputPending(val) {
+    this._enableInputPending = val;
+  }
+  /**
+   * 调度器中添加任务
+   */
+  addTask(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()) {
+        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);
+      }
+    }
+  }
+  /**
+   * 尝试启动异步任务调度
+   */
+  requestHostTimeout(currentTime) {
+    this._requestHostTimeout(currentTime);
+  }
+  _requestHostTimeout(currentTime) {
+    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);
+    }
+  }
+};
+var scheduler;
+function getScheduler() {
+  if (!scheduler) {
+    scheduler = new Scheduler();
+  }
+  return scheduler;
+}
+
+// src/scheduler/callback-token.ts
+var CallbackToken = class {
+  constructor(_task) {
+    this._task = _task;
+  }
+  dispose() {
+    this._task.clearCallback();
+  }
+  updatePriorityLevel(priorityLevel) {
+    const callback = this._task.getCallback();
+    if (!callback) {
+      return;
+    }
+    this._task.clearCallback();
+    const newTask = makeTask(callback, {
+      priorityLevel
+    });
+    const startTime = this._task.getStartTime();
+    const timeout = getTimeout(priorityLevel);
+    const expirationTime = startTime + timeout;
+    newTask.setStartTime(startTime);
+    newTask.setExpirationTime(expirationTime);
+    getScheduler().addTask(newTask);
+    this._task = newTask;
+  }
+};
+
+// src/scheduler/lv-scheduler-callback.ts
+function lvSchedulerCallback(callback, options = {}) {
+  const newTask = makeTask(callback, options);
+  getScheduler().addTask(newTask);
+  return new CallbackToken(newTask);
+}
+
+// src/scheduler/lv-scheduler-config.ts
+function lvSchedulerConfig(config) {
+  if (config.fps !== void 0) {
+    getScheduler().executor.setFrameRate(config.fps);
+  }
+  if (config.enableInputPending !== void 0) {
+    getScheduler().setEnableInputPending(config.enableInputPending);
+  }
+}
+function lvSchedulerResetConfig() {
+  getScheduler().executor.resetFrameRate();
+  getScheduler().setEnableInputPending(true);
+}
+
+export { PriorityLevel, lvSchedulerCallback, lvSchedulerConfig, lvSchedulerResetConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map