@vobs/resource 1.1.0 → 1.2.1

package/dist/index.js

@@ -0,0 +1,1229 @@
+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;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      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();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  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");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/resource/src/resource.ts
+var defaultClient = createResourceClient();
+function resource(optionsOrFetcher) {
+  return typeof optionsOrFetcher === "function" ? defaultClient.resource(optionsOrFetcher) : defaultClient.resource(optionsOrFetcher);
+}
+__name(resource, "resource");
+function createResourceClient(options = {}) {
+  let owner = createOwner();
+  const cache = /* @__PURE__ */ new Map();
+  const entries = /* @__PURE__ */ new Set();
+  const defaultStaleTime = validateStaleTime(options.staleTime ?? 0);
+  const defaultRetry = validateRetry(options.retry ?? 0);
+  const defaultRetryDelay = options.retryDelay ?? 0;
+  function createEntry(key, staleTime) {
+    const entry = owner.run(() => ({
+      key,
+      data: state(null),
+      error: state(null),
+      loading: state(false),
+      staleTime,
+      subscribers: /* @__PURE__ */ new Set(),
+      updatedAt: 0,
+      revision: 0,
+      inFlight: null,
+      controller: null
+    }));
+    owner.onDispose(() => entry.controller?.abort());
+    entries.add(entry);
+    return entry;
+  }
+  __name(createEntry, "createEntry");
+  function execute(entry, fetcher, retry, retryDelay) {
+    if (entry.inFlight) return entry.inFlight;
+    entry.loading.value = true;
+    entry.error.value = null;
+    const controller = new AbortController();
+    entry.controller = controller;
+    const revision = entry.revision;
+    const request = requestWithRetry(fetcher, controller.signal, retry, retryDelay);
+    entry.inFlight = request.then(
+      (data) => {
+        if (entry.revision === revision) {
+          entry.revision++;
+          entry.data.value = data;
+          entry.error.value = null;
+          entry.updatedAt = Date.now();
+        }
+        return data;
+      },
+      (reason) => {
+        const error = toError(reason);
+        if (entry.revision === revision) {
+          entry.error.value = error;
+          if (!controller.signal.aborted) options.onError?.(error, entry.key);
+        }
+        throw error;
+      }
+    ).finally(() => {
+      entry.loading.value = false;
+      if (entry.controller === controller) entry.controller = null;
+      entry.inFlight = null;
+    });
+    return entry.inFlight;
+  }
+  __name(execute, "execute");
+  function isFresh(entry) {
+    return entry.updatedAt > 0 && Date.now() - entry.updatedAt <= entry.staleTime;
+  }
+  __name(isFresh, "isFresh");
+  function createResource(optionsOrFetcher) {
+    const config = normalizeOptions(optionsOrFetcher, defaultStaleTime, defaultRetry, defaultRetryDelay);
+    if (isReactiveKey(config.key)) return createReactiveResource(config);
+    const staticKey = resolveKey(config.key);
+    const keyId = config.cache && staticKey ? stableSerialize(staticKey) : void 0;
+    let entry = keyId ? cache.get(keyId) : void 0;
+    if (!entry) {
+      entry = createEntry(staticKey, config.staleTime);
+      if (keyId) cache.set(keyId, entry);
+    }
+    const request = /* @__PURE__ */ __name((force) => {
+      if (entry.inFlight) return entry.inFlight;
+      if (!force && config.strategy === "stale-while-revalidate" && entry.data.value !== null) {
+        if (!isFresh(entry)) void execute(entry, config.fetcher, config.retry, config.retryDelay).catch(() => void 0);
+        return Promise.resolve(entry.data.value);
+      }
+      if (!force && isFresh(entry)) return Promise.resolve(entry.data.value);
+      return execute(entry, config.fetcher, config.retry, config.retryDelay);
+    }, "request");
+    void request(false).catch(() => void 0);
+    const resourceHandle = {};
+    entry.subscribers.add(resourceHandle);
+    const dispose = /* @__PURE__ */ __name(() => {
+      if (!entry?.subscribers.delete(resourceHandle)) return;
+      if (entry.subscribers.size === 0) entry.controller?.abort();
+    }, "dispose");
+    getCurrentOwner()?.onDispose(dispose);
+    return {
+      key: staticKey,
+      data: entry.data,
+      error: entry.error,
+      loading: entry.loading,
+      dispose,
+      refetch: /* @__PURE__ */ __name(() => request(true), "refetch"),
+      prefetch: /* @__PURE__ */ __name(() => request(false), "prefetch"),
+      invalidate: /* @__PURE__ */ __name(() => {
+        entry.updatedAt = 0;
+      }, "invalidate"),
+      mutate(next) {
+        const value = typeof next === "function" ? next(entry.data.value) : next;
+        entry.revision++;
+        entry.data.value = value;
+        entry.error.value = null;
+        entry.updatedAt = Date.now();
+      },
+      optimistic(next, action) {
+        const previous = {
+          data: entry.data.value,
+          error: entry.error.value,
+          updatedAt: entry.updatedAt
+        };
+        const value = typeof next === "function" ? next(entry.data.value) : next;
+        const revision = ++entry.revision;
+        entry.data.value = value;
+        entry.error.value = null;
+        entry.updatedAt = Date.now();
+        let actionResult;
+        try {
+          actionResult = Promise.resolve(action());
+        } catch (reason) {
+          actionResult = Promise.reject(reason);
+        }
+        return actionResult.catch((reason) => {
+          const error = toError(reason);
+          if (entry.revision === revision) {
+            entry.revision++;
+            entry.data.value = previous.data;
+            entry.error.value = error;
+            entry.updatedAt = previous.updatedAt;
+            options.onError?.(error, entry.key);
+          }
+          throw error;
+        });
+      }
+    };
+    function createReactiveResource(reactiveConfig) {
+      const data = state(null);
+      const error = state(null);
+      const loading = state(false);
+      const handle = {};
+      let activeEntry;
+      let activeKey;
+      let disposed = false;
+      const sync = /* @__PURE__ */ __name(() => {
+        if (!activeEntry) return;
+        data.value = activeEntry.data.value;
+        error.value = activeEntry.error.value;
+        loading.value = activeEntry.loading.value;
+      }, "sync");
+      const switchKey = /* @__PURE__ */ __name((nextKey) => {
+        const keyId2 = reactiveConfig.cache ? stableSerialize(nextKey) : void 0;
+        let nextEntry = keyId2 ? cache.get(keyId2) : void 0;
+        if (!nextEntry) {
+          nextEntry = createEntry(nextKey, reactiveConfig.staleTime);
+          if (keyId2) cache.set(keyId2, nextEntry);
+        }
+        if (activeEntry === nextEntry) {
+          sync();
+          return;
+        }
+        if (activeEntry) {
+          activeEntry.subscribers.delete(handle);
+          if (activeEntry.subscribers.size === 0) activeEntry.controller?.abort();
+        }
+        activeEntry = nextEntry;
+        activeKey = nextKey;
+        activeEntry.subscribers.add(handle);
+        sync();
+        void request2(false).catch(() => void 0);
+      }, "switchKey");
+      const stop = effect(() => {
+        if (disposed) return;
+        const nextKey = resolveKey(reactiveConfig.key);
+        if (!nextKey) throw new Error("resource: \u54CD\u5E94\u5F0F key \u4E0D\u80FD\u662F undefined");
+        switchKey(nextKey);
+        sync();
+      });
+      const dispose2 = /* @__PURE__ */ __name(() => {
+        if (disposed) return;
+        disposed = true;
+        stop.dispose();
+        if (activeEntry) {
+          activeEntry.subscribers.delete(handle);
+          if (activeEntry.subscribers.size === 0) activeEntry.controller?.abort();
+        }
+        activeEntry = void 0;
+      }, "dispose");
+      getCurrentOwner()?.onDispose(dispose2);
+      return {
+        get key() {
+          return activeKey;
+        },
+        data,
+        error,
+        loading,
+        dispose: dispose2,
+        refetch: /* @__PURE__ */ __name(() => request2(true), "refetch"),
+        prefetch: /* @__PURE__ */ __name(() => request2(false), "prefetch"),
+        invalidate: /* @__PURE__ */ __name(() => {
+          if (activeEntry) activeEntry.updatedAt = 0;
+        }, "invalidate"),
+        mutate(next) {
+          if (!activeEntry) return;
+          const value = typeof next === "function" ? next(activeEntry.data.value) : next;
+          activeEntry.revision++;
+          activeEntry.data.value = value;
+          activeEntry.error.value = null;
+          activeEntry.updatedAt = Date.now();
+        },
+        optimistic(next, action) {
+          if (!activeEntry) return Promise.reject(new Error("resource: key \u5C1A\u672A\u521D\u59CB\u5316"));
+          return createOptimistic(activeEntry, next, action);
+        }
+      };
+      function request2(force) {
+        if (!activeEntry) return Promise.reject(new Error("resource: key \u5C1A\u672A\u521D\u59CB\u5316"));
+        if (!force && isFresh(activeEntry) && reactiveConfig.strategy === "cache-first") {
+          return Promise.resolve(activeEntry.data.value);
+        }
+        if (!force && reactiveConfig.strategy === "stale-while-revalidate" && activeEntry.data.value !== null) {
+          if (!isFresh(activeEntry)) void execute(activeEntry, reactiveConfig.fetcher, reactiveConfig.retry, reactiveConfig.retryDelay).catch(() => void 0);
+          return Promise.resolve(activeEntry.data.value);
+        }
+        return execute(activeEntry, reactiveConfig.fetcher, reactiveConfig.retry, reactiveConfig.retryDelay);
+      }
+    }
+    function createOptimistic(target, next, action) {
+      const previous = { data: target.data.value, error: target.error.value, updatedAt: target.updatedAt };
+      const value = typeof next === "function" ? next(target.data.value) : next;
+      const revision = ++target.revision;
+      target.data.value = value;
+      target.error.value = null;
+      target.updatedAt = Date.now();
+      return Promise.resolve().then(action).catch((reason) => {
+        const failure = toError(reason);
+        if (target.revision === revision) {
+          target.revision++;
+          target.data.value = previous.data;
+          target.error.value = failure;
+          target.updatedAt = previous.updatedAt;
+          options.onError?.(failure, target.key);
+        }
+        throw failure;
+      });
+    }
+  }
+  __name(createResource, "createResource");
+  return {
+    resource: createResource,
+    invalidate(key) {
+      const entry = cache.get(stableSerialize(key));
+      if (entry) entry.updatedAt = 0;
+    },
+    async prefetchAll() {
+      const requests = [...entries].map((entry) => entry.inFlight).filter((request) => request !== null);
+      await Promise.allSettled(requests);
+    },
+    dehydrate() {
+      const entries2 = [];
+      for (const entry of cache.values()) {
+        if (entry.updatedAt <= 0 || entry.error.value) continue;
+        entries2.push({
+          key: entry.key ?? [],
+          data: entry.data.value,
+          updatedAt: entry.updatedAt,
+          staleTime: entry.staleTime
+        });
+      }
+      return { version: 1, entries: entries2 };
+    },
+    hydrate(snapshot) {
+      for (const restored of parseDehydratedState(snapshot).entries) {
+        const keyId = stableSerialize(restored.key);
+        const entry = cache.get(keyId) ?? createEntry(restored.key, restored.staleTime);
+        entry.data.value = restored.data;
+        entry.error.value = null;
+        entry.loading.value = false;
+        entry.updatedAt = restored.updatedAt;
+        entry.revision++;
+        cache.set(keyId, entry);
+      }
+    },
+    get(key) {
+      const entry = cache.get(stableSerialize(key));
+      if (!entry) return void 0;
+      return {
+        data: entry.data.value,
+        error: entry.error.value,
+        loading: entry.loading.value,
+        updatedAt: entry.updatedAt
+      };
+    },
+    clear() {
+      cache.clear();
+      entries.clear();
+      owner.dispose();
+      owner = createOwner();
+    }
+  };
+}
+__name(createResourceClient, "createResourceClient");
+function normalizeOptions(optionsOrFetcher, defaultStaleTime, defaultRetry, defaultRetryDelay) {
+  if (typeof optionsOrFetcher === "function") {
+    return {
+      fetcher: optionsOrFetcher,
+      staleTime: defaultStaleTime,
+      cache: false,
+      strategy: "cache-first",
+      retry: defaultRetry,
+      retryDelay: defaultRetryDelay
+    };
+  }
+  return {
+    key: optionsOrFetcher.key,
+    fetcher: optionsOrFetcher.fetcher,
+    staleTime: validateStaleTime(optionsOrFetcher.staleTime ?? defaultStaleTime),
+    cache: optionsOrFetcher.cache ?? Boolean(optionsOrFetcher.key),
+    strategy: optionsOrFetcher.strategy ?? "cache-first",
+    retry: validateRetry(optionsOrFetcher.retry ?? defaultRetry),
+    retryDelay: optionsOrFetcher.retryDelay ?? defaultRetryDelay
+  };
+}
+__name(normalizeOptions, "normalizeOptions");
+function isReactiveKey(key) {
+  return typeof key === "function" || isSignal(key);
+}
+__name(isReactiveKey, "isReactiveKey");
+function isSignal(value) {
+  return value !== null && typeof value === "object" && "value" in value && typeof value.dispose === "function";
+}
+__name(isSignal, "isSignal");
+function resolveKey(source) {
+  const key = typeof source === "function" ? source() : isSignal(source) ? source.value : source;
+  if (key === void 0) return void 0;
+  if (!Array.isArray(key)) throw new Error("resource: key \u5FC5\u987B\u662F\u6570\u7EC4");
+  return key;
+}
+__name(resolveKey, "resolveKey");
+function requestWithRetry(fetcher, signal, retry, retryDelay) {
+  let attempt = 0;
+  const request = /* @__PURE__ */ __name(() => Promise.resolve().then(() => fetcher(signal)).catch((reason) => {
+    const error = toError(reason);
+    if (signal.aborted) throw error;
+    if (attempt++ >= retry) throw error;
+    const delay = resolveRetryDelay(retryDelay, attempt, error);
+    return delay > 0 ? wait(delay).then(request) : request();
+  }), "request");
+  return request();
+}
+__name(requestWithRetry, "requestWithRetry");
+function resolveRetryDelay(retryDelay, attempt, error) {
+  const delay = typeof retryDelay === "function" ? retryDelay(attempt, error) : retryDelay;
+  if (!Number.isFinite(delay) || delay < 0) {
+    throw new Error("resource: retryDelay \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  }
+  return delay;
+}
+__name(resolveRetryDelay, "resolveRetryDelay");
+function wait(delay) {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+__name(wait, "wait");
+function validateStaleTime(staleTime) {
+  if (!Number.isFinite(staleTime) || staleTime < 0) {
+    throw new Error("resource: staleTime \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  }
+  return staleTime;
+}
+__name(validateStaleTime, "validateStaleTime");
+function validateRetry(retry) {
+  if (!Number.isInteger(retry) || retry < 0) {
+    throw new Error("resource: retry \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6574\u6570");
+  }
+  return retry;
+}
+__name(validateRetry, "validateRetry");
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+__name(toError, "toError");
+function stableSerialize(value) {
+  return serialize(value, /* @__PURE__ */ new Set());
+}
+__name(stableSerialize, "stableSerialize");
+function serializeResourceState(snapshot) {
+  const serialized = JSON.stringify(snapshot);
+  return serialized.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+__name(serializeResourceState, "serializeResourceState");
+function parseDehydratedState(snapshot) {
+  let value = snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      value = JSON.parse(snapshot);
+    } catch {
+      throw new Error("resource: \u9884\u53D6\u72B6\u6001\u4E0D\u662F\u6709\u6548 JSON");
+    }
+  }
+  if (!value || typeof value !== "object") throw new Error("resource: \u9884\u53D6\u72B6\u6001\u683C\u5F0F\u65E0\u6548");
+  const candidate = value;
+  if (candidate.version !== 1 || !Array.isArray(candidate.entries)) {
+    throw new Error("resource: \u9884\u53D6\u72B6\u6001\u7248\u672C\u6216 entries \u65E0\u6548");
+  }
+  const entries = [];
+  for (const entry of candidate.entries) {
+    if (!entry || typeof entry !== "object") throw new Error("resource: \u9884\u53D6\u6761\u76EE\u683C\u5F0F\u65E0\u6548");
+    const candidateEntry = entry;
+    if (!Array.isArray(candidateEntry.key) || typeof candidateEntry.updatedAt !== "number" || !Number.isFinite(candidateEntry.updatedAt) || typeof candidateEntry.staleTime !== "number" || !Number.isFinite(candidateEntry.staleTime) || candidateEntry.staleTime < 0) {
+      throw new Error("resource: \u9884\u53D6\u6761\u76EE\u5B57\u6BB5\u65E0\u6548");
+    }
+    stableSerialize(candidateEntry.key);
+    entries.push({
+      key: candidateEntry.key,
+      data: candidateEntry.data,
+      updatedAt: candidateEntry.updatedAt,
+      staleTime: candidateEntry.staleTime
+    });
+  }
+  return { version: 1, entries };
+}
+__name(parseDehydratedState, "parseDehydratedState");
+function serialize(value, stack) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return `string:${JSON.stringify(value)}`;
+    case "boolean":
+      return `boolean:${value}`;
+    case "number":
+      if (Number.isNaN(value)) return "number:NaN";
+      if (Object.is(value, -0)) return "number:-0";
+      return `number:${value}`;
+    case "bigint":
+      return `bigint:${value}`;
+    case "undefined":
+      return "undefined";
+    case "function":
+    case "symbol":
+      throw new Error(`resource: key \u4E0D\u80FD\u5305\u542B ${typeof value}`);
+  }
+  const object = value;
+  if (stack.has(object)) throw new Error("resource: key \u4E0D\u80FD\u5305\u542B\u5FAA\u73AF\u5F15\u7528");
+  stack.add(object);
+  try {
+    if (Array.isArray(object)) {
+      return `array:[${object.map((item) => serialize(item, stack)).join(",")}]`;
+    }
+    if (object instanceof Date) return `date:${object.toJSON()}`;
+    if (object instanceof RegExp) return `regexp:${object.toString()}`;
+    const entries = Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${serialize(object[key], stack)}`);
+    return `object:{${entries.join(",")}}`;
+  } finally {
+    stack.delete(object);
+  }
+}
+__name(serialize, "serialize");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// packages/runtime/src/error.ts
+var _VobsError = class _VobsError extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "VobsError";
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.layer = options.layer ?? "runtime";
+    this.cause = options.cause;
+    this.fix = options.fix;
+    this.location = options.location;
+    this.trace = options.trace;
+    this.example = options.example;
+    this.docs = options.docs;
+    this.codeFrame = options.codeFrame;
+  }
+};
+__name(_VobsError, "VobsError");
+var VobsError = _VobsError;
+function isVobsError(value) {
+  return value instanceof VobsError || Boolean(value && typeof value === "object" && typeof value.code === "string" && typeof value.message === "string" && typeof value.layer === "string");
+}
+__name(isVobsError, "isVobsError");
+function normalizeVobsError(value, defaults = {}) {
+  if (value instanceof VobsError) return value;
+  if (value instanceof Error) {
+    const metadata = value;
+    const code = defaults.code ?? (typeof metadata.vobsCode === "string" ? metadata.vobsCode : void 0);
+    if (code) defineErrorMetadata(value, "code", code);
+    defineErrorMetadata(value, "severity", defaults.severity ?? "error");
+    defineErrorMetadata(value, "layer", defaults.layer ?? "runtime");
+    const fix = defaults.fix ?? (typeof metadata.vobsHint === "string" ? metadata.vobsHint : void 0);
+    if (fix) defineErrorMetadata(value, "fix", fix);
+    const source = metadata.vobsSource;
+    if (source && typeof source === "object" && typeof source.file === "string" && typeof source.line === "number" && typeof source.column === "number") {
+      defineErrorMetadata(value, "location", source);
+    }
+    return value;
+  }
+  if (isVobsError(value)) {
+    const candidate = value;
+    return new VobsError({
+      code: candidate.code,
+      message: candidate.message,
+      severity: candidate.severity ?? defaults.severity,
+      layer: candidate.layer ?? defaults.layer,
+      cause: candidate.cause,
+      fix: candidate.fix ?? defaults.fix,
+      location: candidate.location,
+      trace: candidate.trace,
+      example: candidate.example,
+      docs: candidate.docs,
+      codeFrame: candidate.codeFrame
+    });
+  }
+  const message = String(value);
+  return new VobsError({
+    code: defaults.code ?? "VOBS_UNKNOWN",
+    message,
+    severity: defaults.severity ?? "error",
+    layer: defaults.layer ?? "runtime",
+    cause: void 0,
+    fix: defaults.fix
+  });
+}
+__name(normalizeVobsError, "normalizeVobsError");
+function defineErrorMetadata(target, key, value) {
+  if (key in target) return;
+  try {
+    Object.defineProperty(target, key, { configurable: true, enumerable: false, value, writable: true });
+  } catch {
+  }
+}
+__name(defineErrorMetadata, "defineErrorMetadata");
+
+// packages/runtime/src/boundary.ts
+function insertBoundary(parent, anchor, options) {
+  const boundary = createOwner();
+  boundary.run(() => {
+    const error = state(null);
+    let fallbackActive = false;
+    let lastError = null;
+    let initialized = false;
+    let previousKey;
+    boundary.onError((reason) => {
+      if (fallbackActive) throw reason;
+      const normalized = normalizeVobsError(reason, {
+        code: "VOBS_R001",
+        layer: "runtime",
+        fix: "\u68C0\u67E5\u7EC4\u4EF6\u6E32\u67D3\u903B\u8F91\uFF0C\u6216\u5728\u8FB9\u754C fallback \u4E2D\u63D0\u4F9B\u6062\u590D\u64CD\u4F5C\u3002"
+      });
+      lastError = normalized;
+      invokeRuntimeDebug("error", {
+        error: normalized,
+        owner: boundary,
+        phase: "boundary",
+        handled: true,
+        recovery: "fallback"
+      });
+      error.value = normalized;
+    });
+    const retry = /* @__PURE__ */ __name(() => {
+      if (error.value) {
+        invokeRuntimeDebug("error", {
+          error: error.value,
+          owner: boundary,
+          phase: "boundary",
+          handled: true,
+          recovery: "retrying"
+        });
+      }
+      error.value = null;
+      return options.onRetry?.();
+    }, "retry");
+    insertDynamic(parent, anchor, () => {
+      const nextKey = options.resetKey?.();
+      if (!initialized || !Object.is(previousKey, nextKey)) {
+        initialized = true;
+        previousKey = nextKey;
+        if (error.value) error.value = null;
+      }
+      const currentError = error.value;
+      if (!currentError) {
+        if (fallbackActive && lastError) {
+          invokeRuntimeDebug("error", {
+            error: lastError,
+            owner: boundary,
+            phase: "boundary",
+            handled: true,
+            recovery: "recovered"
+          });
+          lastError = null;
+        }
+        fallbackActive = false;
+        return options.children();
+      }
+      fallbackActive = true;
+      return options.fallback(currentError, retry);
+    });
+  });
+}
+__name(insertBoundary, "insertBoundary");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/resource/src/boundary.ts
+function insertResourceBoundary(parent, anchor, options) {
+  insertBoundary(parent, anchor, {
+    onRetry: /* @__PURE__ */ __name(() => options.resource.refetch(), "onRetry"),
+    fallback: /* @__PURE__ */ __name((error, retry) => options.fallback?.(error, () => Promise.resolve(retry())) ?? null, "fallback"),
+    children: /* @__PURE__ */ __name(() => {
+      if (options.resource.error.value) throw options.resource.error.value;
+      if (options.resource.loading.value) return resolveView(options.loading);
+      const data = options.resource.data.value;
+      if (data === null) return resolveView(options.empty);
+      return options.children(data);
+    }, "children")
+  });
+}
+__name(insertResourceBoundary, "insertResourceBoundary");
+function ResourceBoundary(props) {
+  return createFragment((parent, anchor) => insertResourceBoundary(parent, anchor, props));
+}
+__name(ResourceBoundary, "ResourceBoundary");
+function resolveView(view) {
+  if (!view) return null;
+  return typeof view === "function" ? view() : view;
+}
+__name(resolveView, "resolveView");
+
+// packages/router/src/index.ts
+var ROUTER_KEY = createInjectionKey("vobs.router");
+
+// packages/resource/src/plugin.ts
+var RESOURCE_KEY = createInjectionKey("vobs.resource");
+function resourcePlugin(options = {}) {
+  return {
+    name: "@vobs/resource",
+    version: "0.1.0",
+    install(context) {
+      const client = options.client ?? createResourceClient(options);
+      context.provide(RESOURCE_KEY, client);
+      return () => {
+        if (!options.client) client.clear();
+      };
+    }
+  };
+}
+__name(resourcePlugin, "resourcePlugin");
+function resourceRouterPlugin(options = {}) {
+  return {
+    name: "@vobs/resource-router",
+    version: "0.1.0",
+    install(context) {
+      const router = options.router ?? context.inject(ROUTER_KEY);
+      const client = options.client ?? context.inject(RESOURCE_KEY);
+      if (!router) throw new Error("Vobs Resource Router: \u627E\u4E0D\u5230 Router\uFF0C\u8BF7\u5B89\u88C5 routerPlugin \u6216\u4F20\u5165 router");
+      if (!client) throw new Error("Vobs Resource Router: \u627E\u4E0D\u5230 ResourceClient\uFF0C\u8BF7\u5B89\u88C5 resourcePlugin \u6216\u4F20\u5165 client");
+      return router.beforeEach(async (to) => {
+        const prefetch = readPrefetch(to);
+        await Promise.all(prefetch.map((task, index) => router.devtools.trackDataRequest(
+          "loader",
+          `${to.fullPath}#prefetch-${index + 1}`,
+          () => task({ route: to, client }),
+          { route: to.fullPath, trigger: "resource" }
+        )));
+      });
+    }
+  };
+}
+__name(resourceRouterPlugin, "resourceRouterPlugin");
+function readPrefetch(route) {
+  const value = route.meta.prefetch;
+  if (value === void 0) return [];
+  if (typeof value === "function") return [value];
+  if (!Array.isArray(value) || value.some((task) => typeof task !== "function")) {
+    throw new Error("Vobs Resource Router: route.meta.prefetch \u5FC5\u987B\u662F\u51FD\u6570\u6216\u51FD\u6570\u6570\u7EC4");
+  }
+  return value;
+}
+__name(readPrefetch, "readPrefetch");
+
+export { RESOURCE_KEY, ResourceBoundary, createResourceClient, insertResourceBoundary, resource, resourcePlugin, resourceRouterPlugin, serializeResourceState, stableSerialize };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map