@shuo-li/i18n 1.0.0

package/dist/chunk-JDOLFHBS.cjs

@@ -0,0 +1,664 @@
+"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(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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/core/cacheEvents.ts
+var I18N_RESOURCES_UPDATED_EVENT = "golucky:i18n-resources-updated";
+function emitI18nResourcesUpdated() {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent(I18N_RESOURCES_UPDATED_EVENT));
+}
+
+// src/core/manager.ts
+var _i18next = require('i18next'); var _i18next2 = _interopRequireDefault(_i18next);
+
+// src/core/sse.ts
+var RECONNECT_DELAYS = [1e3, 2e3, 5e3, 1e4, 3e4];
+var SSEClient = class {
+  constructor() {
+    this.options = null;
+    this.onMessage = null;
+    this.abortController = null;
+    this.reconnectAttempt = 0;
+    this.shouldReconnect = true;
+    this.reconnectTimer = null;
+    this.reconnectDelayOverride = null;
+  }
+  start(onMessage, options) {
+    this.options = options;
+    this.onMessage = onMessage;
+    this.shouldReconnect = true;
+    this.reconnectAttempt = 0;
+    void this.connect();
+  }
+  close() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    _optionalChain([this, 'access', _2 => _2.abortController, 'optionalAccess', _3 => _3.abort, 'call', _4 => _4()]);
+    this.abortController = null;
+  }
+  async connect() {
+    if (!this.options || !this.onMessage) return;
+    this.abortController = new AbortController();
+    await this.listen(this.abortController.signal);
+    if (this.shouldReconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  async listen(signal) {
+    if (!this.options || !this.onMessage) return;
+    const { baseURL, eventsPath, getHeaders } = this.options;
+    const url = new URL(eventsPath, baseURL).toString();
+    const headers = { Accept: "text/event-stream", ...getHeaders() };
+    let res;
+    try {
+      res = await fetch(url, { headers, signal });
+    } catch (e) {
+      return;
+    }
+    if (res.status === 401 || res.status === 403) {
+      this.shouldReconnect = false;
+      return;
+    }
+    if (res.status === 429) {
+      const retryAfter = res.headers.get("Retry-After");
+      if (retryAfter) {
+        this.reconnectDelayOverride = Number(retryAfter) * 1e3;
+      }
+      return;
+    }
+    if (!res.ok || !res.body) return;
+    this.reconnectAttempt = 0;
+    this.reconnectDelayOverride = null;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let heartbeatTimer = setTimeout(() => reader.cancel(), 3e4);
+    const resetHeartbeat = () => {
+      clearTimeout(heartbeatTimer);
+      heartbeatTimer = setTimeout(() => reader.cancel(), 3e4);
+    };
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        resetHeartbeat();
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = _nullishCoalesce(events.pop(), () => ( ""));
+        for (const event of events) {
+          this.parseEvent(event);
+        }
+      }
+    } finally {
+      clearTimeout(heartbeatTimer);
+    }
+  }
+  parseEvent(raw) {
+    let data = "";
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("data:")) {
+        data += line.slice(5).trim();
+      }
+    }
+    if (!data) return;
+    try {
+      const parsed = JSON.parse(data);
+      _optionalChain([this, 'access', _5 => _5.onMessage, 'optionalCall', _6 => _6(parsed)]);
+    } catch (e2) {
+    }
+  }
+  scheduleReconnect() {
+    if (!this.shouldReconnect) return;
+    const delay = _nullishCoalesce(this.reconnectDelayOverride, () => ( (_nullishCoalesce(RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)], () => ( 3e4)))));
+    this.reconnectAttempt++;
+    this.reconnectDelayOverride = null;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect();
+    }, delay);
+  }
+};
+
+// src/core/utils.ts
+function buildKey(moduleCode, langCode, store) {
+  return store.cacheGroupKey ? `${moduleCode}_${langCode}_${store.cacheGroupKey}` : `${moduleCode}_${langCode}`;
+}
+function buildUnloginKey(langCode) {
+  return `UNLOGIN_${langCode}`;
+}
+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 toDefaultParams(p) {
+  const result = {};
+  if (_optionalChain([p, 'optionalAccess', _7 => _7.storeName])) result["storeName"] = p.storeName;
+  if (_optionalChain([p, 'optionalAccess', _8 => _8.langCode])) result["langCode"] = p.langCode;
+  if (_optionalChain([p, 'optionalAccess', _9 => _9.moduleCode])) result["moduleCode"] = p.moduleCode;
+  if (_optionalChain([p, 'optionalAccess', _10 => _10.version]) != null) result["version"] = String(p.version);
+  return result;
+}
+function toQueryString(params) {
+  return new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)])
+  ).toString();
+}
+
+// src/core/worker-manager.ts
+var WorkerManager = class {
+  constructor() {
+    this.worker = null;
+    this.pendingCallbacks = /* @__PURE__ */ new Set();
+    this.finalized = false;
+  }
+  start(createWorker, payload, callbacks, storage) {
+    this.terminate();
+    this.finalized = false;
+    this.pendingCallbacks = /* @__PURE__ */ new Set();
+    if (payload.tasks.length === 0) {
+      callbacks.onDone();
+      return;
+    }
+    const worker = createWorker();
+    this.worker = worker;
+    worker.onMessage((msg) => {
+      if (msg.type === "moduleLoaded") {
+        const m = msg;
+        const p = callbacks.onModuleLoaded({
+          storeName: m.storeName,
+          langCode: m.langCode,
+          moduleCode: m.moduleCode,
+          version: m.version
+        });
+        this.pendingCallbacks.add(p);
+        p.finally(() => this.pendingCallbacks.delete(p));
+      } else if (msg.type === "dataReady") {
+        if (!storage) return;
+        const p = (async () => {
+          const existing = await storage.getRecord(msg.storeName, msg.record.key);
+          if (existing && msg.record.version <= existing.version) return;
+          let resources;
+          if (msg.storeIndex === 0) {
+            resources = deepMerge(
+              _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _11 => _11.resources]), () => ( {})),
+              msg.record.resources
+            );
+          } else {
+            resources = { ..._nullishCoalesce(_optionalChain([existing, 'optionalAccess', _12 => _12.resources]), () => ( {})), ...msg.record.resources };
+          }
+          const mergedRecord = { ...msg.record, resources };
+          await storage.putRecord(msg.storeName, mergedRecord);
+          await callbacks.onModuleLoaded({
+            storeName: msg.task.storeName,
+            langCode: mergedRecord.langCode,
+            moduleCode: mergedRecord.moduleCode,
+            version: mergedRecord.version
+          });
+        })().catch(() => {
+        });
+        this.pendingCallbacks.add(p);
+        p.finally(() => this.pendingCallbacks.delete(p));
+      } else if (msg.type === "moduleError") {
+        _optionalChain([callbacks, 'access', _13 => _13.onModuleError, 'optionalCall', _14 => _14(msg)]);
+      } else if (msg.type === "done" || msg.type === "error") {
+        if (msg.type === "error") _optionalChain([callbacks, 'access', _15 => _15.onError, 'optionalCall', _16 => _16()]);
+        this.finalize(callbacks);
+      }
+    });
+    worker.postMessage({ type: "start", payload });
+  }
+  terminate() {
+    _optionalChain([this, 'access', _17 => _17.worker, 'optionalAccess', _18 => _18.terminate, 'call', _19 => _19()]);
+    this.worker = null;
+  }
+  isRunning() {
+    return this.worker !== null;
+  }
+  finalize(callbacks) {
+    if (this.finalized) return;
+    this.finalized = true;
+    const pending = [...this.pendingCallbacks];
+    Promise.allSettled(pending).then(() => {
+      this.terminate();
+      callbacks.onDone();
+    });
+  }
+};
+
+// src/core/manager.ts
+var DB_NAME = "i18n_cache";
+var PRIORITY_MODULES = ["ENUMS", "CUSTOMER"];
+var currentLang = "zh_CN";
+var currentSig = null;
+var currentPromise = null;
+var resolvedStores = [];
+var resolvedModules = [];
+var resolvedLanguages = [];
+var unloginPullStarted = false;
+var managerOptions = null;
+var initOptions = null;
+var loadedModules = /* @__PURE__ */ new Set();
+var loadingModules = /* @__PURE__ */ new Set();
+var sseClient = new SSEClient();
+var workerManager = new WorkerManager();
+var pendingSSESyncs = /* @__PURE__ */ new Map();
+var isFlushing = false;
+function createI18nManager(options) {
+  managerOptions = options;
+  return {
+    initI18n,
+    closeSSE,
+    ensureModules,
+    getResource,
+    getAllRecordsByModule
+  };
+}
+function closeSSE() {
+  sseClient.close();
+  workerManager.terminate();
+  pendingSSESyncs.clear();
+  isFlushing = false;
+  loadedModules.clear();
+  loadingModules.clear();
+  unloginPullStarted = false;
+  currentSig = null;
+  currentPromise = null;
+}
+async function initI18n(options) {
+  const sig = buildSig(options);
+  if (sig === currentSig && currentPromise) return currentPromise;
+  if (currentPromise) closeSSE();
+  currentSig = sig;
+  initOptions = options;
+  currentPromise = _initI18n(options).catch((err) => {
+    currentSig = null;
+    currentPromise = null;
+    throw err;
+  });
+  return currentPromise;
+}
+async function ensureModules(moduleCodes) {
+  const toLoad = moduleCodes.filter((m) => {
+    const key = `${m}_${currentLang}`;
+    if (loadedModules.has(key) || loadingModules.has(key)) return false;
+    loadingModules.add(key);
+    return true;
+  });
+  if (toLoad.length === 0) return;
+  await Promise.allSettled(
+    toLoad.map(async (m) => {
+      try {
+        _i18next2.default.addResourceBundle(currentLang, m, getStaticLocale(m, currentLang), true, false);
+        await injectFromDB(m, currentLang);
+      } catch (e3) {
+      } finally {
+        loadingModules.delete(`${m}_${currentLang}`);
+      }
+    })
+  );
+  await _i18next2.default.changeLanguage(currentLang);
+}
+async function getResource(moduleCode, langCode) {
+  const storage = managerOptions.storage;
+  let merged = { ...getStaticLocale(moduleCode, langCode) };
+  const results = await Promise.allSettled(
+    resolvedStores.map(
+      (store) => storage.getRecord(store.name, buildKey(moduleCode, langCode, store))
+    )
+  );
+  for (let i = 0; i < resolvedStores.length; i++) {
+    const result = results[i];
+    if (result.status === "rejected") continue;
+    const record = result.value;
+    if (!_optionalChain([record, 'optionalAccess', _20 => _20.resources])) continue;
+    merged = i === 0 ? deepMerge(merged, record.resources) : deepMerge(merged, flatToNested(record.resources));
+  }
+  return merged;
+}
+async function getAllRecordsByModule(moduleCode) {
+  const storage = managerOptions.storage;
+  const results = [];
+  for (const store of resolvedStores) {
+    const records = await storage.getAllByModule(store.name, moduleCode);
+    results.push(...records);
+  }
+  return results;
+}
+async function _initI18n(options) {
+  const { storage } = managerOptions;
+  const { apiContext } = options;
+  currentLang = options.language;
+  resolvedStores = options.stores;
+  resolvedLanguages = _nullishCoalesce(options.languages, () => ( [options.language]));
+  resolvedModules = _nullishCoalesce(options.modules, () => ( []));
+  await checkCacheVersion(storage, options);
+  await storage.ensureSchemaVersion(resolvedStores);
+  for (const lang of resolvedLanguages) {
+    for (const m of resolvedModules) {
+      _i18next2.default.addResourceBundle(lang, m, getStaticLocale(m, lang), true, false);
+    }
+  }
+  await injectCurrentLanguageModules(currentLang);
+  await _i18next2.default.changeLanguage(currentLang);
+  if (!apiContext.isLoggedIn()) {
+    if (!unloginPullStarted && apiContext.unloginPull) {
+      unloginPullStarted = true;
+      await doUnloginPull(storage, options);
+    }
+    return;
+  }
+  if (!apiContext.pull || !managerOptions.createWorker) return;
+  const hasCache = await storage.hasLoginResources(resolvedStores);
+  if (!hasCache) {
+    await startWorkerFull(options);
+    await injectCurrentLanguageModules(currentLang);
+    await _i18next2.default.changeLanguage(currentLang);
+    emitI18nResourcesUpdated();
+  }
+  if (apiContext.sse) {
+    startSSE(options);
+  }
+}
+async function checkCacheVersion(storage, options) {
+  if (options.version == null) return;
+  const stored = Number(await _asyncNullishCoalesce(await storage.getMeta("cache_version"), async () => ( 0)));
+  if (options.version <= stored) return;
+  for (const store of options.stores) {
+    await storage.clearStore(store.name);
+  }
+  await storage.setMeta("cache_version", String(options.version));
+}
+async function doUnloginPull(storage, options) {
+  const { apiContext } = options;
+  if (!apiContext.unloginPull) return;
+  const unloginStoreName = resolvedStores[0].name;
+  try {
+    const blocks = await doFetch(apiContext.unloginPull, options);
+    for (const block of blocks) {
+      for (const mod of _nullishCoalesce(block.modules, () => ( []))) {
+        if (mod.moduleCode !== "UNLOGIN") continue;
+        await storage.putRecord(unloginStoreName, {
+          key: buildUnloginKey(block.langCode),
+          moduleCode: "UNLOGIN",
+          langCode: block.langCode,
+          version: _nullishCoalesce(mod.version, () => ( 0)),
+          resources: flatToNested(parseI18nValues(_nullishCoalesce(mod.i18nValues, () => ( []))))
+        });
+      }
+    }
+  } catch (e4) {
+  }
+  _i18next2.default.addResourceBundle(currentLang, "UNLOGIN", getStaticLocale("UNLOGIN", currentLang), true, false);
+  const dbUnlogin = await storage.getRecord(unloginStoreName, buildUnloginKey(currentLang));
+  if (_optionalChain([dbUnlogin, 'optionalAccess', _21 => _21.resources])) {
+    _i18next2.default.addResourceBundle(currentLang, "UNLOGIN", dbUnlogin.resources, true, true);
+  }
+  await _i18next2.default.changeLanguage(currentLang);
+  emitI18nResourcesUpdated();
+}
+async function startWorkerFull(options) {
+  const { apiContext } = options;
+  const pull = apiContext.pull;
+  const tasks = [];
+  for (const store of resolvedStores) {
+    for (const lang of resolvedLanguages) {
+      for (const module of sortedModules()) {
+        tasks.push({
+          storeName: store.name,
+          langCode: lang,
+          moduleCode: module,
+          version: 0,
+          trigger: "init-full"
+        });
+      }
+    }
+  }
+  await runWorker(options, tasks, pull);
+}
+function runWorker(options, tasks, pull) {
+  return new Promise((resolve, reject) => {
+    const { apiContext } = options;
+    const workerWritesDB = _nullishCoalesce(managerOptions.workerWritesDB, () => ( false));
+    workerManager.start(
+      managerOptions.createWorker,
+      {
+        baseURL: apiContext.baseURL,
+        headers: apiContext.getHeaders(),
+        pullPath: pull.path,
+        pullMethod: _nullishCoalesce(pull.method, () => ( "GET")),
+        stores: resolvedStores,
+        tasks,
+        dbName: DB_NAME
+      },
+      {
+        onModuleLoaded: async (data) => {
+          await onModuleLoaded(data);
+        },
+        onModuleError: (_data) => {
+        },
+        onDone: resolve,
+        onError: () => reject(new Error("[i18n] Worker fatal error"))
+      },
+      workerWritesDB ? void 0 : managerOptions.storage
+    );
+  });
+}
+async function onModuleLoaded(data) {
+  if (data.langCode === currentLang && loadedModules.has(`${data.moduleCode}_${currentLang}`)) {
+    await injectFromDB(data.moduleCode, data.langCode);
+    await _i18next2.default.changeLanguage(currentLang);
+    emitI18nResourcesUpdated();
+  }
+}
+async function injectFromDB(moduleCode, langCode) {
+  const storage = managerOptions.storage;
+  for (let i = 0; i < resolvedStores.length; i++) {
+    const store = resolvedStores[i];
+    const key = buildKey(moduleCode, langCode, store);
+    const record = await storage.getRecord(store.name, key);
+    if (!_optionalChain([record, 'optionalAccess', _22 => _22.resources])) continue;
+    if (i === 0) {
+      _i18next2.default.addResourceBundle(langCode, moduleCode, record.resources, true, true);
+    } else {
+      _i18next2.default.addResources(langCode, moduleCode, record.resources);
+    }
+  }
+  loadedModules.add(`${moduleCode}_${langCode}`);
+}
+async function injectCurrentLanguageModules(langCode) {
+  const modules = sortedModules();
+  const results = await Promise.allSettled(modules.map((m) => injectFromDB(m, langCode)));
+  const retries = modules.filter((_, i) => results[i].status === "rejected");
+  if (retries.length > 0) {
+    await Promise.allSettled(retries.map((m) => injectFromDB(m, langCode)));
+  }
+}
+function startSSE(options) {
+  const { apiContext } = options;
+  if (!apiContext.sse) return;
+  sseClient.start(
+    (raw) => {
+      const msg = _optionalChain([apiContext, 'access', _23 => _23.sse, 'optionalAccess', _24 => _24.transformMessage]) ? apiContext.sse.transformMessage(raw) : raw;
+      void handleSSEMessage(msg, options);
+    },
+    {
+      baseURL: apiContext.baseURL,
+      eventsPath: apiContext.sse.path,
+      getHeaders: apiContext.getHeaders
+    }
+  );
+}
+async function handleSSEMessage(msg, options) {
+  if (msg.type !== "i18n_update") return;
+  if (!options.apiContext.sseSync) return;
+  const store = resolvedStores.find((s) => s.name === msg.storeName);
+  if (!store) return;
+  const cg = store.cacheGroupKey;
+  const key = `${msg.storeName}_${msg.moduleCode}_${msg.langCode}_${_nullishCoalesce(cg, () => ( ""))}`;
+  const localVersion = await getStoredVersion(store, msg.moduleCode, msg.langCode);
+  const pending = pendingSSESyncs.get(key);
+  const knownTarget = pending ? Math.max(localVersion, pending.targetVersion) : localVersion;
+  if (msg.version <= knownTarget) return;
+  if (!pending && pendingSSESyncs.size >= 50) return;
+  pendingSSESyncs.set(key, {
+    key,
+    storeName: msg.storeName,
+    moduleCode: msg.moduleCode,
+    langCode: msg.langCode,
+    cacheGroupKey: cg,
+    targetVersion: pending ? Math.max(pending.targetVersion, msg.version) : msg.version
+  });
+  void flushPendingSSESyncs(options);
+}
+async function flushPendingSSESyncs(options) {
+  if (isFlushing) return;
+  isFlushing = true;
+  const tasks = [...pendingSSESyncs.values()];
+  pendingSSESyncs.clear();
+  const sorted = [
+    ...tasks.filter((t) => t.langCode === currentLang),
+    ...tasks.filter((t) => t.langCode !== currentLang)
+  ];
+  try {
+    for (const task of sorted) {
+      let localVersion;
+      try {
+        localVersion = await getStoredVersion(
+          { name: task.storeName, cacheGroupKey: task.cacheGroupKey },
+          task.moduleCode,
+          task.langCode
+        );
+      } catch (e5) {
+        localVersion = 0;
+      }
+      if (task.targetVersion <= localVersion) continue;
+      try {
+        await pullAndStore(task, localVersion, options);
+        if (task.langCode === currentLang && loadedModules.has(`${task.moduleCode}_${task.langCode}`)) {
+          await injectFromDB(task.moduleCode, task.langCode);
+          await _i18next2.default.changeLanguage(currentLang);
+          emitI18nResourcesUpdated();
+        }
+      } catch (e6) {
+      }
+    }
+  } finally {
+    isFlushing = false;
+    if (pendingSSESyncs.size > 0) void flushPendingSSESyncs(options);
+  }
+}
+async function pullAndStore(task, fromVersion, options) {
+  const storage = managerOptions.storage;
+  const sseSync = options.apiContext.sseSync;
+  const blocks = await doFetch(sseSync, options, {
+    storeName: task.storeName,
+    langCode: task.langCode,
+    moduleCode: task.moduleCode,
+    version: fromVersion
+  });
+  for (const block of blocks) {
+    for (const mod of _nullishCoalesce(block.modules, () => ( []))) {
+      const store = resolvedStores.find((s) => s.name === task.storeName);
+      if (!store) continue;
+      const storeIndex = resolvedStores.indexOf(store);
+      const key = buildKey(mod.moduleCode, block.langCode, store);
+      const existing = await storage.getRecord(store.name, key);
+      if (mod.version <= (_nullishCoalesce(_optionalChain([existing, 'optionalAccess', _25 => _25.version]), () => ( 0)))) continue;
+      let resources;
+      const parsed = parseI18nValues(_nullishCoalesce(mod.i18nValues, () => ( [])));
+      if (storeIndex === 0) {
+        resources = deepMerge(
+          _nullishCoalesce(_optionalChain([existing, 'optionalAccess', _26 => _26.resources]), () => ( {})),
+          flatToNested(parsed)
+        );
+      } else {
+        resources = { ..._nullishCoalesce(_optionalChain([existing, 'optionalAccess', _27 => _27.resources]), () => ( {})), ...parsed };
+      }
+      const version = Math.max(mod.version, task.targetVersion);
+      await storage.putRecord(store.name, {
+        key,
+        moduleCode: mod.moduleCode,
+        langCode: block.langCode,
+        version,
+        resources
+      });
+    }
+  }
+}
+async function doFetch(config, options, internalParams) {
+  const fetchFn = _nullishCoalesce(managerOptions.fetchFn, () => ( globalThis.fetch.bind(globalThis)));
+  const headers = options.apiContext.getHeaders();
+  const url = options.apiContext.baseURL + config.path;
+  const params = "buildParams" in config && config.buildParams ? config.buildParams(internalParams) : toDefaultParams(internalParams);
+  const method = "method" in config ? config.method : void 0;
+  let res;
+  if (method === "POST") {
+    res = await fetchFn(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(params)
+    });
+  } else {
+    res = await fetchFn(`${url}?${toQueryString(params)}`, { headers });
+  }
+  if (!res.ok) throw new Error(`[i18n] fetch failed: ${res.status} ${url}`);
+  const raw = await res.json();
+  return "transform" in config && config.transform ? config.transform(raw) : raw;
+}
+function buildSig(options) {
+  const cgKeys = options.stores.map((s) => _nullishCoalesce(s.cacheGroupKey, () => ( ""))).join(",");
+  return [options.apiContext.baseURL, options.language, cgKeys].join("|");
+}
+function sortedModules() {
+  const priority = PRIORITY_MODULES.filter((m) => resolvedModules.includes(m));
+  const rest = resolvedModules.filter((m) => !PRIORITY_MODULES.includes(m));
+  return [...priority, ...rest];
+}
+function getStaticLocale(moduleCode, langCode) {
+  return _nullishCoalesce(_optionalChain([initOptions, 'optionalAccess', _28 => _28.staticLocales, 'optionalAccess', _29 => _29[langCode], 'optionalAccess', _30 => _30[moduleCode]]), () => ( {}));
+}
+async function getStoredVersion(store, moduleCode, langCode) {
+  const storage = managerOptions.storage;
+  const key = buildKey(moduleCode, langCode, store);
+  const record = await storage.getRecord(store.name, key);
+  return _nullishCoalesce(_optionalChain([record, 'optionalAccess', _31 => _31.version]), () => ( 0));
+}
+
+
+
+
+
+exports.I18N_RESOURCES_UPDATED_EVENT = I18N_RESOURCES_UPDATED_EVENT; exports.emitI18nResourcesUpdated = emitI18nResourcesUpdated; exports.createI18nManager = createI18nManager;