@shuo-li/i18n 1.0.0

package/dist/chunk-VUDMWZAA.js

@@ -0,0 +1,88 @@
+// src/adapters/web-worker-adapter.ts
+var WebWorkerAdapter = class {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  postMessage(data) {
+    this.worker.postMessage(data);
+  }
+  onMessage(handler) {
+    this.worker.onmessage = (e) => handler(e.data);
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+};
+
+// src/core/hooks.ts
+import {
+  useTranslation,
+  Trans,
+  I18nextProvider
+} from "react-i18next";
+import { useTranslation as useTranslation2 } from "react-i18next";
+import { useMemo } from "react";
+function useDict(dictCode) {
+  const { t, i18n } = useTranslation2("ENUMS");
+  return useMemo(() => {
+    const directNs = i18n.getResourceBundle(i18n.language, "ENUMS");
+    const directEntry = directNs?.[dictCode];
+    if (directEntry && typeof directEntry === "object" && !Array.isArray(directEntry)) {
+      const raw = directEntry;
+      return {
+        raw,
+        options: Object.entries(raw).map(([value, label]) => ({ value, label }))
+      };
+    }
+    const wmsDict = directNs?.["wms_dict_value"]?.["dict_value_name_term_value"];
+    if (wmsDict) {
+      const prefix = `${dictCode}_`;
+      const raw = {};
+      for (const [k, v] of Object.entries(wmsDict)) {
+        if (k.startsWith(prefix)) {
+          raw[k.slice(prefix.length)] = v;
+        }
+      }
+      if (Object.keys(raw).length > 0) {
+        return {
+          raw,
+          options: Object.entries(raw).map(([value, label]) => ({ value, label }))
+        };
+      }
+    }
+    if (dictCode === "bool_active") {
+      return buildBoolActive(i18n.language, i18n);
+    }
+    const fallbackKey = `${dictCode}`;
+    const fallbackVal = t(fallbackKey, { returnObjects: true });
+    if (fallbackVal && typeof fallbackVal === "object") {
+      const raw = fallbackVal;
+      return {
+        raw,
+        options: Object.entries(raw).map(([value, label]) => ({ value, label }))
+      };
+    }
+    return { raw: {}, options: [] };
+  }, [dictCode, i18n.language]);
+}
+function buildBoolActive(lang, i18n) {
+  const common = i18n.getResourceBundle(lang, "COMMON");
+  const booleans = common?.["select"]?.["boolean"];
+  const button = common?.["button"];
+  const trueLabel = button?.["enable"] ?? booleans?.["true"] ?? "\u542F\u7528";
+  const falseLabel = button?.["deactivate"] ?? booleans?.["false"] ?? "\u505C\u7528";
+  const raw = { true: trueLabel, false: falseLabel };
+  return {
+    raw,
+    options: [
+      { value: "true", label: trueLabel },
+      { value: "false", label: falseLabel }
+    ]
+  };
+}
+
+export {
+  WebWorkerAdapter,
+  useDict,
+  useTranslation
+};

package/dist/hooks-ClO29Chr.d.cts

@@ -0,0 +1,16 @@
+interface DictResult {
+    raw: Record<string, string>;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/**
+ * 从 ENUMS namespace 读取指定字典码。
+ * 支持两种后端格式：
+ *   格式 A：{ "warehouse_type": { "standard": "标准仓" } }
+ *   格式 B：{ "wms_dict_value": { "dict_value_name_term_value": { "warehouse_type_standard": "标准仓" } } }
+ */
+declare function useDict(dictCode: string): DictResult;
+
+export { useDict as u };

package/dist/hooks-ClO29Chr.d.ts

@@ -0,0 +1,16 @@
+interface DictResult {
+    raw: Record<string, string>;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/**
+ * 从 ENUMS namespace 读取指定字典码。
+ * 支持两种后端格式：
+ *   格式 A：{ "warehouse_type": { "standard": "标准仓" } }
+ *   格式 B：{ "wms_dict_value": { "dict_value_name_term_value": { "warehouse_type_standard": "标准仓" } } }
+ */
+declare function useDict(dictCode: string): DictResult;
+
+export { useDict as u };

package/dist/index.cjs

@@ -0,0 +1,223 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkAJJKJPNBcjs = require('./chunk-AJJKJPNB.cjs');
+
+
+
+
+var _chunkJDOLFHBScjs = require('./chunk-JDOLFHBS.cjs');
+
+// src/index.ts
+var _i18next = require('i18next'); var _i18next2 = _interopRequireDefault(_i18next);
+var _reacti18next = require('react-i18next');
+
+// src/storage/indexeddb.ts
+var DB_NAME = "i18n_cache";
+var SCHEMA_VERSION = 2;
+var META_STORE = "i18n_meta";
+function resourceStoreName(name) {
+  return `i18n_resources_${name}`;
+}
+var dbInstance = null;
+var dbOpenPromise = null;
+var dbStoreNames = [];
+function openDB(storeNames) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, SCHEMA_VERSION);
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      for (const name of storeNames) {
+        const storeName = resourceStoreName(name);
+        if (!db.objectStoreNames.contains(storeName)) {
+          const s = db.createObjectStore(storeName, { keyPath: "key" });
+          s.createIndex("by_module", "moduleCode");
+          s.createIndex("by_language", "langCode");
+        }
+      }
+      if (!db.objectStoreNames.contains(META_STORE)) {
+        db.createObjectStore(META_STORE, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => {
+        db.close();
+        dbInstance = null;
+        dbOpenPromise = null;
+      };
+      db.onclose = () => {
+        dbInstance = null;
+        dbOpenPromise = null;
+      };
+      resolve(db);
+    };
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => reject(new Error("[i18n] IndexedDB open blocked"));
+  });
+}
+function getDB(storeNames) {
+  if (dbInstance) return Promise.resolve(dbInstance);
+  if (!dbOpenPromise) {
+    dbOpenPromise = openDB(_nullishCoalesce(storeNames, () => ( dbStoreNames))).then((db) => {
+      dbInstance = db;
+      dbOpenPromise = null;
+      return db;
+    }).catch((err) => {
+      dbOpenPromise = null;
+      throw err;
+    });
+  }
+  return dbOpenPromise;
+}
+function idbRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function withRetry(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    dbInstance = null;
+    return fn();
+  }
+}
+var IndexedDBAdapter = class {
+  async ensureSchemaVersion(stores) {
+    dbStoreNames = stores.map((s) => s.name);
+    const db = await getDB(dbStoreNames);
+    const stored = await this.getMeta("schema_version");
+    const storedVersion = Number(_nullishCoalesce(stored, () => ( 0)));
+    if (storedVersion === 0) {
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion < SCHEMA_VERSION) {
+      db.close();
+      dbInstance = null;
+      await new Promise((resolve, reject) => {
+        const req = indexedDB.deleteDatabase(DB_NAME);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+      });
+      dbInstance = await openDB(dbStoreNames);
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion > SCHEMA_VERSION) {
+      throw new Error(`[i18n] DB schema version ${storedVersion} > current ${SCHEMA_VERSION}`);
+    }
+  }
+  async getRecord(storeName, key) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readonly");
+      const store = tx.objectStore(resourceStoreName(storeName));
+      return idbRequest(store.get(key));
+    });
+  }
+  async putRecord(storeName, record) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readwrite");
+      const store = tx.objectStore(resourceStoreName(storeName));
+      await idbRequest(store.put(record));
+    });
+  }
+  async getAllByModule(storeName, moduleCode) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readonly");
+      const index = tx.objectStore(resourceStoreName(storeName)).index("by_module");
+      return idbRequest(index.getAll(moduleCode));
+    });
+  }
+  async clearStore(storeName) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readwrite");
+      await idbRequest(tx.objectStore(resourceStoreName(storeName)).clear());
+    });
+  }
+  async getMeta(key) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(META_STORE, "readonly");
+      const result = await idbRequest(
+        tx.objectStore(META_STORE).get(key)
+      );
+      return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _ => _.value]), () => ( null));
+    });
+  }
+  async setMeta(key, value) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(META_STORE, "readwrite");
+      await idbRequest(tx.objectStore(META_STORE).put({ key, value }));
+    });
+  }
+  async hasLoginResources(stores) {
+    return withRetry(async () => {
+      const db = await getDB();
+      for (const store of stores) {
+        const tx = db.transaction(resourceStoreName(store.name), "readonly");
+        const objStore = tx.objectStore(resourceStoreName(store.name));
+        const found = await new Promise((resolve, reject) => {
+          const req = objStore.openCursor();
+          req.onerror = () => reject(req.error);
+          req.onsuccess = () => {
+            const cursor = req.result;
+            if (!cursor) {
+              resolve(false);
+              return;
+            }
+            const record = cursor.value;
+            if (!record.key.startsWith("UNLOGIN_")) {
+              resolve(true);
+              return;
+            }
+            cursor.continue();
+          };
+        });
+        if (found) return true;
+      }
+      return false;
+    });
+  }
+};
+
+// src/index.ts
+if (!_i18next2.default.isInitialized) {
+  void _i18next2.default.use(_reacti18next.initReactI18next).init({
+    lng: "__loading__",
+    fallbackLng: "zh_CN",
+    ns: ["COMMON"],
+    defaultNS: "COMMON",
+    resources: {},
+    interpolation: { escapeValue: false },
+    react: {
+      useSuspense: false,
+      bindI18n: "languageChanged",
+      bindI18nStore: "added removed",
+      transSupportBasicHtmlNodes: true,
+      transKeepBasicHtmlNodesFor: ["br", "p", "strong", "i", "em", "b", "a", "span"]
+    }
+  });
+}
+var { initI18n, closeSSE, ensureModules, getResource, getAllRecordsByModule } = _chunkJDOLFHBScjs.createI18nManager.call(void 0, {
+  storage: new IndexedDBAdapter(),
+  workerWritesDB: true,
+  createWorker: () => new (0, _chunkAJJKJPNBcjs.WebWorkerAdapter)(
+    new Worker(new URL("./workers/preload-worker.js", import.meta.url), { type: "module" })
+  )
+});
+
+
+
+
+
+
+
+
+
+
+exports.I18N_RESOURCES_UPDATED_EVENT = _chunkJDOLFHBScjs.I18N_RESOURCES_UPDATED_EVENT; exports.closeSSE = closeSSE; exports.emitI18nResourcesUpdated = _chunkJDOLFHBScjs.emitI18nResourcesUpdated; exports.ensureModules = ensureModules; exports.getAllRecordsByModule = getAllRecordsByModule; exports.getResource = getResource; exports.initI18n = initI18n; exports.useDict = _chunkAJJKJPNBcjs.useDict; exports.useTranslation = _chunkAJJKJPNBcjs.useTranslation;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { c as closeSSE$1, e as ensureModules$1, g as getAllRecordsByModule$1, a as getResource$1, i as initI18n$1 } from './cacheEvents-kOPDM3Ed.cjs';
+export { I as I18N_RESOURCES_UPDATED_EVENT, b as I18nInitOptions, P as PullLangBlock, R as ResourceRecord, S as SSEMessage, d as StandardPullParams, f as StoreConfig, W as WorkerLike, h as emitI18nResourcesUpdated } from './cacheEvents-kOPDM3Ed.cjs';
+export { u as useDict } from './hooks-ClO29Chr.cjs';
+export { useTranslation } from 'react-i18next';
+
+declare const initI18n: typeof initI18n$1;
+declare const closeSSE: typeof closeSSE$1;
+declare const ensureModules: typeof ensureModules$1;
+declare const getResource: typeof getResource$1;
+declare const getAllRecordsByModule: typeof getAllRecordsByModule$1;
+
+export { closeSSE, ensureModules, getAllRecordsByModule, getResource, initI18n };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { c as closeSSE$1, e as ensureModules$1, g as getAllRecordsByModule$1, a as getResource$1, i as initI18n$1 } from './cacheEvents-kOPDM3Ed.js';
+export { I as I18N_RESOURCES_UPDATED_EVENT, b as I18nInitOptions, P as PullLangBlock, R as ResourceRecord, S as SSEMessage, d as StandardPullParams, f as StoreConfig, W as WorkerLike, h as emitI18nResourcesUpdated } from './cacheEvents-kOPDM3Ed.js';
+export { u as useDict } from './hooks-ClO29Chr.js';
+export { useTranslation } from 'react-i18next';
+
+declare const initI18n: typeof initI18n$1;
+declare const closeSSE: typeof closeSSE$1;
+declare const ensureModules: typeof ensureModules$1;
+declare const getResource: typeof getResource$1;
+declare const getAllRecordsByModule: typeof getAllRecordsByModule$1;
+
+export { closeSSE, ensureModules, getAllRecordsByModule, getResource, initI18n };

