@shuo-li/i18n 1.0.0

package/dist/mp/index.cjs

@@ -0,0 +1,231 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkJDOLFHBScjs = require('../chunk-JDOLFHBS.cjs');
+
+// src/storage/wx-sqlite.ts
+var DB_NAME = "i18n_cache";
+var SCHEMA_VERSION = 2;
+function resourceTable(name) {
+  return `i18n_resources_${name}`;
+}
+var dbInstance = null;
+function getDB() {
+  if (dbInstance) return Promise.resolve(dbInstance);
+  return new Promise((resolve, reject) => {
+    const db = wx.openDatabase({
+      name: DB_NAME,
+      success: () => {
+        dbInstance = db;
+        resolve(db);
+      },
+      fail: (err) => reject(new Error(`[i18n] wx.openDatabase failed: ${JSON.stringify(err)}`))
+    });
+  });
+}
+function exec(db, sql, args = []) {
+  return new Promise((resolve, reject) => {
+    db.transaction((tx) => {
+      tx.executeSql(
+        sql,
+        args,
+        (_tx, result) => resolve(result),
+        (_tx, err) => {
+          reject(err);
+          return true;
+        }
+      );
+    });
+  });
+}
+var WxSQLiteAdapter = class {
+  async ensureSchemaVersion(stores) {
+    const db = await getDB();
+    await exec(db, `
+      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(_nullishCoalesce(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 exec(db, `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] wx.openDatabase schema version ${storedVersion} > current ${SCHEMA_VERSION}`);
+    }
+  }
+  async createTables(stores) {
+    const db = await getDB();
+    for (const store of stores) {
+      const table = resourceTable(store.name);
+      await exec(db, `
+        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 exec(
+        db,
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_module ON ${table}(module_code)`
+      );
+      await exec(
+        db,
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_language ON ${table}(lang_code)`
+      );
+    }
+  }
+  async getRecord(storeName, key) {
+    const db = await getDB();
+    const result = await exec(
+      db,
+      `SELECT * FROM ${resourceTable(storeName)} WHERE key = ?`,
+      [key]
+    );
+    if (result.rows.length === 0) return void 0;
+    return rowToRecord(result.rows.item(0));
+  }
+  async putRecord(storeName, record) {
+    const db = await getDB();
+    await exec(
+      db,
+      `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 db = await getDB();
+    const result = await exec(
+      db,
+      `SELECT * FROM ${resourceTable(storeName)} WHERE module_code = ?`,
+      [moduleCode]
+    );
+    const records = [];
+    for (let i = 0; i < result.rows.length; i++) {
+      records.push(rowToRecord(result.rows.item(i)));
+    }
+    return records;
+  }
+  async clearStore(storeName) {
+    const db = await getDB();
+    await exec(db, `DELETE FROM ${resourceTable(storeName)}`);
+  }
+  async getMeta(key) {
+    const db = await getDB();
+    const result = await exec(db, "SELECT value FROM i18n_meta WHERE key = ?", [key]);
+    if (result.rows.length === 0) return null;
+    return result.rows.item(0).value;
+  }
+  async setMeta(key, value) {
+    const db = await getDB();
+    await exec(db, "INSERT OR REPLACE INTO i18n_meta (key, value) VALUES (?, ?)", [key, value]);
+  }
+  async hasLoginResources(stores) {
+    const db = await getDB();
+    for (const store of stores) {
+      const result = await exec(
+        db,
+        `SELECT key FROM ${resourceTable(store.name)}
+         WHERE key NOT LIKE 'UNLOGIN_%' LIMIT 1`
+      );
+      if (result.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/adapters/wx-worker-adapter.ts
+var WxWorkerAdapter = class {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  postMessage(data) {
+    this.worker.postMessage(data);
+  }
+  onMessage(handler) {
+    this.worker.onMessage((res) => handler(res));
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+};
+
+// src/polyfills/wx-fetch.ts
+function toPlainHeaders(h) {
+  if (!h) return {};
+  if (h instanceof Headers) {
+    const r = {};
+    h.forEach((v, k) => {
+      r[k] = v;
+    });
+    return r;
+  }
+  if (Array.isArray(h)) return Object.fromEntries(h);
+  return h;
+}
+function wxFetch(input, init) {
+  return new Promise((resolve, reject) => {
+    const body = _optionalChain([init, 'optionalAccess', _ => _.body]) ? JSON.parse(String(init.body)) : void 0;
+    wx.request({
+      url: input,
+      method: _nullishCoalesce(_optionalChain([init, 'optionalAccess', _2 => _2.method]), () => ( "GET")),
+      header: toPlainHeaders(_optionalChain([init, 'optionalAccess', _3 => _3.headers])),
+      data: body,
+      success: (res) => {
+        resolve(
+          new Response(JSON.stringify(res.data), {
+            status: res.statusCode,
+            headers: res.header
+          })
+        );
+      },
+      fail: (err) => {
+        reject(new Error(err.errMsg));
+      }
+    });
+  });
+}
+
+// src/mp/index.ts
+var { initI18n, closeSSE, ensureModules, getResource, getAllRecordsByModule } = _chunkJDOLFHBScjs.createI18nManager.call(void 0, {
+  storage: new WxSQLiteAdapter(),
+  createWorker: () => new WxWorkerAdapter(wx.createWorker("workers/preload-worker-mp.js")),
+  fetchFn: wxFetch
+});
+
+
+
+
+
+
+
+
+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;

package/dist/mp/index.d.cts

@@ -0,0 +1,10 @@
+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, h as emitI18nResourcesUpdated } from '../cacheEvents-kOPDM3Ed.cjs';
+
+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/mp/index.d.ts

@@ -0,0 +1,10 @@
+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, h as emitI18nResourcesUpdated } from '../cacheEvents-kOPDM3Ed.js';
+
+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/mp/index.js

@@ -0,0 +1,231 @@
+import {
+  I18N_RESOURCES_UPDATED_EVENT,
+  createI18nManager,
+  emitI18nResourcesUpdated
+} from "../chunk-ONDHZEK4.js";
+
+// src/storage/wx-sqlite.ts
+var DB_NAME = "i18n_cache";
+var SCHEMA_VERSION = 2;
+function resourceTable(name) {
+  return `i18n_resources_${name}`;
+}
+var dbInstance = null;
+function getDB() {
+  if (dbInstance) return Promise.resolve(dbInstance);
+  return new Promise((resolve, reject) => {
+    const db = wx.openDatabase({
+      name: DB_NAME,
+      success: () => {
+        dbInstance = db;
+        resolve(db);
+      },
+      fail: (err) => reject(new Error(`[i18n] wx.openDatabase failed: ${JSON.stringify(err)}`))
+    });
+  });
+}
+function exec(db, sql, args = []) {
+  return new Promise((resolve, reject) => {
+    db.transaction((tx) => {
+      tx.executeSql(
+        sql,
+        args,
+        (_tx, result) => resolve(result),
+        (_tx, err) => {
+          reject(err);
+          return true;
+        }
+      );
+    });
+  });
+}
+var WxSQLiteAdapter = class {
+  async ensureSchemaVersion(stores) {
+    const db = await getDB();
+    await exec(db, `
+      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 exec(db, `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] wx.openDatabase schema version ${storedVersion} > current ${SCHEMA_VERSION}`);
+    }
+  }
+  async createTables(stores) {
+    const db = await getDB();
+    for (const store of stores) {
+      const table = resourceTable(store.name);
+      await exec(db, `
+        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 exec(
+        db,
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_module ON ${table}(module_code)`
+      );
+      await exec(
+        db,
+        `CREATE INDEX IF NOT EXISTS idx_${store.name}_language ON ${table}(lang_code)`
+      );
+    }
+  }
+  async getRecord(storeName, key) {
+    const db = await getDB();
+    const result = await exec(
+      db,
+      `SELECT * FROM ${resourceTable(storeName)} WHERE key = ?`,
+      [key]
+    );
+    if (result.rows.length === 0) return void 0;
+    return rowToRecord(result.rows.item(0));
+  }
+  async putRecord(storeName, record) {
+    const db = await getDB();
+    await exec(
+      db,
+      `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 db = await getDB();
+    const result = await exec(
+      db,
+      `SELECT * FROM ${resourceTable(storeName)} WHERE module_code = ?`,
+      [moduleCode]
+    );
+    const records = [];
+    for (let i = 0; i < result.rows.length; i++) {
+      records.push(rowToRecord(result.rows.item(i)));
+    }
+    return records;
+  }
+  async clearStore(storeName) {
+    const db = await getDB();
+    await exec(db, `DELETE FROM ${resourceTable(storeName)}`);
+  }
+  async getMeta(key) {
+    const db = await getDB();
+    const result = await exec(db, "SELECT value FROM i18n_meta WHERE key = ?", [key]);
+    if (result.rows.length === 0) return null;
+    return result.rows.item(0).value;
+  }
+  async setMeta(key, value) {
+    const db = await getDB();
+    await exec(db, "INSERT OR REPLACE INTO i18n_meta (key, value) VALUES (?, ?)", [key, value]);
+  }
+  async hasLoginResources(stores) {
+    const db = await getDB();
+    for (const store of stores) {
+      const result = await exec(
+        db,
+        `SELECT key FROM ${resourceTable(store.name)}
+         WHERE key NOT LIKE 'UNLOGIN_%' LIMIT 1`
+      );
+      if (result.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/adapters/wx-worker-adapter.ts
+var WxWorkerAdapter = class {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  postMessage(data) {
+    this.worker.postMessage(data);
+  }
+  onMessage(handler) {
+    this.worker.onMessage((res) => handler(res));
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+};
+
+// src/polyfills/wx-fetch.ts
+function toPlainHeaders(h) {
+  if (!h) return {};
+  if (h instanceof Headers) {
+    const r = {};
+    h.forEach((v, k) => {
+      r[k] = v;
+    });
+    return r;
+  }
+  if (Array.isArray(h)) return Object.fromEntries(h);
+  return h;
+}
+function wxFetch(input, init) {
+  return new Promise((resolve, reject) => {
+    const body = init?.body ? JSON.parse(String(init.body)) : void 0;
+    wx.request({
+      url: input,
+      method: init?.method ?? "GET",
+      header: toPlainHeaders(init?.headers),
+      data: body,
+      success: (res) => {
+        resolve(
+          new Response(JSON.stringify(res.data), {
+            status: res.statusCode,
+            headers: res.header
+          })
+        );
+      },
+      fail: (err) => {
+        reject(new Error(err.errMsg));
+      }
+    });
+  });
+}
+
+// src/mp/index.ts
+var { initI18n, closeSSE, ensureModules, getResource, getAllRecordsByModule } = createI18nManager({
+  storage: new WxSQLiteAdapter(),
+  createWorker: () => new WxWorkerAdapter(wx.createWorker("workers/preload-worker-mp.js")),
+  fetchFn: wxFetch
+});
+export {
+  I18N_RESOURCES_UPDATED_EVENT,
+  closeSSE,
+  emitI18nResourcesUpdated,
+  ensureModules,
+  getAllRecordsByModule,
+  getResource,
+  initI18n
+};

package/dist/native/index.cjs

@@ -0,0 +1,175 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+var _chunkAJJKJPNBcjs = require('../chunk-AJJKJPNB.cjs');
+
+
+
+
+var _chunkJDOLFHBScjs = require('../chunk-JDOLFHBS.cjs');
+
+// src/native/index.ts
+var _i18next = require('i18next'); var _i18next2 = _interopRequireDefault(_i18next);
+var _reacti18next = require('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 Promise.resolve().then(() => _interopRequireWildcard(require("@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(_nullishCoalesce(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 (!_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 SQLiteAdapter(),
+  // Hermes Worker（RN 0.71+），API 与 Web Worker 一致
+  createWorker: () => new (0, _chunkAJJKJPNBcjs.WebWorkerAdapter)(
+    new Worker("./workers/preload-worker-rn", { 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/native/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, 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/native/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, 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 };