@shuo-li/i18n 1.0.0

package/dist/native/index.js

@@ -0,0 +1,175 @@
+import {
+  WebWorkerAdapter,
+  useDict,
+  useTranslation
+} from "../chunk-VUDMWZAA.js";
+import {
+  I18N_RESOURCES_UPDATED_EVENT,
+  createI18nManager,
+  emitI18nResourcesUpdated
+} from "../chunk-ONDHZEK4.js";
+
+// src/native/index.ts
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+
+// src/storage/sqlite.ts
+var DB_NAME = "i18n_cache";
+var SCHEMA_VERSION = 2;
+function resourceTable(name) {
+  return `i18n_resources_${name}`;
+}
+var dbInstance = null;
+async function getDB() {
+  if (dbInstance) return dbInstance;
+  const { open } = await import("@op-engineering/op-sqlite");
+  dbInstance = open({ name: DB_NAME });
+  return dbInstance;
+}
+async function execute(sql, params = []) {
+  const db = await getDB();
+  return db.executeAsync(sql, params);
+}
+var SQLiteAdapter = class {
+  async ensureSchemaVersion(stores) {
+    await execute(`
+      CREATE TABLE IF NOT EXISTS i18n_meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    const stored = await this.getMeta("schema_version");
+    const storedVersion = Number(stored ?? 0);
+    if (storedVersion === 0) {
+      await this.createTables(stores);
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion < SCHEMA_VERSION) {
+      for (const store of stores) {
+        await execute(`DROP TABLE IF EXISTS ${resourceTable(store.name)}`);
+      }
+      await this.createTables(stores);
+      await this.setMeta("schema_version", String(SCHEMA_VERSION));
+    } else if (storedVersion > SCHEMA_VERSION) {
+      throw new Error(`[i18n] SQLite schema version ${storedVersion} > current ${SCHEMA_VERSION}`);
+    }
+  }
+  async createTables(stores) {
+    for (const store of stores) {
+      const table = resourceTable(store.name);
+      await execute(`
+        CREATE TABLE IF NOT EXISTS ${table} (
+          key               TEXT PRIMARY KEY,
+          module_code TEXT NOT NULL,
+          lang_code         TEXT NOT NULL,
+          version           INTEGER NOT NULL DEFAULT 0,
+          resources         TEXT NOT NULL
+        )
+      `);
+      await execute(
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_module ON ${table}(module_code)`
+      );
+      await execute(
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_language ON ${table}(lang_code)`
+      );
+    }
+  }
+  async getRecord(storeName, key) {
+    const { rows } = await execute(
+      `SELECT * FROM ${resourceTable(storeName)} WHERE key = ?`,
+      [key]
+    );
+    if (!rows.length) return void 0;
+    return rowToRecord(rows[0]);
+  }
+  async putRecord(storeName, record) {
+    await execute(
+      `INSERT OR REPLACE INTO ${resourceTable(storeName)}
+        (key, module_code, lang_code, version, resources)
+       VALUES (?, ?, ?, ?, ?)`,
+      [
+        record.key,
+        record.moduleCode,
+        record.langCode,
+        record.version,
+        JSON.stringify(record.resources)
+      ]
+    );
+  }
+  async getAllByModule(storeName, moduleCode) {
+    const { rows } = await execute(
+      `SELECT * FROM ${resourceTable(storeName)} WHERE module_code = ?`,
+      [moduleCode]
+    );
+    return rows.map((r) => rowToRecord(r));
+  }
+  async clearStore(storeName) {
+    await execute(`DELETE FROM ${resourceTable(storeName)}`);
+  }
+  async getMeta(key) {
+    const { rows } = await execute("SELECT value FROM i18n_meta WHERE key = ?", [key]);
+    if (!rows.length) return null;
+    return rows[0].value;
+  }
+  async setMeta(key, value) {
+    await execute(
+      "INSERT OR REPLACE INTO i18n_meta (key, value) VALUES (?, ?)",
+      [key, value]
+    );
+  }
+  async hasLoginResources(stores) {
+    for (const store of stores) {
+      const { rows } = await execute(
+        `SELECT key FROM ${resourceTable(store.name)}
+         WHERE key NOT LIKE 'UNLOGIN_%' LIMIT 1`
+      );
+      if (rows.length > 0) return true;
+    }
+    return false;
+  }
+};
+function rowToRecord(row) {
+  return {
+    key: row.key,
+    moduleCode: row.module_code,
+    langCode: row.lang_code,
+    version: row.version,
+    resources: JSON.parse(row.resources)
+  };
+}
+
+// src/native/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 SQLiteAdapter(),
+  // Hermes Worker（RN 0.71+），API 与 Web Worker 一致
+  createWorker: () => new WebWorkerAdapter(
+    new Worker("./workers/preload-worker-rn", { type: "module" })
+  )
+});
+export {
+  I18N_RESOURCES_UPDATED_EVENT,
+  closeSSE,
+  emitI18nResourcesUpdated,
+  ensureModules,
+  getAllRecordsByModule,
+  getResource,
+  initI18n,
+  useDict,
+  useTranslation
+};

package/dist/workers/preload-worker-rn.cjs

@@ -0,0 +1,91 @@
+"use strict"; function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/workers/preload-worker-rn.ts
+function flatToNested(flat) {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    const parts = key.split(".");
+    let cur = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof cur[part] !== "object" || cur[part] === null) cur[part] = {};
+      cur = cur[part];
+    }
+    cur[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+function parseI18nValues(values) {
+  const result = {};
+  for (const { termCode, langValue } of values) {
+    if (termCode && langValue !== void 0) result[termCode] = _nullishCoalesce(langValue, () => ( ""));
+  }
+  return result;
+}
+function buildKey(moduleCode, langCode, store) {
+  return store.cacheGroupKey ? `${moduleCode}_${langCode}_${store.cacheGroupKey}` : `${moduleCode}_${langCode}`;
+}
+function toQueryString(params) {
+  return new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)])
+  ).toString();
+}
+async function processTask(task, payload) {
+  const { baseURL, headers, pullPath, pullMethod, stores } = payload;
+  const params = {};
+  if (task.storeName) params["storeName"] = task.storeName;
+  if (task.langCode) params["langCode"] = task.langCode;
+  if (task.moduleCode) params["moduleCode"] = task.moduleCode;
+  if (task.version != null) params["version"] = String(task.version);
+  const url = baseURL + pullPath;
+  let res;
+  if (pullMethod === "POST") {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(params)
+    });
+  } else {
+    res = await fetch(`${url}?${toQueryString(params)}`, { headers });
+  }
+  if (!res.ok) throw new Error(`[i18n rn-worker] fetch failed: ${res.status}`);
+  const blocks = await res.json();
+  for (const block of blocks) {
+    for (const mod of _nullishCoalesce(block.modules, () => ( []))) {
+      const store = stores.find((s) => s.name === task.storeName);
+      if (!store) continue;
+      const storeIndex = stores.indexOf(store);
+      const key = buildKey(mod.moduleCode, block.langCode, store);
+      const parsed = parseI18nValues(_nullishCoalesce(mod.i18nValues, () => ( [])));
+      const resources = storeIndex === 0 ? flatToNested(parsed) : parsed;
+      self.postMessage({
+        type: "dataReady",
+        storeName: store.name,
+        storeIndex,
+        record: {
+          key,
+          moduleCode: mod.moduleCode,
+          langCode: block.langCode,
+          version: mod.version,
+          resources
+        },
+        task
+      });
+    }
+  }
+}
+self.onmessage = async (event) => {
+  if (event.data.type !== "start") return;
+  const { payload } = event.data;
+  for (const task of payload.tasks) {
+    try {
+      await processTask(task, payload);
+    } catch (e) {
+      self.postMessage({
+        type: "moduleError",
+        storeName: task.storeName,
+        langCode: task.langCode,
+        moduleCode: task.moduleCode
+      });
+    }
+  }
+  self.postMessage({ type: "done" });
+};

package/dist/workers/preload-worker-rn.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/workers/preload-worker-rn.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/workers/preload-worker-rn.js

@@ -0,0 +1,91 @@
+// src/workers/preload-worker-rn.ts
+function flatToNested(flat) {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    const parts = key.split(".");
+    let cur = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof cur[part] !== "object" || cur[part] === null) cur[part] = {};
+      cur = cur[part];
+    }
+    cur[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+function parseI18nValues(values) {
+  const result = {};
+  for (const { termCode, langValue } of values) {
+    if (termCode && langValue !== void 0) result[termCode] = langValue ?? "";
+  }
+  return result;
+}
+function buildKey(moduleCode, langCode, store) {
+  return store.cacheGroupKey ? `${moduleCode}_${langCode}_${store.cacheGroupKey}` : `${moduleCode}_${langCode}`;
+}
+function toQueryString(params) {
+  return new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)])
+  ).toString();
+}
+async function processTask(task, payload) {
+  const { baseURL, headers, pullPath, pullMethod, stores } = payload;
+  const params = {};
+  if (task.storeName) params["storeName"] = task.storeName;
+  if (task.langCode) params["langCode"] = task.langCode;
+  if (task.moduleCode) params["moduleCode"] = task.moduleCode;
+  if (task.version != null) params["version"] = String(task.version);
+  const url = baseURL + pullPath;
+  let res;
+  if (pullMethod === "POST") {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(params)
+    });
+  } else {
+    res = await fetch(`${url}?${toQueryString(params)}`, { headers });
+  }
+  if (!res.ok) throw new Error(`[i18n rn-worker] fetch failed: ${res.status}`);
+  const blocks = await res.json();
+  for (const block of blocks) {
+    for (const mod of block.modules ?? []) {
+      const store = stores.find((s) => s.name === task.storeName);
+      if (!store) continue;
+      const storeIndex = stores.indexOf(store);
+      const key = buildKey(mod.moduleCode, block.langCode, store);
+      const parsed = parseI18nValues(mod.i18nValues ?? []);
+      const resources = storeIndex === 0 ? flatToNested(parsed) : parsed;
+      self.postMessage({
+        type: "dataReady",
+        storeName: store.name,
+        storeIndex,
+        record: {
+          key,
+          moduleCode: mod.moduleCode,
+          langCode: block.langCode,
+          version: mod.version,
+          resources
+        },
+        task
+      });
+    }
+  }
+}
+self.onmessage = async (event) => {
+  if (event.data.type !== "start") return;
+  const { payload } = event.data;
+  for (const task of payload.tasks) {
+    try {
+      await processTask(task, payload);
+    } catch {
+      self.postMessage({
+        type: "moduleError",
+        storeName: task.storeName,
+        langCode: task.langCode,
+        moduleCode: task.moduleCode
+      });
+    }
+  }
+  self.postMessage({ type: "done" });
+};

package/dist/workers/preload-worker.cjs

@@ -0,0 +1,169 @@
+"use strict"; 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; }// src/workers/preload-worker.ts
+function flatToNested(flat) {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    const parts = key.split(".");
+    let cur = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (typeof cur[part] !== "object" || cur[part] === null) cur[part] = {};
+      cur = cur[part];
+    }
+    cur[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, sv] of Object.entries(source)) {
+    const tv = result[key];
+    if (sv !== null && typeof sv === "object" && !Array.isArray(sv) && tv !== null && typeof tv === "object" && !Array.isArray(tv)) {
+      result[key] = deepMerge(tv, sv);
+    } else {
+      result[key] = sv;
+    }
+  }
+  return result;
+}
+function parseI18nValues(values) {
+  const result = {};
+  for (const { termCode, langValue } of values) {
+    if (termCode && langValue !== void 0) result[termCode] = _nullishCoalesce(langValue, () => ( ""));
+  }
+  return result;
+}
+function buildKey(moduleCode, langCode, store) {
+  return store.cacheGroupKey ? `${moduleCode}_${langCode}_${store.cacheGroupKey}` : `${moduleCode}_${langCode}`;
+}
+function toQueryString(params) {
+  return new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)])
+  ).toString();
+}
+var db = null;
+function openDB(dbName, storeNames) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName, 2);
+    req.onupgradeneeded = (event) => {
+      const database = event.target.result;
+      for (const name of storeNames) {
+        const storeName = `i18n_resources_${name}`;
+        if (!database.objectStoreNames.contains(storeName)) {
+          const s = database.createObjectStore(storeName, { keyPath: "key" });
+          s.createIndex("by_module", "moduleCode");
+          s.createIndex("by_language", "langCode");
+        }
+      }
+      if (!database.objectStoreNames.contains("i18n_meta")) {
+        database.createObjectStore("i18n_meta", { keyPath: "key" });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbGet(database, storeName, key) {
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(storeName, "readonly");
+    const req = tx.objectStore(storeName).get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbPut(database, storeName, value) {
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(storeName, "readwrite");
+    const req = tx.objectStore(storeName).put(value);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+async function processTask(task, payload) {
+  const { baseURL, headers, pullPath, pullMethod, stores } = payload;
+  const params = {};
+  if (task.storeName) params["storeName"] = task.storeName;
+  if (task.langCode) params["langCode"] = task.langCode;
+  if (task.moduleCode) params["moduleCode"] = task.moduleCode;
+  if (task.version != null) params["version"] = String(task.version);
+  const url = baseURL + pullPath;
+  let res;
+  if (pullMethod === "POST") {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(params)
+    });
+  } else {
+    res = await fetch(`${url}?${toQueryString(params)}`, { headers });
+  }
+  if (!res.ok) throw new Error(`[i18n worker] fetch failed: ${res.status}`);
+  const blocks = await res.json();
+  for (const block of blocks) {
+    for (const mod of _nullishCoalesce(block.modules, () => ( []))) {
+      const store = stores.find((s) => s.name === task.storeName);
+      if (!store) continue;
+      const storeIndex = stores.indexOf(store);
+      const idbStoreName = `i18n_resources_${store.name}`;
+      const key = buildKey(mod.moduleCode, block.langCode, store);
+      const parsed = parseI18nValues(_nullishCoalesce(mod.i18nValues, () => ( [])));
+      let resources;
+      if (storeIndex === 0) {
+        const existing = await idbGet(
+          db,
+          idbStoreName,
+          key
+        );
+        resources = deepMerge(
+          _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _ => _.resources]), () => ( {})),
+          flatToNested(parsed)
+        );
+      } else {
+        const existing = await idbGet(
+          db,
+          idbStoreName,
+          key
+        );
+        resources = { ..._nullishCoalesce(_optionalChain([existing, 'optionalAccess', _2 => _2.resources]), () => ( {})), ...parsed };
+      }
+      const record = {
+        key,
+        moduleCode: mod.moduleCode,
+        langCode: block.langCode,
+        version: mod.version,
+        resources
+      };
+      await idbPut(db, idbStoreName, record);
+      self.postMessage({
+        type: "moduleLoaded",
+        storeName: task.storeName,
+        langCode: block.langCode,
+        moduleCode: mod.moduleCode,
+        version: mod.version
+      });
+    }
+  }
+}
+self.onmessage = async (event) => {
+  if (event.data.type !== "start") return;
+  const { payload } = event.data;
+  const storeNames = payload.stores.map((s) => s.name);
+  try {
+    db = await openDB(payload.dbName, storeNames);
+  } catch (err) {
+    self.postMessage({ type: "error", message: String(err) });
+    return;
+  }
+  for (const task of payload.tasks) {
+    try {
+      await processTask(task, payload);
+    } catch (e) {
+      self.postMessage({
+        type: "moduleError",
+        storeName: task.storeName,
+        langCode: task.langCode,
+        moduleCode: task.moduleCode
+      });
+    }
+  }
+  self.postMessage({ type: "done" });
+};

package/dist/workers/preload-worker.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/workers/preload-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }