@sonenta/react-i18next 2.2.0 → 2.3.1

package/README.md

@@ -540,6 +540,41 @@ Resolution is locale-outer / surface-inner (same chain as `t()`): `(fr-CA,
 aria_label) > (fr-CA, base) > (fr, aria_label) > (fr, base)`. Overlays are
 CDN-only (`env: "dev"` is base-only).
 
+## Available languages (runtime switcher)
+
+List the languages **published for the active version** at runtime — so adding
+a language in Sonenta makes it appear in your switcher **without recompiling
+the app**. The set comes from a per-version CDN manifest (public, cacheable,
+no auth); each code is enriched from the language catalog (`native_name`,
+`rtl`, …).
+
+```tsx
+import { useTranslation, useAvailableLanguages } from "@sonenta/react-i18next";
+
+function LanguageSwitcher() {
+  const { i18n } = useTranslation();
+  const languages = useAvailableLanguages(); // [{ code, native_name, rtl, is_default, published_at? }]
+  return (
+    <select value={i18n.language} onChange={(e) => i18n.setLocale(e.target.value)}>
+      {languages.map((l) => (
+        <option key={l.code} value={l.code}>
+          {l.native_name ?? l.code}
+        </option>
+      ))}
+    </select>
+  );
+}
+```
+
+- A newly-published language appears on the **next load** (the manifest is
+  CDN-served), or immediately after `i18n.reload()` — no rebuild, no redeploy
+  of your app.
+- `is_default` marks the project's default locale; `published_at` (when the
+  manifest provides it) lets you flag recently-added languages.
+- Falls back to `defaultLocale` + `fallbackLng` when no manifest is available
+  (or `env: "dev"`, which is CDN-only). Opt out with `disableLanguageManifest`.
+- Also imperative: `i18n.availableLanguages`.
+
 ## Recipes
 
 ### Next.js (App Router)

package/dist/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   logTransport: () => logTransport,
   surfaceForWidth: () => surfaceForWidth,
   t: () => t,
+  useAvailableLanguages: () => useAvailableLanguages,
   useTranslation: () => useTranslation
 });
 module.exports = __toCommonJS(index_exports);
