@vobs/dict 1.1.0 → 1.2.1

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+import { Signal } from '@vobs/reactivity';
+import { InjectionKey, VobsPlugin } from '@vobs/vobs';
+
+type DictName = string;
+type DictValue = string | number;
+interface DictItem {
+    readonly value: DictValue;
+    readonly label: string;
+    readonly disabled?: boolean;
+    readonly [key: string]: unknown;
+}
+type DictItems = readonly DictItem[];
+type DictData = Readonly<Record<DictName, DictItems>>;
+type DictLoader = (name: DictName, signal: AbortSignal) => DictItems | PromiseLike<DictItems>;
+interface DictQuery {
+    readonly name: DictName;
+    readonly items: Signal<DictItems>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | null>;
+    readonly updatedAt: Signal<number>;
+    load(options?: {
+        readonly force?: boolean;
+    }): Promise<DictItems>;
+    invalidate(): void;
+}
+interface DictDehydratedEntry {
+    readonly name: DictName;
+    readonly items: DictItems;
+    readonly updatedAt: number;
+}
+interface DictDehydratedState {
+    readonly version: 1;
+    readonly entries: readonly DictDehydratedEntry[];
+}
+interface DictOptions {
+    readonly data?: DictData;
+    readonly loader?: DictLoader;
+    readonly staleTime?: number;
+    readonly now?: () => number;
+    readonly onError?: (error: DictError, name: DictName) => void;
+}
+interface DictPluginOptions extends DictOptions {
+    readonly dict?: DictContext;
+}
+interface DictContext {
+    readonly data: Signal<DictData>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | null>;
+    readonly staleTime: number;
+    get(name: DictName): DictItems;
+    find(name: DictName, value: DictValue): DictItem | undefined;
+    label(name: DictName, value: DictValue, fallback?: string): string;
+    query(name: DictName): DictQuery;
+    load(name: DictName, options?: {
+        readonly force?: boolean;
+    }): Promise<DictItems>;
+    set(name: DictName, items: DictItems): void;
+    invalidate(name?: DictName): void;
+    dehydrate(): DictDehydratedState;
+    hydrate(snapshot: unknown): void;
+    dispose(): void;
+}
+type DictErrorCode = 'DICT_CONTEXT_MISSING' | 'DICT_CONTEXT_DISPOSED' | 'INVALID_DICT_NAME' | 'INVALID_DICT_ITEMS' | 'DICT_LOADER_MISSING' | 'DICT_LOAD_FAILED' | 'INVALID_DEHYDRATED_STATE';
+declare class DictError extends Error {
+    readonly code: DictErrorCode;
+    readonly cause: unknown;
+    constructor(code: DictErrorCode, message: string, cause?: unknown);
+}
+declare const DICT_KEY: InjectionKey<DictContext>;
+declare function createDict(options?: DictOptions): DictContext;
+declare function dictPlugin(options?: DictPluginOptions): VobsPlugin;
+declare function useDict(): DictContext;
+
+export { DICT_KEY, type DictContext, type DictData, type DictDehydratedEntry, type DictDehydratedState, DictError, type DictErrorCode, type DictItem, type DictItems, type DictLoader, type DictName, type DictOptions, type DictPluginOptions, type DictQuery, type DictValue, createDict, dictPlugin, useDict };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { Signal } from '@vobs/reactivity';
+import { InjectionKey, VobsPlugin } from '@vobs/vobs';
+
+type DictName = string;
+type DictValue = string | number;
+interface DictItem {
+    readonly value: DictValue;
+    readonly label: string;
+    readonly disabled?: boolean;
+    readonly [key: string]: unknown;
+}
+type DictItems = readonly DictItem[];
+type DictData = Readonly<Record<DictName, DictItems>>;
+type DictLoader = (name: DictName, signal: AbortSignal) => DictItems | PromiseLike<DictItems>;
+interface DictQuery {
+    readonly name: DictName;
+    readonly items: Signal<DictItems>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | null>;
+    readonly updatedAt: Signal<number>;
+    load(options?: {
+        readonly force?: boolean;
+    }): Promise<DictItems>;
+    invalidate(): void;
+}
+interface DictDehydratedEntry {
+    readonly name: DictName;
+    readonly items: DictItems;
+    readonly updatedAt: number;
+}
+interface DictDehydratedState {
+    readonly version: 1;
+    readonly entries: readonly DictDehydratedEntry[];
+}
+interface DictOptions {
+    readonly data?: DictData;
+    readonly loader?: DictLoader;
+    readonly staleTime?: number;
+    readonly now?: () => number;
+    readonly onError?: (error: DictError, name: DictName) => void;
+}
+interface DictPluginOptions extends DictOptions {
+    readonly dict?: DictContext;
+}
+interface DictContext {
+    readonly data: Signal<DictData>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | null>;
+    readonly staleTime: number;
+    get(name: DictName): DictItems;
+    find(name: DictName, value: DictValue): DictItem | undefined;
+    label(name: DictName, value: DictValue, fallback?: string): string;
+    query(name: DictName): DictQuery;
+    load(name: DictName, options?: {
+        readonly force?: boolean;
+    }): Promise<DictItems>;
+    set(name: DictName, items: DictItems): void;
+    invalidate(name?: DictName): void;
+    dehydrate(): DictDehydratedState;
+    hydrate(snapshot: unknown): void;
+    dispose(): void;
+}
+type DictErrorCode = 'DICT_CONTEXT_MISSING' | 'DICT_CONTEXT_DISPOSED' | 'INVALID_DICT_NAME' | 'INVALID_DICT_ITEMS' | 'DICT_LOADER_MISSING' | 'DICT_LOAD_FAILED' | 'INVALID_DEHYDRATED_STATE';
+declare class DictError extends Error {
+    readonly code: DictErrorCode;
+    readonly cause: unknown;
+    constructor(code: DictErrorCode, message: string, cause?: unknown);
+}
+declare const DICT_KEY: InjectionKey<DictContext>;
+declare function createDict(options?: DictOptions): DictContext;
+declare function dictPlugin(options?: DictPluginOptions): VobsPlugin;
+declare function useDict(): DictContext;
+
+export { DICT_KEY, type DictContext, type DictData, type DictDehydratedEntry, type DictDehydratedState, DictError, type DictErrorCode, type DictItem, type DictItems, type DictLoader, type DictName, type DictOptions, type DictPluginOptions, type DictQuery, type DictValue, createDict, dictPlugin, useDict };