package/dist/index.js

@@ -0,0 +1,223 @@
+import {
+  WebWorkerAdapter,
+  useDict,
+  useTranslation
+} from "./chunk-VUDMWZAA.js";
+import {
+  I18N_RESOURCES_UPDATED_EVENT,
+  createI18nManager,
+  emitI18nResourcesUpdated
+} from "./chunk-ONDHZEK4.js";
+
+// src/index.ts
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+
+// src/storage/indexeddb.ts
+var DB_NAME = "i18n_cache";
+var SCHEMA_VERSION = 2;
+var META_STORE = "i18n_meta";
+function resourceStoreName(name) {
+  return `i18n_resources_${name}`;
+}
+var dbInstance = null;
+var dbOpenPromise = null;
+var dbStoreNames = [];
+function openDB(storeNames) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, SCHEMA_VERSION);
+    request.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      for (const name of storeNames) {
+        const storeName = resourceStoreName(name);
+        if (!db.objectStoreNames.contains(storeName)) {
+          const s = db.createObjectStore(storeName, { keyPath: "key" });
+          s.createIndex("by_module", "moduleCode");
+          s.createIndex("by_language", "langCode");
+        }
+      }
+      if (!db.objectStoreNames.contains(META_STORE)) {
+        db.createObjectStore(META_STORE, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => {
+        db.close();
+        dbInstance = null;
+        dbOpenPromise = null;
+      };
+      db.onclose = () => {
+        dbInstance = null;
+        dbOpenPromise = null;
+      };
+      resolve(db);
+    };
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => reject(new Error("[i18n] IndexedDB open blocked"));
+  });
+}
+function getDB(storeNames) {
+  if (dbInstance) return Promise.resolve(dbInstance);
+  if (!dbOpenPromise) {
+    dbOpenPromise = openDB(storeNames ?? dbStoreNames).then((db) => {
+      dbInstance = db;
+      dbOpenPromise = null;
+      return db;
+    }).catch((err) => {
+      dbOpenPromise = null;
+      throw err;
+    });
+  }
+  return dbOpenPromise;
+}
+function idbRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function withRetry(fn) {
+  try {
+    return await fn();
+  } catch {
+    dbInstance = null;
+    return fn();
+  }
+}
+var IndexedDBAdapter = class {
+  async ensureSchemaVersion(stores) {
+    dbStoreNames = stores.map((s) => s.name);
+    const db = await getDB(dbStoreNames);
+    const stored = await this.getMeta("schema_version");
+    const storedVersion = Number(stored ?? 0);
+    if (storedVersion === 0) {
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion < SCHEMA_VERSION) {
+      db.close();
+      dbInstance = null;
+      await new Promise((resolve, reject) => {
+        const req = indexedDB.deleteDatabase(DB_NAME);
+        req.onsuccess = () => resolve();
+        req.onerror = () => reject(req.error);
+      });
+      dbInstance = await openDB(dbStoreNames);
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion > SCHEMA_VERSION) {
+      throw new Error(`[i18n] DB schema version ${storedVersion} > current ${SCHEMA_VERSION}`);
+    }
+  }
+  async getRecord(storeName, key) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readonly");
+      const store = tx.objectStore(resourceStoreName(storeName));
+      return idbRequest(store.get(key));
+    });
+  }
+  async putRecord(storeName, record) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readwrite");
+      const store = tx.objectStore(resourceStoreName(storeName));
+      await idbRequest(store.put(record));
+    });
+  }
+  async getAllByModule(storeName, moduleCode) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readonly");
+      const index = tx.objectStore(resourceStoreName(storeName)).index("by_module");
+      return idbRequest(index.getAll(moduleCode));
+    });
+  }
+  async clearStore(storeName) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(resourceStoreName(storeName), "readwrite");
+      await idbRequest(tx.objectStore(resourceStoreName(storeName)).clear());
+    });
+  }
+  async getMeta(key) {
+    return withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(META_STORE, "readonly");
+      const result = await idbRequest(
+        tx.objectStore(META_STORE).get(key)
+      );
+      return result?.value ?? null;
+    });
+  }
+  async setMeta(key, value) {
+    await withRetry(async () => {
+      const db = await getDB();
+      const tx = db.transaction(META_STORE, "readwrite");
+      await idbRequest(tx.objectStore(META_STORE).put({ key, value }));
+    });
+  }
+  async hasLoginResources(stores) {
+    return withRetry(async () => {
+      const db = await getDB();
+      for (const store of stores) {
+        const tx = db.transaction(resourceStoreName(store.name), "readonly");
+        const objStore = tx.objectStore(resourceStoreName(store.name));
+        const found = await new Promise((resolve, reject) => {
+          const req = objStore.openCursor();
+          req.onerror = () => reject(req.error);
+          req.onsuccess = () => {
+            const cursor = req.result;
+            if (!cursor) {
+              resolve(false);
+              return;
+            }
+            const record = cursor.value;
+            if (!record.key.startsWith("UNLOGIN_")) {
+              resolve(true);
+              return;
+            }
+            cursor.continue();
+          };
+        });
+        if (found) return true;
+      }
+      return false;
+    });
+  }
+};
+
+// src/index.ts
+if (!i18n.isInitialized) {
+  void i18n.use(initReactI18next).init({
+    lng: "__loading__",
+    fallbackLng: "zh_CN",
+    ns: ["COMMON"],
+    defaultNS: "COMMON",
+    resources: {},
+    interpolation: { escapeValue: false },
+    react: {
+      useSuspense: false,
+      bindI18n: "languageChanged",
+      bindI18nStore: "added removed",
+      transSupportBasicHtmlNodes: true,
+      transKeepBasicHtmlNodesFor: ["br", "p", "strong", "i", "em", "b", "a", "span"]
+    }
+  });
+}
+var { initI18n, closeSSE, ensureModules, getResource, getAllRecordsByModule } = createI18nManager({
+  storage: new IndexedDBAdapter(),
+  workerWritesDB: true,
+  createWorker: () => new WebWorkerAdapter(
+    new Worker(new URL("./workers/preload-worker.js", import.meta.url), { type: "module" })
+  )
+});
+export {
+  I18N_RESOURCES_UPDATED_EVENT,
+  closeSSE,
+  emitI18nResourcesUpdated,
+  ensureModules,
+  getAllRecordsByModule,
+  getResource,
+  initI18n,
+  useDict,
+  useTranslation
+};