@@ -237,7 +238,7 @@ function flattenPlurals(tree, locale) {
 
 // src/transport.ts
 var SDK_LIB = "@sonenta/react-i18next";
-var SDK_VER = true ? "2.2.0" : "0.0.0-dev";
+var SDK_VER = true ? "2.3.1" : "0.0.0-dev";
 function defaultTransport(opts) {
   return async (batch) => {
     if (!batch.length) return;
@@ -429,6 +430,14 @@ var SonentaI18n = class {
   // config.languageCatalog and/or the public GET /v1/languages in start().
   _catalog = new LanguageCatalog();
   _catalogDisabled = false;
+  // Published-languages manifest (available-languages feature). Per-version,
+  // public CDN, no auth: the SET of locales published for the active version.
+  // Codes are enriched from `_catalog` (#803) for native_name/rtl/etc.
+  _manifestDisabled = false;
+  _manifest = null;
+  // The configured default locale (the initial `this.locale`, which is mutable
+  // via setLocale) — used as the available-languages fallback + default marker.
+  _defaultLocale;
   _config;
   // Surface variant (#911). When set, each loaded (locale,ns) is composed as
   // base ⊕ sparse `{ns}.{surface}.json` overlay (overlay wins per key). We
@@ -476,6 +485,7 @@ var SonentaI18n = class {
       );
     }
     this.locale = config.defaultLocale;
+    this._defaultLocale = config.defaultLocale;
     this.fallbackLng = config.fallbackLng;
     this._surface = config.surface;
     for (const s of config.a11ySurfaces ?? []) this._a11ySurfaces.add(s);
@@ -578,6 +588,7 @@ var SonentaI18n = class {
     this._rebindFormat();
     this._catalogDisabled = config.disableLanguageCatalog === true;
     this._catalog.merge(config.languageCatalog);
+    this._manifestDisabled = config.disableLanguageManifest === true;
     const active = config.initialBundles?.[this.locale];
     if (active && this._config.namespaces.every(
       (n) => active[n] && Object.keys(active[n]).length > 0
@@ -674,6 +685,7 @@ var SonentaI18n = class {
       dir: this.dir,
       nativeName: this.nativeName,
       languageMeta: this.languageMeta,
+      availableLanguages: this.availableLanguages,
       i18next: this._i18next
     };
   }
@@ -735,7 +747,9 @@ var SonentaI18n = class {
       // Best-effort: align the key separator with the version's key_style (#754).
       this._loadKeyStyle(fetchImpl),
       // Best-effort: load the public language catalog for dir()/nativeName().
-      this._loadCatalog(fetchImpl)
+      this._loadCatalog(fetchImpl),
+      // Best-effort: load the per-version published-languages manifest.
+      this._loadManifest(fetchImpl)
     ]);
     await this._syncLanguage();
     this.ready = true;
@@ -759,6 +773,73 @@ var SonentaI18n = class {
   }
   /** Best-effort: fetch the PUBLIC language catalog and merge it in (#803).
    *  Skipped when disabled; a failure keeps any embedded catalog. */
+  /**
+   * Best-effort: fetch the per-version published-languages manifest
+   * (`{apiBase}/cdn/v1/{project}/{version}/latest/languages.json`, public, no
+   * auth, CORS-open, CDN-cached `max-age=60` + ETag) — the SET of locales
+   * published for the active version (compute-on-serve from cdn_releases,
+   * always in sync with what is published). Codes only; enriched from the
+   * catalog. A 404/offline keeps any prior manifest (`availableLanguages` then
+   * falls back to default + fallback). Same route on prod + dev (backend task
+   * 989+; the authed `/v1/projects/{id}/languages` is ALL project languages,
+   * not the published set — this manifest is the in-production set).
+   */
+  async _loadManifest(fetchImpl, opts = {}) {
+    if (this._manifestDisabled) return;
+    const url = `${this._config.apiBase.replace(/\/+$/, "")}/cdn/v1/${this._config.projectUuid}/${this._config.version}/latest/languages.json`;
+    const init = { method: "GET", credentials: "omit" };
+    if (opts.bust) init.cache = "reload";
+    try {
+      const r = await fetchImpl(url, init);
+      if (!r.ok) return;
+      const data = await r.json();
+      const raw = Array.isArray(data.languages) ? data.languages : [];
+      const languages = [];
+      for (const e of raw) {
+        if (typeof e === "string") {
+          languages.push({ code: e });
+        } else if (e && typeof e === "object" && typeof e.code === "string") {
+          const obj = e;
+          languages.push({
+            code: obj.code,
+            published_at: typeof obj.published_at === "string" ? obj.published_at : void 0
+          });
+        }
+      }
+      this._manifest = {
+        default_locale: typeof data.default_locale === "string" ? data.default_locale : void 0,
+        languages
+      };
+    } catch {
+    }
+  }
+  /** Languages PUBLISHED for the active version (available-languages feature):
+   *  the manifest's codes enriched with catalog metadata, marked with the
+   *  default locale + any `published_at`. Falls back to the configured
+   *  `defaultLocale` + `fallbackLng` when no manifest is available. */
+  get availableLanguages() {
+    const def = this._manifest?.default_locale ?? this._defaultLocale;
+    let entries = this._manifest?.languages;
+    if (!entries || entries.length === 0) {
+      const seen = /* @__PURE__ */ new Set();
+      entries = [];
+      for (const c of [this._defaultLocale, ...asArray(this.fallbackLng)]) {
+        if (c && !seen.has(c)) {
+          seen.add(c);
+          entries.push({ code: c });
+        }
+      }
+    }
+    return entries.map(({ code, published_at }) => {
+      const meta = this.languageMeta(code);
+      return {
+        ...meta ?? {},
+        code,
+        ...published_at ? { published_at } : {},
+        is_default: code === def
+      };
+    });
+  }
   async _loadCatalog(fetchImpl) {
     if (this._catalogDisabled) return;
     this._catalog.merge(await loadCatalog(this._config.apiBase, fetchImpl));
@@ -849,12 +930,14 @@ var SonentaI18n = class {
       if (opts.namespace && opts.namespace !== ns) continue;
       targets.push({ locale, ns });
     }
-    if (targets.length === 0) return;
-    await Promise.all(
-      targets.map(
+    if (targets.length === 0 && (opts.locale || opts.namespace)) return;
+    const manifest = this._loadManifest(fetch, { bust: true });
+    await Promise.all([
+      manifest,
+      ...targets.map(
         (t2) => this._loadBundle(t2.locale, t2.ns, fetch, { bust: true })
       )
-    );
+    ]);
     this._notify();
   };
   /**
@@ -1445,6 +1528,9 @@ function useTranslation(defaultNamespace) {
   }, []);
   return { t: t2, i18n: snapshot };
 }
+function useAvailableLanguages() {
+  return useI18nSnapshot().availableLanguages;
+}
 
 // src/trans.tsx
 var import_react3 = require("react");
@@ -1499,6 +1585,7 @@ function splitOnComponents(text, components) {
   logTransport,
   surfaceForWidth,
   t,
+  useAvailableLanguages,
   useTranslation
 });
 //# sourceMappingURL=index.cjs.map