package/dist/index.js

@@ -0,0 +1,525 @@
+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/dict/src/index.ts
+var _DictError = class _DictError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "DictError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+__name(_DictError, "DictError");
+var DictError = _DictError;
+var DICT_KEY = createInjectionKey("vobs.dict");
+var EMPTY_ITEMS = Object.freeze([]);
+function createDict(options = {}) {
+  const staleTime = validateStaleTime(options.staleTime ?? 5 * 60 * 1e3);
+  const now = options.now ?? Date.now;
+  const initial = normalizeData(options.data ?? {});
+  const data = state(initial);
+  const loading = state(false);
+  const error = state(null);
+  const entries = /* @__PURE__ */ new Map();
+  let disposed = false;
+  for (const [name, items] of Object.entries(initial)) {
+    const entry = createEntry(name, items, now());
+    entries.set(name, entry);
+  }
+  const context = {
+    data,
+    loading,
+    error,
+    staleTime,
+    get(name) {
+      ensureActive();
+      return data.value[validateName(name)] ?? EMPTY_ITEMS;
+    },
+    find(name, value) {
+      ensureActive();
+      return context.get(name).find((item) => item.value === value);
+    },
+    label(name, value, fallback) {
+      ensureActive();
+      return context.find(name, value)?.label ?? fallback ?? String(value);
+    },
+    query(name) {
+      ensureActive();
+      return getEntry(validateName(name));
+    },
+    load(name, loadOptions = {}) {
+      ensureActive();
+      const entry = getEntry(validateName(name));
+      if (!loadOptions.force && isFresh(entry)) return Promise.resolve(entry.items.value);
+      if (entry.inFlight) return entry.inFlight;
+      if (!options.loader) {
+        const loadError = new DictError("DICT_LOADER_MISSING", `Vobs Dict: ${entry.name} \u672A\u914D\u7F6E loader`);
+        entry.error.value = loadError;
+        error.value = loadError;
+        report(loadError, entry.name);
+        return Promise.reject(loadError);
+      }
+      const revision = ++entry.revision;
+      const controller = new AbortController();
+      entry.controller = controller;
+      entry.loading.value = true;
+      refreshLoading();
+      const request = Promise.resolve().then(() => options.loader(entry.name, controller.signal)).then((items) => {
+        if (disposed || revision !== entry.revision) return entry.items.value;
+        const normalized = normalizeItems(items);
+        commit(entry, normalized, now(), false);
+        return normalized;
+      }).catch((reason) => {
+        if (disposed || revision !== entry.revision || isAbortError(reason)) return entry.items.value;
+        const loadError = reason instanceof DictError ? reason : new DictError("DICT_LOAD_FAILED", `Vobs Dict: ${entry.name} \u52A0\u8F7D\u5931\u8D25`, reason);
+        entry.error.value = loadError;
+        error.value = loadError;
+        report(loadError, entry.name);
+        throw loadError;
+      }).finally(() => {
+        if (revision !== entry.revision) return;
+        entry.inFlight = null;
+        entry.controller = null;
+        entry.loading.value = false;
+        refreshLoading();
+      });
+      entry.inFlight = request;
+      return request;
+    },
+    set(name, items) {
+      ensureActive();
+      commit(getEntry(validateName(name)), normalizeItems(items), now());
+    },
+    invalidate(name) {
+      ensureActive();
+      if (name === void 0) {
+        for (const entry of entries.values()) invalidateEntry(entry);
+        return;
+      }
+      invalidateEntry(getEntry(validateName(name)));
+    },
+    dehydrate() {
+      ensureActive();
+      return {
+        version: 1,
+        entries: Object.freeze([...entries.values()].filter((entry) => entry.updatedAt.value > 0).map((entry) => Object.freeze({
+          name: entry.name,
+          items: entry.items.value,
+          updatedAt: entry.updatedAt.value
+        })))
+      };
+    },
+    hydrate(snapshot) {
+      ensureActive();
+      const restored = parseDehydratedState(snapshot);
+      const nextData = {};
+      const restoredNames = /* @__PURE__ */ new Set();
+      for (const item of restored.entries) {
+        const entry = getEntry(item.name);
+        entry.revision++;
+        entry.controller?.abort();
+        entry.controller = null;
+        entry.inFlight = null;
+        entry.loading.value = false;
+        entry.items.value = item.items;
+        entry.error.value = null;
+        entry.updatedAt.value = item.updatedAt;
+        nextData[item.name] = item.items;
+        restoredNames.add(item.name);
+      }
+      for (const [name, entry] of entries) {
+        if (restoredNames.has(name)) continue;
+        entry.revision++;
+        entry.controller?.abort();
+        entry.controller = null;
+        entry.inFlight = null;
+        entry.loading.value = false;
+        entry.items.value = EMPTY_ITEMS;
+        entry.error.value = null;
+        entry.updatedAt.value = 0;
+      }
+      data.value = Object.freeze(nextData);
+      error.value = null;
+      refreshLoading();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const entry of entries.values()) {
+        entry.controller?.abort();
+        entry.items.dispose();
+        entry.loading.dispose();
+        entry.error.dispose();
+        entry.updatedAt.dispose();
+      }
+      entries.clear();
+      data.dispose();
+      loading.dispose();
+      error.dispose();
+    }
+  };
+  return context;
+  function getEntry(name) {
+    const existing = entries.get(name);
+    if (existing) return existing;
+    const entry = createEntry(name, data.value[name] ?? EMPTY_ITEMS, 0);
+    entries.set(name, entry);
+    return entry;
+  }
+  function createEntry(name, items, updatedAt) {
+    const entry = {
+      name,
+      items: state(items),
+      loading: state(false),
+      error: state(null),
+      updatedAt: state(updatedAt),
+      controller: null,
+      inFlight: null,
+      revision: 0,
+      load: /* @__PURE__ */ __name((loadOptions) => context.load(name, loadOptions), "load"),
+      invalidate: /* @__PURE__ */ __name(() => context.invalidate(name), "invalidate")
+    };
+    return entry;
+  }
+  function commit(entry, items, updatedAt, replaceRequest = true) {
+    if (replaceRequest) {
+      entry.revision++;
+      entry.controller?.abort();
+      entry.controller = null;
+      entry.inFlight = null;
+    }
+    entry.items.value = items;
+    entry.error.value = null;
+    entry.updatedAt.value = updatedAt;
+    data.value = Object.freeze({ ...data.value, [entry.name]: items });
+    error.value = null;
+    refreshLoading();
+  }
+  function invalidateEntry(entry) {
+    entry.revision++;
+    entry.controller?.abort();
+    entry.controller = null;
+    entry.inFlight = null;
+    entry.loading.value = false;
+    entry.updatedAt.value = 0;
+    refreshLoading();
+  }
+  function isFresh(entry) {
+    return entry.updatedAt.value > 0 && now() - entry.updatedAt.value < staleTime;
+  }
+  function refreshLoading() {
+    loading.value = [...entries.values()].some((entry) => entry.loading.value);
+  }
+  function report(dictError, name) {
+    try {
+      options.onError?.(dictError, name);
+    } catch {
+    }
+  }
+  function ensureActive() {
+    if (disposed) throw new DictError("DICT_CONTEXT_DISPOSED", "Vobs Dict: \u4E0A\u4E0B\u6587\u5DF2\u9500\u6BC1");
+  }
+}
+__name(createDict, "createDict");
+function dictPlugin(options = {}) {
+  return {
+    name: "@vobs/dict",
+    version: "0.1.0",
+    install(context) {
+      const ownedDict = options.dict ? void 0 : createDict(options);
+      context.provide(DICT_KEY, options.dict ?? ownedDict);
+      return () => ownedDict?.dispose();
+    }
+  };
+}
+__name(dictPlugin, "dictPlugin");
+function useDict() {
+  const dict = inject(DICT_KEY);
+  if (!dict) throw new DictError("DICT_CONTEXT_MISSING", "Vobs Dict: \u627E\u4E0D\u5230\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5B89\u88C5 dictPlugin");
+  return dict;
+}
+__name(useDict, "useDict");
+function validateName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new DictError("INVALID_DICT_NAME", "Vobs Dict: \u5B57\u5178\u540D\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+  }
+  return name;
+}
+__name(validateName, "validateName");
+function validateStaleTime(value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new DictError("INVALID_DICT_ITEMS", "Vobs Dict: staleTime \u5FC5\u987B\u662F\u5927\u4E8E\u7B49\u4E8E 0 \u7684\u6709\u9650\u6570\u5B57");
+  }
+  return value;
+}
+__name(validateStaleTime, "validateStaleTime");
+function normalizeData(data) {
+  const normalized = {};
+  for (const [name, items] of Object.entries(data)) normalized[validateName(name)] = normalizeItems(items);
+  return Object.freeze(normalized);
+}
+__name(normalizeData, "normalizeData");
+function normalizeItems(items) {
+  if (!Array.isArray(items)) throw new DictError("INVALID_DICT_ITEMS", "Vobs Dict: \u5B57\u5178\u9879\u5FC5\u987B\u662F\u6570\u7EC4");
+  return Object.freeze(items.map((item, index) => {
+    if (!item || typeof item !== "object" || typeof item.value !== "string" && typeof item.value !== "number" || typeof item.label !== "string") {
+      throw new DictError("INVALID_DICT_ITEMS", `Vobs Dict: \u7B2C ${index + 1} \u4E2A\u5B57\u5178\u9879\u5FC5\u987B\u5305\u542B value \u548C label`);
+    }
+    return Object.freeze({ ...item });
+  }));
+}
+__name(normalizeItems, "normalizeItems");
+function parseDehydratedState(snapshot) {
+  let value = snapshot;
+  if (typeof snapshot === "string") {
+    try {
+      value = JSON.parse(snapshot);
+    } catch {
+      throw new DictError("INVALID_DEHYDRATED_STATE", "Vobs Dict: \u521D\u59CB\u72B6\u6001\u4E0D\u662F\u6709\u6548 JSON");
+    }
+  }
+  if (!value || typeof value !== "object") {
+    throw new DictError("INVALID_DEHYDRATED_STATE", "Vobs Dict: \u521D\u59CB\u72B6\u6001\u683C\u5F0F\u65E0\u6548");
+  }
+  const candidate = value;
+  if (candidate.version !== 1 || !Array.isArray(candidate.entries)) {
+    throw new DictError("INVALID_DEHYDRATED_STATE", "Vobs Dict: \u521D\u59CB\u72B6\u6001\u7248\u672C\u6216 entries \u65E0\u6548");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const entries = candidate.entries.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      throw new DictError("INVALID_DEHYDRATED_STATE", "Vobs Dict: \u521D\u59CB\u72B6\u6001\u6761\u76EE\u65E0\u6548");
+    }
+    const name = validateName(entry.name);
+    const updatedAt = entry.updatedAt;
+    if (seen.has(name) || typeof updatedAt !== "number" || !Number.isFinite(updatedAt) || updatedAt < 0) {
+      throw new DictError("INVALID_DEHYDRATED_STATE", "Vobs Dict: \u521D\u59CB\u72B6\u6001\u6761\u76EE\u5B57\u6BB5\u65E0\u6548");
+    }
+    seen.add(name);
+    return Object.freeze({
+      name,
+      items: normalizeItems(entry.items),
+      updatedAt
+    });
+  });
+  return { version: 1, entries: Object.freeze(entries) };
+}
+__name(parseDehydratedState, "parseDehydratedState");
+function isAbortError(value) {
+  return Boolean(value) && typeof value === "object" && value.name === "AbortError";
+}
+__name(isAbortError, "isAbortError");
+
+export { DICT_KEY, DictError, createDict, dictPlugin, useDict };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map