@lacqjs/nuxt-dict 0.0.8 → 0.0.9

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@lacqjs/nuxt-dict",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "configKey": "dict",
   "compatibility": {
     "nuxt": "^4.4.8"

package/dist/module.mjs

@@ -7,7 +7,7 @@ export { createDictTranslator } from '../dist/runtime/utils/dict-translator.js';
 export { defineDictAdapter } from '../dist/runtime/core/define-adapter.js';
 
 const name = "@lacqjs/nuxt-dict";
-const version = "0.0.8";
+const version = "0.0.9";
 const devDependencies = {
 	nuxt: "^4.4.8"};
 const pkg = {

package/dist/runtime/composables/useDict.js

@@ -1,6 +1,8 @@
 import { shallowRef, ref, watch, onMounted, onBeforeUnmount, triggerRef } from "vue";
 import { useNuxtApp } from "#imports";
 import { DEFAULT_STORE_NAME } from "../core/cache/indexeddb-cache.js";
+import { createLogger } from "../utils/logger.js";
+const logger = createLogger("nuxt-dict");
 const activeInstances = /* @__PURE__ */ new Map();
 async function fetchDictData(manager, dictType, storeName, data, loading, error, mode = "load", itemMap) {
   loading.value = true;
@@ -20,6 +22,7 @@ async function fetchDictData(manager, dictType, storeName, data, loading, error,
       }
     }
   } catch (e) {
+    logger.debug(`fetchDictData ERROR store=${storeName} type=${dictType} mode=${mode}`, e);
     error.value = e instanceof Error ? e.message : String(e);
   } finally {
     loading.value = false;

package/dist/runtime/core/cache/indexeddb-cache.d.ts

@@ -2,47 +2,70 @@ import type { DictEntry, CacheEntry } from '../../types/index.js';
 /** 默认 IndexedDB 对象存储库名称 */
 export declare const DEFAULT_STORE_NAME = "dicts";
 /**
- * IndexedDB 缓存实现，用于持久化字典数据。
- * 支持客户端离线访问，减少重复网络请求。
- * 版本号改用 localStorage 存储，不再使用 IndexedDB。
+ * 基于 Dexie.js 的 IndexedDB 缓存实现（多表方案）。
  *
- * 多对象存储库支持：
- * - 默认存储库 `'dicts'` 在 init() 时创建
- * - 额外存储库通过 ensureStore() 惰性创建
- * - 使用串行升级队列处理并发多 store 创建，批量累积后一次升级完成
+ * @description 每个字典仓库对应一个独立的 Dexie table（IndexedDB object store），
+ * 通过 init(storeNames) 在初始化时一次性声明所有表的 schema，
+ * 避免原生 IndexedDB 多次版本升级导致的竞态问题。
+ *
+ * 数据隔离：各仓库数据物理隔离，在 DevTools Application 面板中独立可见。
+ * Schema 管理：使用仓库数量作为版本号，增删仓库时自动升级。
+ *
+ * @example
+ * const cache = new IndexedDBCache('nuxt-dict')
+ * await cache.init(['dicts', 'dicts2', 'dicts3'])
+ * await cache.set('dicts', 'gender', 'zh-CN', entry)
+ * const result = await cache.get('dicts', 'gender', 'zh-CN')
  */
 export declare class IndexedDBCache {
-    private dbName;
     private db;
-    private version;
-    /** 串行化升级队列，防止并发 ensureStore 导致多次版本升级 */
-    private upgradeQueue;
-    /** 累积待创建的 store 名，批量创建以减少升级次数 */
-    private pendingStores;
+    private dbName;
+    /**
+     * @param {string} dbName - IndexedDB 数据库名称
+     */
     constructor(dbName: string);
-    /** 初始化 IndexedDB，创建默认对象存储库 */
-    init(): Promise<void>;
     /**
-     * 惰性确保指定名称的对象存储库存在。
-     * 若当前 DB 中已有该 store 则立即返回；
-     * 否则将 store 名加入待建集合，通过串行队列触发一次版本升级批量创建。
+     * 初始化数据库，一次性声明所有仓库对应的 object store。
+     *
+     * @description 根据传入的仓库名列表声明 Dexie schema，每个仓库一个独立表。
+     * 使用仓库数量作为版本号，增减仓库时自动触发 Dexie 的版本升级。
+     * 若版本降级（删了仓库）导致 VersionError，自动删除旧库重建。
+     *
+     * @param {string[]} storeNames - 所有仓库名列表，如 ['dicts', 'dicts2', 'dicts3']
+     * @returns {Promise<void>}
      */
-    private ensureStore;
+    init(storeNames: string[]): Promise<void>;
     /**
-     * 执行一次版本升级，批量创建所有累积的待建 object store。
-     * 内部注册 onversionchange 确保旧连接能被浏览器主动关闭，
-     * blocked 事件不视为错误——旧连接释放后 success 事件会自动触发。
+     * 生成缓存键。
+     * @param {string} dictType - 字典类型，如 'gender'
+     * @param {string} locale - 语言标识，如 'zh-CN'
+     * @returns {string} 格式 `${dictType}_${locale}`
      */
-    private doUpgrade;
-    /** 生成存储键名：`{dictType}_{locale}` */
     private getStoreKey;
-    /** 从指定存储库读取字典缓存 */
+    /**
+     * 从指定仓库读取字典缓存。
+     *
+     * @param {string} storeName - 仓库名，如 'dicts'
+     * @param {string} dictType - 字典类型，如 'gender'
+     * @param {string} locale - 语言标识，如 'zh-CN'
+     * @returns {Promise<CacheEntry<DictEntry> | null>} 缓存条目，未命中返回 null
+     */
     get(storeName: string, dictType: string, locale: string): Promise<CacheEntry<DictEntry> | null>;
-    /** 写入字典缓存条目到指定存储库 */
+    /**
+     * 写入缓存条目到指定仓库。
+     *
+     * @param {string} storeName - 仓库名
+     * @param {string} dictType - 字典类型
+     * @param {string} locale - 语言标识
+     * @param {CacheEntry<DictEntry>} entry - 缓存条目
+     * @returns {Promise<void>}
+     */
     set(storeName: string, dictType: string, locale: string, entry: CacheEntry<DictEntry>): Promise<void>;
     /**
-     * 清空字典缓存数据。
-     * @param storeName 指定要清空的存储库名，不传则清空全部存储库
+     * 清空缓存数据。
+     *
+     * @param {string} [storeName] - 指定仓库名则只清该仓库，不传则清空全部
+     * @returns {Promise<void>}
      */
     clear(storeName?: string): Promise<void>;
 }

package/dist/runtime/core/cache/indexeddb-cache.js

@@ -1,144 +1,109 @@
+import Dexie from "dexie";
+import { createLogger } from "../../utils/logger.js";
 export const DEFAULT_STORE_NAME = "dicts";
+const logger = createLogger("nuxt-dict");
 export class IndexedDBCache {
+  db;
   dbName;
-  db = null;
-  version = 1;
-  /** 串行化升级队列，防止并发 ensureStore 导致多次版本升级 */
-  upgradeQueue = Promise.resolve();
-  /** 累积待创建的 store 名，批量创建以减少升级次数 */
-  pendingStores = /* @__PURE__ */ new Set();
+  /**
+   * @param {string} dbName - IndexedDB 数据库名称
+   */
   constructor(dbName) {
     this.dbName = dbName;
-  }
-  /** 初始化 IndexedDB，创建默认对象存储库 */
-  init() {
-    if (this.db) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName);
-      request.addEventListener("upgradeneeded", () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains(DEFAULT_STORE_NAME)) {
-          db.createObjectStore(DEFAULT_STORE_NAME);
-        }
-      });
-      request.addEventListener("success", () => {
-        this.db = request.result;
-        this.version = this.db.version;
-        resolve();
-      });
-      request.addEventListener("error", () => {
-        reject(
-          new Error("Failed to open IndexedDB: " + (request.error?.message || "unknown error"))
-        );
-      });
-      request.addEventListener("blocked", () => {
-        reject(new Error("IndexedDB is blocked by another tab"));
-      });
-    });
+    this.db = new Dexie(dbName);
   }
   /**
-   * 惰性确保指定名称的对象存储库存在。
-   * 若当前 DB 中已有该 store 则立即返回；
-   * 否则将 store 名加入待建集合，通过串行队列触发一次版本升级批量创建。
+   * 初始化数据库，一次性声明所有仓库对应的 object store。
+   *
+   * @description 根据传入的仓库名列表声明 Dexie schema，每个仓库一个独立表。
+   * 使用仓库数量作为版本号，增减仓库时自动触发 Dexie 的版本升级。
+   * 若版本降级（删了仓库）导致 VersionError，自动删除旧库重建。
+   *
+   * @param {string[]} storeNames - 所有仓库名列表，如 ['dicts', 'dicts2', 'dicts3']
+   * @returns {Promise<void>}
    */
