@vobs/queue 1.1.0 → 1.2.1

package/dist/index.cjs

@@ -0,0 +1,615 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+function onDispose(cleanup) {
+  throw new Error("Vobs: onDispose \u5FC5\u987B\u5728 Owner \u4F5C\u7528\u57DF\u5185\u8C03\u7528");
+}
+__name(onDispose, "onDispose");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function trackDependency(dependency) {
+  return;
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+
+// packages/vobs/src/context.ts
+var ownerProviders = /* @__PURE__ */ new WeakMap();
+function inject(key, fallback) {
+  const owner = getCurrentOwner();
+  const value = owner ? injectFromOwner(owner, key) : void 0;
+  return value === void 0 ? fallback : value;
+}
+__name(inject, "inject");
+function injectFromOwner(owner, key) {
+  let current = owner;
+  while (current) {
+    const providers = ownerProviders.get(current);
+    if (providers?.has(key)) return providers.get(key);
+    current = current.parent;
+  }
+  return void 0;
+}
+__name(injectFromOwner, "injectFromOwner");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/queue/src/index.ts
+var _QueueError = class _QueueError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "QueueError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+__name(_QueueError, "QueueError");
+var QueueError = _QueueError;
+var QUEUE_KEY = createInjectionKey("vobs.queue");
+var PRIORITIES = {
+  low: 0,
+  normal: 1,
+  high: 2,
+  critical: 3
+};
+function createTaskQueue(options = {}) {
+  const concurrency = resolveConcurrency(options);
+  const tasks = state([]);
+  const pending = state(0);
+  const processing = state(0);
+  const completed = state(0);
+  const failed = state(0);
+  const total = state(0);
+  const paused = state(false);
+  const queue = [];
+  const ownedTasks = /* @__PURE__ */ new Set();
+  let sequence = 0;
+  let active = 0;
+  let nextId = 0;
+  let disposed = false;
+  const context = {
+    pending,
+    processing,
+    completed,
+    failed,
+    total,
+    paused,
+    tasks,
+    add(fn, taskOptions = {}) {
+      ensureActive();
+      if (typeof fn !== "function") {
+        throw new QueueError("INVALID_TASK", "Vobs Queue: task \u5FC5\u987B\u662F\u51FD\u6570");
+      }
+      const id = taskOptions.id ?? options.idFactory?.() ?? `task-${++nextId}`;
+      if (typeof id !== "string" || id.trim() === "") {
+        throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: task id \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (tasks.value.some((task2) => task2.id === id)) {
+        throw new QueueError("INVALID_QUEUE_OPTIONS", `Vobs Queue: \u5DF2\u5B58\u5728\u4EFB\u52A1 ${id}`);
+      }
+      const task = createTask(fn, id, taskOptions);
+      ownedTasks.add(task);
+      tasks.value = Object.freeze([...tasks.value, task]);
+      queue.push(task);
+      sortQueue();
+      refreshStats();
+      drain();
+      return task;
+    },
+    pause() {
+      ensureActive();
+      paused.value = true;
+    },
+    resume() {
+      ensureActive();
+      if (!paused.value) return;
+      paused.value = false;
+      drain();
+    },
+    clear() {
+      ensureActive();
+      for (const task of [...queue]) task.cancel();
+      queue.length = 0;
+      refreshStats();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const task of [...ownedTasks]) task.cancel();
+      queue.length = 0;
+      for (const task of ownedTasks) task.dispose();
+      ownedTasks.clear();
+      tasks.value = Object.freeze([]);
+      pending.dispose();
+      processing.dispose();
+      completed.dispose();
+      failed.dispose();
+      total.dispose();
+      paused.dispose();
+      tasks.dispose();
+    }
+  };
+  return context;
+  function createTask(fn, id, taskOptions) {
+    const priority = taskOptions.priority ?? "normal";
+    if (!(priority in PRIORITIES)) {
+      throw new QueueError("INVALID_QUEUE_OPTIONS", `Vobs Queue: \u4E0D\u652F\u6301\u4EFB\u52A1\u4F18\u5148\u7EA7 ${String(priority)}`);
+    }
+    const maxRetries = taskOptions.retry ?? 0;
+    if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+      throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: retry \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6574\u6570");
+    }
+    const retryDelay = taskOptions.retryDelay ?? 0;
+    validateRetryDelay(retryDelay);
+    const status = state("pending");
+    const attempt = state(0);
+    const result = state(null);
+    const error = state(null);
+    let promise;
+    const task = {
+      id,
+      priority,
+      status,
+      attempt,
+      result,
+      error,
+      get promise() {
+        return promise;
+      },
+      fn,
+      maxRetries,
+      retryDelay,
+      sequence: sequence++,
+      controller: null,
+      settled: false,
+      executing: false,
+      retryQueued: false,
+      resolve: null,
+      reject: null,
+      cancel() {
+        if (status.value === "success" || status.value === "error" || status.value === "cancelled") return;
+        task.controller?.abort();
+        removeFromQueue(task);
+        status.value = "cancelled";
+        const cancellation = new QueueError("QUEUE_TASK_CANCELLED", `Vobs Queue: \u4EFB\u52A1 ${id} \u5DF2\u53D6\u6D88`);
+        error.value = cancellation;
+        settleReject(cancellation);
+        refreshStats();
+      },
+      retry() {
+        ensureActive();
+        if (status.value === "pending" || status.value === "running" || status.value === "retrying") return promise;
+        if (status.value === "success") return promise;
+        status.value = "pending";
+        attempt.value = 0;
+        result.value = null;
+        error.value = null;
+        task.controller = null;
+        task.settled = false;
+        task.retryQueued = true;
+        promise = createPromise();
+        if (!task.executing) queue.push(task);
+        sortQueue();
+        refreshStats();
+        drain();
+        return promise;
+      },
+      run() {
+        task.retryQueued = false;
+        task.executing = true;
+        return execute(task).finally(() => {
+          task.executing = false;
+          if (task.retryQueued && task.status.value === "pending" && !disposed) {
+            task.retryQueued = false;
+            queue.push(task);
+            sortQueue();
+            drain();
+          }
+        });
+      },
+      dispose() {
+        task.controller?.abort();
+        status.dispose();
+        attempt.dispose();
+        result.dispose();
+        error.dispose();
+      }
+    };
+    promise = createPromise();
+    return task;
+    function createPromise() {
+      return new Promise((resolve, reject) => {
+        task.resolve = resolve;
+        task.reject = reject;
+      });
+    }
+    function settleReject(reason) {
+      if (task.settled) return;
+      task.settled = true;
+      task.reject?.(reason);
+      task.resolve = null;
+      task.reject = null;
+    }
+  }
+  async function execute(task) {
+    while (!disposed && (task.status.value === "pending" || task.status.value === "retrying")) {
+      if (task.status.value === "retrying") task.status.value = "pending";
+      task.status.value = "running";
+      task.attempt.value++;
+      const controller = new AbortController();
+      task.controller = controller;
+      refreshStats();
+      try {
+        const value = await task.fn(controller.signal);
+        if (isCancelled(task) || disposed) return;
+        task.result.value = value;
+        task.status.value = "success";
+        settleTask(task, value);
+        refreshStats();
+        return;
+      } catch (reason) {
+        if (isCancelled(task) || disposed) return;
+        if (isAbortError(reason)) {
+          const cancellation = new QueueError("QUEUE_TASK_CANCELLED", `Vobs Queue: \u4EFB\u52A1 ${task.id} \u5DF2\u53D6\u6D88`, reason);
+          task.error.value = cancellation;
+          task.status.value = "cancelled";
+          settleTask(task, void 0, cancellation);
+          refreshStats();
+          return;
+        }
+        const failure = toQueueError(reason, task.id);
+        let delay;
+        try {
+          if (task.attempt.value <= task.maxRetries) {
+            delay = resolveRetryDelay(task.retryDelay, task.attempt.value, failure);
+          }
+        } catch (delayError) {
+          const invalidDelay = toQueueError(delayError, task.id);
+          task.error.value = invalidDelay;
+          task.status.value = "error";
+          settleTask(task, void 0, invalidDelay);
+          report(invalidDelay, task);
+          refreshStats();
+          return;
+        }
+        if (delay !== void 0) {
+          task.status.value = "retrying";
+          refreshStats();
+          try {
+            await wait(delay, controller.signal);
+          } catch (delayError) {
+            if (isCancelled(task) || isAbortError(delayError)) return;
+            throw delayError;
+          }
+          if (isCancelled(task) || disposed) return;
+          continue;
+        }
+        task.error.value = failure;
+        task.status.value = "error";
+        settleTask(task, void 0, failure);
+        report(failure, task);
+        refreshStats();
+        return;
+      } finally {
+        if (task.controller === controller) task.controller = null;
+      }
+    }
+  }
+  function drain() {
+    while (!disposed && !paused.value && active < concurrency && queue.length > 0) {
+      const task = queue.shift();
+      if (task.status.value !== "pending") continue;
+      active++;
+      void task.run().finally(() => {
+        active--;
+        refreshStats();
+        drain();
+      });
+    }
+    refreshStats();
+  }
+  function sortQueue() {
+    queue.sort((left, right) => PRIORITIES[right.priority] - PRIORITIES[left.priority] || left.sequence - right.sequence);
+  }
+  function removeFromQueue(task) {
+    const index = queue.indexOf(task);
+    if (index >= 0) queue.splice(index, 1);
+  }
+  function refreshStats() {
+    let nextPending = 0;
+    let nextProcessing = 0;
+    let nextCompleted = 0;
+    let nextFailed = 0;
+    for (const task of tasks.value) {
+      if (task.status.value === "pending") nextPending++;
+      else if (task.status.value === "running" || task.status.value === "retrying") nextProcessing++;
+      else if (task.status.value === "success") nextCompleted++;
+      else if (task.status.value === "error") nextFailed++;
+    }
+    pending.value = nextPending;
+    processing.value = nextProcessing;
+    completed.value = nextCompleted;
+    failed.value = nextFailed;
+    total.value = tasks.value.length;
+  }
+  function settleTask(task, value, reason) {
+    if (task.settled) return;
+    task.settled = true;
+    if (reason !== void 0) task.reject?.(reason);
+    else task.resolve?.(value);
+    task.resolve = null;
+    task.reject = null;
+  }
+  function report(queueError, task) {
+    try {
+      options.onError?.(queueError, task);
+    } catch {
+    }
+  }
+  function ensureActive() {
+    if (disposed) throw new QueueError("QUEUE_CONTEXT_DISPOSED", "Vobs Queue: \u4E0A\u4E0B\u6587\u5DF2\u9500\u6BC1");
+  }
+  function isCancelled(task) {
+    return task.status.value === "cancelled";
+  }
+}
+__name(createTaskQueue, "createTaskQueue");
+function queuePlugin(options = {}) {
+  return {
+    name: "@vobs/queue",
+    version: "0.1.0",
+    install(context) {
+      const ownedQueue = options.queue ? void 0 : createTaskQueue(options);
+      context.provide(QUEUE_KEY, options.queue ?? ownedQueue);
+      return () => ownedQueue?.dispose();
+    }
+  };
+}
+__name(queuePlugin, "queuePlugin");
+function useQueue() {
+  const queue = inject(QUEUE_KEY);
+  if (!queue) throw new QueueError("QUEUE_CONTEXT_MISSING", "Vobs Queue: \u627E\u4E0D\u5230\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5B89\u88C5 queuePlugin");
+  return queue;
+}
+__name(useQueue, "useQueue");
+function resolveConcurrency(options) {
+  if (options.concurrency !== void 0 && options.concurrent !== void 0 && options.concurrency !== options.concurrent) {
+    throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: concurrency \u4E0E concurrent \u4E0D\u80FD\u8BBE\u7F6E\u4E3A\u4E0D\u540C\u503C");
+  }
+  const value = options.concurrency ?? options.concurrent ?? 3;
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: concurrency \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  }
+  return value;
+}
+__name(resolveConcurrency, "resolveConcurrency");
+function validateRetryDelay(value) {
+  if (typeof value === "number" && (!Number.isFinite(value) || value < 0)) {
+    throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: retryDelay \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57\u6216\u51FD\u6570");
+  }
+  if (typeof value !== "number" && typeof value !== "function") {
+    throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: retryDelay \u5FC5\u987B\u662F\u6570\u5B57\u6216\u51FD\u6570");
+  }
+}
+__name(validateRetryDelay, "validateRetryDelay");
+function resolveRetryDelay(value, attempt, error) {
+  const delay = typeof value === "function" ? value(attempt, error) : value;
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new QueueError("INVALID_QUEUE_OPTIONS", "Vobs Queue: retryDelay \u51FD\u6570\u5FC5\u987B\u8FD4\u56DE\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  }
+  return delay;
+}
+__name(resolveRetryDelay, "resolveRetryDelay");
+function wait(delay, signal) {
+  if (delay === 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(done, delay);
+    signal.addEventListener("abort", abort, { once: true });
+    function done() {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    }
+    __name(done, "done");
+    function abort() {
+      clearTimeout(timer);
+      reject(Object.assign(new Error("Aborted"), { name: "AbortError" }));
+    }
+    __name(abort, "abort");
+  });
+}
+__name(wait, "wait");
+function toQueueError(reason, id) {
+  if (reason instanceof QueueError) return reason;
+  return new QueueError("QUEUE_TASK_FAILED", `Vobs Queue: \u4EFB\u52A1 ${id} \u6267\u884C\u5931\u8D25`, reason);
+}
+__name(toQueueError, "toQueueError");
+function isAbortError(value) {
+  return Boolean(value) && typeof value === "object" && value.name === "AbortError";
+}
+__name(isAbortError, "isAbortError");
+
+exports.QUEUE_KEY = QUEUE_KEY;
+exports.QueueError = QueueError;
+exports.createTaskQueue = createTaskQueue;
+exports.queuePlugin = queuePlugin;
+exports.useQueue = useQueue;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map