-  async ensureStore(storeName) {
-    await this.init();
-    if (this.db.objectStoreNames.contains(storeName)) return;
-    this.pendingStores.add(storeName);
-    this.upgradeQueue = this.upgradeQueue.then(() => this.doUpgrade());
-    return this.upgradeQueue;
+  async init(storeNames) {
+    const schema = {};
+    for (const name of storeNames) {
+      schema[name] = "";
+    }
+    const version = Math.max(storeNames.length, 1);
+    this.db.version(version).stores(schema);
+    logger.debug(`IndexedDB init: opening "${this.dbName}", version=${version}, stores=[${storeNames.join(", ")}]`);
+    try {
+      await this.db.open();
+    } catch (e) {
+      if (e instanceof Error && e.name === "VersionError") {
+        logger.debug(`IndexedDB init: VersionError, deleting old database and recreating`);
+        this.db.close();
+        await Dexie.delete(this.dbName);
+        this.db = new Dexie(this.dbName);
+        this.db.version(version).stores(schema);
+        await this.db.open();
+      } else {
+        throw e;
+      }
+    }
+    logger.debug(`IndexedDB init: complete, tables=[${this.db.tables.map((t) => t.name).join(", ")}]`);
   }
   /**
-   * 执行一次版本升级，批量创建所有累积的待建 object store。
-   * 内部注册 onversionchange 确保旧连接能被浏览器主动关闭，
-   * blocked 事件不视为错误——旧连接释放后 success 事件会自动触发。
+   * 生成缓存键。
+   * @param {string} dictType - 字典类型，如 'gender'
+   * @param {string} locale - 语言标识，如 'zh-CN'
+   * @returns {string} 格式 `${dictType}_${locale}`
    */
-  async doUpgrade() {
-    if (this.pendingStores.size === 0) return;
-    const stores = new Set(this.pendingStores);
-    this.pendingStores.clear();
-    const toCreate = [...stores].filter((s) => !this.db.objectStoreNames.contains(s));
-    if (toCreate.length === 0) return;
-    this.db.onversionchange = () => {
-      this.db.close();
-    };
-    this.db.close();
-    this.version++;
-    await new Promise((resolve, reject) => {
-      const req = indexedDB.open(this.dbName, this.version);
-      req.addEventListener("upgradeneeded", () => {
-        const db = req.result;
-        for (const name of toCreate) {
-          if (!db.objectStoreNames.contains(name)) {
-            db.createObjectStore(name);
-          }
-        }
-      });
-      req.addEventListener("success", () => {
-        this.db = req.result;
-        resolve();
-      });
-      req.addEventListener("error", () => reject(req.error));
-      req.addEventListener("blocked", () => {
-      });
-    });
-  }
-  /** 生成存储键名：`{dictType}_{locale}` */
   getStoreKey(dictType, locale) {
     return `${dictType}_${locale}`;
   }
-  /** 从指定存储库读取字典缓存 */
+  /**
+   * 从指定仓库读取字典缓存。
+   *
+   * @param {string} storeName - 仓库名，如 'dicts'
+   * @param {string} dictType - 字典类型，如 'gender'
+   * @param {string} locale - 语言标识，如 'zh-CN'
+   * @returns {Promise<CacheEntry<DictEntry> | null>} 缓存条目，未命中返回 null
+   */
   async get(storeName, dictType, locale) {
-    if (!this.db) return null;
-    await this.ensureStore(storeName);
-    if (!this.db) return null;
-    return new Promise((resolve, reject) => {
-      const tx = this.db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const request = store.get(this.getStoreKey(dictType, locale));
-      request.addEventListener("success", () => resolve(request.result ?? null));
-      request.addEventListener("error", () => reject(request.error));
-    });
+    if (!this.db.isOpen()) return null;
+    if (!this.db.tables.some((t) => t.name === storeName)) return null;
+    const key = this.getStoreKey(dictType, locale);
+    const record = await this.db.table(storeName).get(key);
+    logger.debug(`IndexedDB get: store=${storeName} key=${key} hit=${!!record}`);
+    return record ?? null;
   }
-  /** 写入字典缓存条目到指定存储库 */
+  /**
+   * 写入缓存条目到指定仓库。
+   *
+   * @param {string} storeName - 仓库名
+   * @param {string} dictType - 字典类型
+   * @param {string} locale - 语言标识
+   * @param {CacheEntry<DictEntry>} entry - 缓存条目
+   * @returns {Promise<void>}
+   */
   async set(storeName, dictType, locale, entry) {
-    if (!this.db) return;
-    await this.ensureStore(storeName);
-    if (!this.db) return;
-    return new Promise((resolve, reject) => {
-      const tx = this.db.transaction(storeName, "readwrite");
-      const store = tx.objectStore(storeName);
-      const request = store.put(entry, this.getStoreKey(dictType, locale));
-      request.addEventListener("success", () => resolve());
-      request.addEventListener("error", () => reject(request.error));
-    });
+    if (!this.db.isOpen()) return;
+    if (!this.db.tables.some((t) => t.name === storeName)) return;
+    const key = this.getStoreKey(dictType, locale);
+    logger.debug(`IndexedDB set: store=${storeName} key=${key}`);
+    await this.db.table(storeName).put(entry, key);
   }
   /**
-   * 清空字典缓存数据。
-   * @param storeName 指定要清空的存储库名，不传则清空全部存储库
+   * 清空缓存数据。
+   *
+   * @param {string} [storeName] - 指定仓库名则只清该仓库，不传则清空全部
+   * @returns {Promise<void>}
    */
   async clear(storeName) {
-    if (!this.db) return;
+    if (!this.db.isOpen()) return;
     if (storeName) {
-      if (!this.db.objectStoreNames.contains(storeName)) return;
-      await new Promise((resolve, reject) => {
-        const tx = this.db.transaction(storeName, "readwrite");
-        const store = tx.objectStore(storeName);
-        const request = store.clear();
-        request.addEventListener("success", () => resolve());
-        request.addEventListener("error", () => reject(request.error));
-      });
-      return;
-    }
-    const storeNames = Array.from(this.db.objectStoreNames);
-    for (const name of storeNames) {
-      await new Promise((resolve, reject) => {
-        const tx = this.db.transaction(name, "readwrite");
-        const store = tx.objectStore(name);
-        const request = store.clear();
-        request.addEventListener("success", () => resolve());
-        request.addEventListener("error", () => reject(request.error));
-      });
+      if (!this.db.tables.some((t) => t.name === storeName)) return;
+      logger.debug(`IndexedDB clear: store=${storeName}`);
+      await this.db.table(storeName).clear();
+    } else {
+      logger.debug("IndexedDB clear: ALL");
+      for (const table of this.db.tables) {
+        await table.clear();
+      }
     }
   }
 }

package/dist/runtime/core/define-adapter.d.ts

@@ -9,8 +9,7 @@ import type { DictAdapter } from '../types/index.js';
  * @returns {DictAdapter} 原样返回传入的适配器对象
  *
  * @example
- * // ~/dict/dict-adapter.ts
- * import { defineDictAdapter } from '@lacqjs/nuxt-dict'
+ * // ~/dict/dict-adapter.ts — defineDictAdapter 已自动导入，无需 import
  *
  * export default defineDictAdapter({
  *   async fetchDict(storeName, { types, locale }) {

package/dist/runtime/core/dict-manager.d.ts

@@ -20,6 +20,8 @@ export interface DictManagerOptions {
     ttl: number;
     /** localStorage 中存储版本号的 key */
     versionStorageKey: string;
+    /** 配置为惰性版本检查的仓库集合，不在此集合中的仓库由 initialize() 立即检查 */
+    lazyStores: Set<string>;
 }
 /**
  * 字典管理器 —— 核心调度层。
@@ -46,6 +48,8 @@ export declare class DictManager {
     private checkedStores;
     /** 正在进行的版本检查请求，用于去重 */
     private pendingVersionChecks;
+    /** 配置为惰性版本检查的仓库集合 */
+    private lazyStores;
     locale: import("vue").ShallowRef<string, string>;
     constructor(options: DictManagerOptions);
     /** 构建带存储库命名空间和语言后缀的缓存键 */
@@ -66,7 +70,7 @@ export declare class DictManager {
      */
     getLocale(): string;
     /**
-     * 惰性版本检查：首次访问该仓库时检查版本变更，按需清理缓存。
+     * 惰性版本检查（仅 lazy 仓库使用）：首次访问该仓库时检查版本变更，按需清理缓存。
      * 并发调用去重 —— 同一仓库的多个 getDict 共享单次版本检查。
      */
     private ensureVersionChecked;
@@ -126,8 +130,8 @@ export declare class DictManager {
      */
     private codeMatch;
     /**
-     * 初始化管理器。
-     * 版本检查已改为惰性执行，在首次 getDict() 调用时触发，避免全量串行请求。
+     * 初始化管理器：对非 lazy 仓库立即并行检查版本号。
+     * lazy 仓库的版本检查延迟到首次 getDict() 调用时惰性触发。
      *
      * @returns {Promise<void>}
      */

package/dist/runtime/core/dict-manager.js

@@ -2,6 +2,8 @@ import { shallowRef } from "vue";
 import { DEFAULT_STORE_NAME } from "./cache/indexeddb-cache.js";
 import { MemoryCache } from "./cache/memory-cache.js";
 import { VersionCheck } from "./cache/version-check.js";
+import { createLogger } from "../utils/logger.js";
+const logger = createLogger("nuxt-dict");
 export class DictManager {
   memoryCache;
   indexedDB;
@@ -14,12 +16,15 @@ export class DictManager {
   checkedStores = /* @__PURE__ */ new Set();
   /** 正在进行的版本检查请求，用于去重 */
   pendingVersionChecks = /* @__PURE__ */ new Map();
+  /** 配置为惰性版本检查的仓库集合 */
+  lazyStores;
   locale = shallowRef("zh-CN");
   constructor(options) {
     this.memoryCache = new MemoryCache(options.memoryMax, options.ttl);
     this.indexedDB = options.indexedDB;
     this.adapters = options.adapters;
     this.pendingRequests = /* @__PURE__ */ new Map();
+    this.lazyStores = options.lazyStores;
     this.versionChecks = /* @__PURE__ */ new Map();
     for (const [storeName, adapter] of options.adapters) {
       const storageKey = storeName === DEFAULT_STORE_NAME ? options.versionStorageKey : `${options.versionStorageKey}__${storeName}`;
@@ -56,7 +61,7 @@ export class DictManager {
     return this.locale.value;
   }
   /**
-   * 惰性版本检查：首次访问该仓库时检查版本变更，按需清理缓存。
+   * 惰性版本检查（仅 lazy 仓库使用）：首次访问该仓库时检查版本变更，按需清理缓存。
    * 并发调用去重 —— 同一仓库的多个 getDict 共享单次版本检查。
    */
   async ensureVersionChecked(storeName) {
@@ -79,9 +84,9 @@ export class DictManager {
       }
     })() : Promise.resolve();
     this.pendingVersionChecks.set(storeName, promise);
-    this.checkedStores.add(storeName);
     try {
       await promise;
+      this.checkedStores.add(storeName);
     } finally {
       this.pendingVersionChecks.delete(storeName);
     }
@@ -95,7 +100,10 @@ export class DictManager {
    * @returns {Promise<DictEntry>} 包含 items 和可选 tree 的字典条目
    */
   async getDict(type, storeName = DEFAULT_STORE_NAME) {
-    await this.ensureVersionChecked(storeName);
+    logger.debug(`getDict START store=${storeName} type=${type} lazy=${this.lazyStores.has(storeName)}`);
+    if (this.lazyStores.has(storeName)) {
+      await this.ensureVersionChecked(storeName);
+    }
     const key = this.buildKey(type, storeName);
     const memoryEntry = this.memoryCache.get(key);
     if (memoryEntry) {
@@ -115,7 +123,9 @@ export class DictManager {
   }
   /** 执行实际的数据获取与缓存写入 */
   async fetchAndCache(type, storeName, key) {
+    logger.debug(`fetchAndCache START store=${storeName} type=${type}`);
     const idbEntry = await this.indexedDB.get(storeName, type, this.locale.value);
+    logger.debug(`fetchAndCache IndexedDB result store=${storeName} type=${type} hit=${!!idbEntry}`);
     if (idbEntry) {
       this.memoryCache.set(key, {
         data: idbEntry.data,
@@ -124,12 +134,14 @@ export class DictManager {
       });
       return idbEntry.data;
     }
+    logger.debug(`fetchAndCache NETWORK requesting store=${storeName} type=${type}`);
     const adapter = this.getAdapter(storeName);
     const response = await adapter.fetchDict(storeName, {
       types: [type],
       locale: this.locale.value
     });
     const entry = response.data[type];
+    logger.debug(`fetchAndCache NETWORK done store=${storeName} type=${type} found=${!!entry} items=${entry?.items?.length}`);
     if (!entry) {
       throw new Error(`Dictionary type "${type}" not found in response`);
     }
@@ -253,12 +265,24 @@ export class DictManager {
     return String(a) === String(b);
   }
   /**
-   * 初始化管理器。
-   * 版本检查已改为惰性执行，在首次 getDict() 调用时触发，避免全量串行请求。
+   * 初始化管理器：对非 lazy 仓库立即并行检查版本号。
+   * lazy 仓库的版本检查延迟到首次 getDict() 调用时惰性触发。
    *
    * @returns {Promise<void>}
    */
   async initialize() {
+    if (typeof localStorage === "undefined") return;
+    const immediateStores = [...this.versionChecks].filter(([name]) => !this.lazyStores.has(name));
+    await Promise.all(immediateStores.map(async ([name, vc]) => {
+      try {
+        const { changed } = await vc.check(name);
+        if (changed) {
+          await this.invalidateAll(name);
+        }
+      } catch {
+      }
+      this.checkedStores.add(name);
+    }));
   }
   /**
    * 失效缓存数据。

package/dist/runtime/options.js

@@ -4,7 +4,8 @@ export const defaultOptions = {
   api: {
     baseURL: "/api",
     dictEndpoint: "/dict/list",
-    versionEndpoint: "/dict/version"
+    versionEndpoint: "/dict/version",
+    lazy: false
   },
   cache: {
     memoryMax: 200,

package/dist/runtime/plugins/dict.js

@@ -54,13 +54,26 @@ function resolveClientLocale(options) {
   }
   return options.locale.default;
 }
-async function initClientCache(manager, indexedDB, logger) {
-  try {
-    await indexedDB.init();
-    await manager.initialize();
-  } catch (e) {
-    logger.warn("IndexedDB init failed:", e);
+async function initClient(manager, indexedDB, options, logger) {
+  if (options.cache.indexedDB.enabled) {
+    try {
+      const storeNames = [DEFAULT_STORE_NAME, ...Object.keys(options.stores)];
+      await indexedDB.init(storeNames);
+    } catch (e) {
+      logger.warn("IndexedDB init failed:", e);
+    }
   }
+  await manager.initialize();
+}
+function resolveLazyStores(options) {
+  const lazyStores = /* @__PURE__ */ new Set();
+  if (options.api.lazy) lazyStores.add(DEFAULT_STORE_NAME);
+  for (const [name, config] of Object.entries(options.stores)) {
+    if (config.lazy ?? options.api.lazy ?? false) {
+      lazyStores.add(name);
+    }
+  }
+  return lazyStores;
 }
 async function executePrefetch(manager, types, logger) {
   try {
@@ -102,12 +115,14 @@ const dictPlugin = defineNuxtPlugin(async (nuxtApp) => {
   const logger = createLogger("nuxt-dict", { level: options.logLevel });
   const adapters = createAdapters(options, logger);
   const indexedDB = new IndexedDBCache(options.cache.indexedDB.dbName);
+  const lazyStores = resolveLazyStores(options);
   const manager = new DictManager({
     adapters,
     indexedDB,
     memoryMax: options.cache.memoryMax,
     ttl: options.cache.ttl,
-    versionStorageKey: options.version.storageKey
+    versionStorageKey: options.version.storageKey,
+    lazyStores
   });
   const locale = import.meta.server ? resolveServerLocale(options) : resolveClientLocale(options);
   manager.setLocale(locale);
@@ -120,8 +135,8 @@ const dictPlugin = defineNuxtPlugin(async (nuxtApp) => {
       }
     });
   }
-  if (import.meta.client && options.cache.indexedDB.enabled) {
-    await initClientCache(manager, indexedDB, logger);
+  if (import.meta.client) {
+    await initClient(manager, indexedDB, options, logger);
   }
   if (import.meta.server && options.ssr.prefetch.length > 0) {
     await executePrefetch(manager, options.ssr.prefetch, logger);

package/dist/runtime/types/index.d.ts

@@ -88,6 +88,8 @@ export interface StoreApiOptions {
     versionEndpoint?: string;
     /** 自定义字典适配器文件路径（如 '~/dict/dict-adapter'），不传则按约定路径自动发现或使用默认 REST 适配器 */
     adapter?: string;
+    /** 是否惰性检查版本号，默认继承全局 `api.lazy`。`true` 时首次 getDict 调用才检查，`false` 时页面加载立即检查 */
+    lazy?: boolean;
 }
 /** 模块配置项（用户可传，字段均可选） */
 export interface ModuleOptions {
@@ -104,6 +106,8 @@ export interface ModuleOptions {
         versionEndpoint?: string;
         /** 自定义字典适配器文件路径（如 '~/dict/dict-adapter'），不传则按约定路径自动发现或使用默认 REST 适配器 */
         adapter?: string;
+        /** 是否惰性检查版本号，默认 `false`（页面加载时立即检查）。`true` 时首次 getDict 调用才检查 */
+        lazy?: boolean;
     };
     cache?: {
         /** 内存缓存最大条目数，默认 `200` */
@@ -156,6 +160,7 @@ export interface ResolvedModuleOptions {
         dictEndpoint: string;
         versionEndpoint: string;
         adapter?: string;
+        lazy: boolean;
     };
     cache: {
         memoryMax: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lacqjs/nuxt-dict",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Nuxt 数据字典模块，提供扁平/树形字典翻译、多语言国际化、三级缓存与 SSR 预取。",
   "keywords": [
     "@lacqjs/nuxt-dict",
@@ -44,7 +44,8 @@
     "@nuxt/kit": "^4.4.8",
     "compare-versions": "^6.1.1",
     "consola": "^3.4.2",
-    "defu": "^6.1.7"
+    "defu": "^6.1.7",
+    "dexie": "^4.4.4"
   },
   "devDependencies": {
     "@nuxt/devtools": "^3.2.4",