@axiom-lattice/react-sdk 4.10.0 → 4.11.1

package/dist/chunk-XVZUC4U3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/i18n/instance.ts","../src/i18n/useT.ts","../src/i18n/useLocale.ts","../src/i18n/LatticeLocaleProvider.tsx"],"sourcesContent":["/**\n * The SDK's i18next instance.\n *\n * Auto-namespacing is the load-bearing idea here. Components write fully\n * qualified keys — `t(\"auth.login.title\")` — and the first segment (`auth`) is\n * also the namespace the dictionary is filed under. So `useT()` derives the\n * namespace from the key and hands it to i18next, which lets the ~2400\n * existing call sites stay exactly as they are while i18next still loads\n * dictionaries one namespace at a time.\n *\n * The alternative — merging all 18 namespaces into one — would also leave call\n * sites untouched, but it throws away the namespace boundary that i18next's\n * tooling (`i18next-cli extract/status/types`) is built around, and it makes\n * every chunk carry every module's copy.\n *\n * The instance is created with `createInstance()`, never the default export:\n * a shared package must not read or clobber its host's locale. For the same\n * reason `initReactI18next` is **not** used here — its `init()` writes the\n * instance into react-i18next's module-level singleton, which would swap the\n * host's instance out from under it. `<I18nextProvider>` is the supported way\n * to hand an instance down.\n */\n\nimport { createInstance } from \"i18next\";\nimport type { i18n as I18nInstance, ResourceKey } from \"i18next\";\nimport type { LatticeLocale } from \"@axiom-lattice/i18n\";\n\n/** Shipped locales, in the SDK's tag vocabulary. */\nexport const SUPPORTED_LOCALES: LatticeLocale[] = [\"en-US\", \"zh-CN\"];\n\n/** i18next speaks short tags; the SDK speaks BCP-47. */\nexport function toI18nextLocale(locale: LatticeLocale): string {\n  return locale === \"zh-CN\" ? \"zh\" : \"en\";\n}\n\nexport function fromI18nextLocale(language: string): LatticeLocale {\n  return language.startsWith(\"zh\") ? \"zh-CN\" : \"en-US\";\n}\n\n/**\n * Namespaces, one per dictionary module.\n *\n * Kept as an explicit list rather than discovered from the filesystem: it is\n * what lets the dynamic import below stay a *literal* pattern, which is what\n * Vite and Rollup require to emit a chunk per namespace.\n */\nexport const NAMESPACES = [\n  /**\n   * The shared verbs — confirm/cancel/save/delete/… — that used to live in\n   * `@axiom-lattice/i18n`'s own dictionary. They keep the `common.` prefix and\n   * become a namespace of their own so `namespaceOf` routes them somewhere they\n   * actually exist; without this they fell through to the first namespace and\n   * rendered as raw keys.\n   */\n  \"common\",\n  \"a2a\", \"auth\", \"capability\", \"chat\", \"chatConfig\", \"chatMenu\", \"chatWorkspace\",\n  \"cospace\", \"entities\", \"eval\", \"genui\", \"governance\", \"integration\", \"mcpapp\",\n  \"migration\", \"projectRoom\", \"tasks\", \"training\",\n] as const;\n\n/**\n * Which namespace a key belongs to.\n *\n * `\"auth.login.title\"` → `\"auth\"`. A key with no dotted prefix falls back to\n * the first namespace, which keeps `i18next.t` from being handed `undefined`\n * and keeps unknown keys resolving (to themselves) instead of throwing.\n */\nexport function namespaceOf(key: string): string {\n  const [head] = key.split(\".\");\n  return (NAMESPACES as readonly string[]).includes(head) ? head : NAMESPACES[0];\n}\n\n/**\n * Loads the dictionary for one namespace in one language.\n *\n * A plain object satisfying i18next's backend contract — no\n * `i18next-resources-to-backend` dependency for eight lines of code. The\n * `import()` argument is a literal pattern with a literal extension, so the\n * bundler emits one chunk per namespace+language and loads them on demand.\n */\nconst namespaceBackend = {\n  type: \"backend\" as const,\n  read(\n    language: string,\n    namespace: string,\n    callback: (error: unknown, resources: ResourceKey | null) => void\n  ): void {\n    void import(`./locales/${namespace}/${language}.json`)\n      .then((mod) => {\n        /**\n         * Each file is `{ messages: { \"a.b.c\": \"…\" } }`, not the flat object\n         * directly. The wrapper exists for the bundler: Vite's JSON plugin emits\n         * a *named export* per top-level key, and our keys contain dots, so\n         * `export { \"a2a.audit.action\": … }` is not valid JavaScript and the\n         * build fails. One level of nesting makes the only top-level key a\n         * legal identifier. Keys inside stay flat, so call sites are unaffected.\n         */\n        const body = (mod.default ?? mod) as { messages?: ResourceKey };\n        callback(null, (body.messages ?? body) as ResourceKey);\n      })\n      .catch((error: unknown) => callback(error, null));\n  },\n};\n\n/**\n * Exported for the jest setup, which registers this same loader on\n * react-i18next's default instance. Sharing it keeps the test environment from\n * drifting away from what the app does at runtime.\n */\nexport { namespaceBackend };\n\n/**\n * Build an instance for `locale`.\n *\n * `init()` is awaited so `changeLanguage` resolves only once the namespaces the\n * caller asked for are in hand — callers use that to avoid painting keys.\n */\nexport async function createSdkI18n(locale: LatticeLocale): Promise<I18nInstance> {\n  const instance = createInstance();\n\n  await instance.use(namespaceBackend).init({\n    lng: toI18nextLocale(locale),\n    fallbackLng: \"en\",\n    ns: [...NAMESPACES],\n    defaultNS: NAMESPACES[0],\n    /**\n     * Keys are stored flat and fully qualified (\"auth.login.title\"), so there\n     * is no separator for i18next to split on — splitting would look for\n     * `auth` → `login` → `title` as nested objects, which is not the shape.\n     */\n    keySeparator: false,\n    nsSeparator: false,\n    interpolation: { escapeValue: false },\n    // The backend is the only source; an empty `resources` would make i18next\n    // treat bundled resources as authoritative and never call it.\n    returnNull: false,\n  });\n\n  return instance;\n}\n","import { useMemo } from \"react\";\nimport { useTranslation } from \"react-i18next\";\nimport type { TFunction as I18nextT } from \"i18next\";\nimport type { TParams, LatticeLocale } from \"@axiom-lattice/i18n\";\nimport type { TranslationKey } from \"./translationKeys\";\nimport { fromI18nextLocale, namespaceOf } from \"./instance\";\n\n/**\n * The translator the SDK hands out: same call shape as before, but the key is\n * now constrained to the keys that actually exist.\n *\n * That constraint is the whole point of M5 — it turns `t(\"auth.login.titel\")`\n * into a compile error instead of a raw key rendered to the user, which is the\n * gap the hand-rolled implementation left open (it checked the *dictionary* for\n * missing translations, never the *call site* for typos).\n */\nexport interface SdkTFunction {\n  (key: TranslationKey, params?: TParams): string;\n  /** Active locale. Use for `Intl.*` / `toLocaleDateString`. */\n  locale: LatticeLocale;\n}\n\n/**\n * Wrap i18next's `t` in the shape the SDK's components already use.\n *\n * The public contract is unchanged — `(key, params?) => string`, plus a\n * `locale` property for the browser-native formatters — which is what keeps the\n * ~2400 call sites and every component's `import { useT } from \".../i18n\"`\n * untouched through the migration.\n *\n * The one thing this adds over i18next's own `t` is deriving the namespace from\n * the key's first segment, so `t(\"auth.login.title\")` keeps working as written\n * while i18next still loads only the `auth` namespace. See `./instance.ts`.\n */\nfunction wrap(i18nextT: I18nextT, language: string | undefined): SdkTFunction {\n  const t = ((key: TranslationKey, params?: TParams): string =>\n    // `ns` first so a caller's interpolation params cannot shadow it.\n    i18nextT(key, { ns: namespaceOf(key), ...(params as Record<string, unknown>) })) as SdkTFunction;\n\n  t.locale = fromI18nextLocale(language ?? \"en\");\n  return t;\n}\n\n/**\n * Translate copy in the active locale.\n *\n * Safe with no provider above: react-i18next falls back to its default instance\n * and, failing that, renders the key rather than throwing. The SDK's test suite\n * relies on that — it renders components bare — and `src/__tests__/setup.ts`\n * initialises that default instance in English so assertions still see real copy\n * rather than keys.\n */\nexport function useT(): SdkTFunction {\n  const { t, i18n } = useTranslation();\n  const language = i18n?.language;\n  return useMemo(() => wrap(t, language), [t, language]);\n}\n","import { createContext, useContext } from \"react\";\nimport type { LatticeLocale } from \"@axiom-lattice/i18n\";\nimport { SUPPORTED_LOCALES } from \"./instance\";\n\nexport interface LocaleBridgeValue {\n  /** Active locale. */\n  locale: LatticeLocale;\n  /** Locales this build can render. */\n  setLocale: (locale: LatticeLocale) => void;\n  supportedLocales: LatticeLocale[];\n}\n\n/**\n * Bridges the locale *selection* to the component tree.\n *\n * i18next owns the translations and hands them down through `I18nextProvider`;\n * this context carries only the bits i18next has no opinion about — which\n * locales the build ships, and how a switch is initiated.\n *\n * It exists because `useLocale()` is part of the SDK's public surface (the\n * language switcher reads it) and its shape predates i18next. Keeping the shape\n * is what lets that component survive the migration untouched.\n *\n * The default is deliberately inert rather than throwing: rendered with no\n * provider, `useLocale()` reports `en-US` and a no-op setter, matching how\n * `useT()` degrades.\n */\nexport const LocaleBridgeContext = createContext<LocaleBridgeValue>({\n  locale: \"en-US\",\n  setLocale: () => undefined,\n  supportedLocales: SUPPORTED_LOCALES,\n});\n\n/**\n * Read and switch the active locale.\n *\n * @example\n * const { locale, setLocale, supportedLocales } = useLocale();\n */\nexport function useLocale(): LocaleBridgeValue {\n  return useContext(LocaleBridgeContext);\n}\n","import React, { useEffect, useMemo, useState } from \"react\";\nimport { createInstance } from \"i18next\";\nimport type { i18n as I18nInstance } from \"i18next\";\nimport { I18nextProvider } from \"react-i18next\";\nimport type { Dictionary, LatticeLocale } from \"@axiom-lattice/i18n\";\nimport { NAMESPACES, SUPPORTED_LOCALES, toI18nextLocale, namespaceBackend } from \"./instance\";\nimport { LocaleBridgeContext } from \"./useLocale\";\n\nexport interface LatticeLocaleProviderProps {\n  /** Active locale. Defaults to `\"en-US\"` — the source language. */\n  locale?: LatticeLocale;\n  /**\n   * Host-supplied copy layered **over** the shipped dictionary, per locale.\n   *\n   * Kept from the hand-rolled provider so hosts do not change: it is applied as\n   * an i18next resource bundle for that namespace-free `translation` scope.\n   */\n  overrides?: Partial<Record<LatticeLocale, Dictionary>>;\n  /** Forwarded to `onLocaleChange` hosts that persist the choice themselves. */\n  storageKey?: string;\n  /** Called when the user picks a locale, before the host re-renders. */\n  onLocaleChange?: (locale: LatticeLocale) => void;\n  children: React.ReactNode;\n}\n\n/**\n * Supplies the SDK's i18next instance to every `useT()` below it.\n *\n * The props are the ones the hand-rolled provider had, so hosts and\n * `AgentChatApp` keep working unchanged; only the implementation moved.\n *\n * The instance is private to this provider (`createInstance`, never the default\n * export) so the SDK neither reads nor replaces its host's locale. Namespaces\n * are fetched before `children` render, which is what stops the first paint\n * from showing raw keys.\n */\nexport function LatticeLocaleProvider({\n  locale = \"en-US\",\n  overrides,\n  storageKey,\n  onLocaleChange,\n  children,\n}: LatticeLocaleProviderProps): React.ReactElement | null {\n  const [ready, setReady] = useState(false);\n  const instance = useMemo<I18nInstance>(() => createInstance(), []);\n\n  useEffect(() => {\n    let cancelled = false;\n    setReady(false);\n\n    void instance\n      .use(namespaceBackend)\n      .init({\n        lng: toI18nextLocale(locale),\n        fallbackLng: \"en\",\n        ns: [...NAMESPACES],\n        defaultNS: NAMESPACES[0],\n        // Dictionaries are stored flat and fully qualified, so there is no\n        // separator to split on. See ./instance.ts.\n        keySeparator: false,\n        nsSeparator: false,\n        interpolation: { escapeValue: false },\n        resources: overrides\n          ? {\n              [toI18nextLocale(locale)]: {\n                [NAMESPACES[0]]: (overrides[locale] ?? {}) as Record<string, string>,\n              },\n            }\n          : undefined,\n      })\n      .then(() => instance.loadNamespaces([...NAMESPACES]))\n      .then(() => {\n        if (!cancelled) setReady(true);\n      })\n      .catch(() => {\n        // A namespace that fails to load must not blank the app; render with\n        // whatever arrived and let missing keys fall back to their key text.\n        if (!cancelled) setReady(true);\n      });\n\n    return () => {\n      cancelled = true;\n    };\n  }, [instance, locale, overrides]);\n\n  /**\n   * Switching is delegated, not handled here.\n   *\n   * The provider cannot swap locale in place — the dictionaries for the new\n   * locale have not been fetched — so the host decides what happens: it stores\n   * the choice and reloads, and the reload re-enters this component with the\n   * new `locale`. That mirrors the hand-rolled provider, whose `setLocale` also\n   * only persisted and notified.\n   */\n  const bridge = useMemo(\n    () => ({\n      locale,\n      supportedLocales: SUPPORTED_LOCALES,\n      setLocale: (next: LatticeLocale) => {\n        if (!SUPPORTED_LOCALES.includes(next)) return;\n        if (storageKey && typeof window !== \"undefined\") {\n          try {\n            window.localStorage.setItem(storageKey, next);\n          } catch {\n            // Private mode / disabled storage: the switch still notifies the\n            // host, it just will not survive a reload.\n          }\n        }\n        onLocaleChange?.(next);\n      },\n    }),\n    [locale, storageKey, onLocaleChange]\n  );\n\n  if (!ready) return null;\n\n  return (\n    <LocaleBridgeContext.Provider value={bridge}>\n      <I18nextProvider i18n={instance}>{children}</I18nextProvider>\n    </LocaleBridgeContext.Provider>\n  );\n}\n"],"mappings":";;;;;AAuBA,SAAS,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKxB,IAAM,oBAAqC,CAAC,SAAS,OAAO;AAG5D,SAAS,gBAAgB,QAA+B;AAC7D,SAAO,WAAW,UAAU,OAAO;AACrC;AAEO,SAAS,kBAAkB,UAAiC;AACjE,SAAO,SAAS,WAAW,IAAI,IAAI,UAAU;AAC/C;AASO,IAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQxB;AAAA,EACA;AAAA,EAAO;AAAA,EAAQ;AAAA,EAAc;AAAA,EAAQ;AAAA,EAAc;AAAA,EAAY;AAAA,EAC/D;AAAA,EAAW;AAAA,EAAY;AAAA,EAAQ;AAAA,EAAS;AAAA,EAAc;AAAA,EAAe;AAAA,EACrE;AAAA,EAAa;AAAA,EAAe;AAAA,EAAS;AACvC;AASO,SAAS,YAAY,KAAqB;AAC/C,QAAM,CAAC,IAAI,IAAI,IAAI,MAAM,GAAG;AAC5B,SAAQ,WAAiC,SAAS,IAAI,IAAI,OAAO,WAAW,CAAC;AAC/E;AAUA,IAAM,mBAAmB;AAAA,EACvB,MAAM;AAAA,EACN,KACE,UACA,WACA,UACM;AACN,SAAY,qCAAa,SAAS,IAAI,QAAQ,SAC3C,KAAK,CAAC,QAAQ;AASb,YAAM,OAAQ,IAAI,WAAW;AAC7B,eAAS,MAAO,KAAK,YAAY,IAAoB;AAAA,IACvD,CAAC,EACA,MAAM,CAAC,UAAmB,SAAS,OAAO,IAAI,CAAC;AAAA,EACpD;AACF;;;ACtGA,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAiC/B,SAAS,KAAK,UAAoB,UAA4C;AAC5E,QAAM,KAAK,CAAC,KAAqB;AAAA;AAAA,IAE/B,SAAS,KAAK,EAAE,IAAI,YAAY,GAAG,GAAG,GAAI,OAAmC,CAAC;AAAA;AAEhF,IAAE,SAAS,kBAAkB,YAAY,IAAI;AAC7C,SAAO;AACT;AAWO,SAAS,OAAqB;AACnC,QAAM,EAAE,GAAG,KAAK,IAAI,eAAe;AACnC,QAAM,WAAW,MAAM;AACvB,SAAO,QAAQ,MAAM,KAAK,GAAG,QAAQ,GAAG,CAAC,GAAG,QAAQ,CAAC;AACvD;;;ACxDA,SAAS,eAAe,kBAAkB;AA2BnC,IAAM,sBAAsB,cAAiC;AAAA,EAClE,QAAQ;AAAA,EACR,WAAW,MAAM;AAAA,EACjB,kBAAkB;AACpB,CAAC;AAQM,SAAS,YAA+B;AAC7C,SAAO,WAAW,mBAAmB;AACvC;;;ACzCA,SAAgB,WAAW,WAAAA,UAAS,gBAAgB;AACpD,SAAS,kBAAAC,uBAAsB;AAE/B,SAAS,uBAAuB;AAmH1B;AAlFC,SAAS,sBAAsB;AAAA,EACpC,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA0D;AACxD,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAS,KAAK;AACxC,QAAM,WAAWC,SAAsB,MAAMC,gBAAe,GAAG,CAAC,CAAC;AAEjE,YAAU,MAAM;AACd,QAAI,YAAY;AAChB,aAAS,KAAK;AAEd,SAAK,SACF,IAAI,gBAAgB,EACpB,KAAK;AAAA,MACJ,KAAK,gBAAgB,MAAM;AAAA,MAC3B,aAAa;AAAA,MACb,IAAI,CAAC,GAAG,UAAU;AAAA,MAClB,WAAW,WAAW,CAAC;AAAA;AAAA;AAAA,MAGvB,cAAc;AAAA,MACd,aAAa;AAAA,MACb,eAAe,EAAE,aAAa,MAAM;AAAA,MACpC,WAAW,YACP;AAAA,QACE,CAAC,gBAAgB,MAAM,CAAC,GAAG;AAAA,UACzB,CAAC,WAAW,CAAC,CAAC,GAAI,UAAU,MAAM,KAAK,CAAC;AAAA,QAC1C;AAAA,MACF,IACA;AAAA,IACN,CAAC,EACA,KAAK,MAAM,SAAS,eAAe,CAAC,GAAG,UAAU,CAAC,CAAC,EACnD,KAAK,MAAM;AACV,UAAI,CAAC,UAAW,UAAS,IAAI;AAAA,IAC/B,CAAC,EACA,MAAM,MAAM;AAGX,UAAI,CAAC,UAAW,UAAS,IAAI;AAAA,IAC/B,CAAC;AAEH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAC,UAAU,QAAQ,SAAS,CAAC;AAWhC,QAAM,SAASD;AAAA,IACb,OAAO;AAAA,MACL;AAAA,MACA,kBAAkB;AAAA,MAClB,WAAW,CAAC,SAAwB;AAClC,YAAI,CAAC,kBAAkB,SAAS,IAAI,EAAG;AACvC,YAAI,cAAc,OAAO,WAAW,aAAa;AAC/C,cAAI;AACF,mBAAO,aAAa,QAAQ,YAAY,IAAI;AAAA,UAC9C,QAAQ;AAAA,UAGR;AAAA,QACF;AACA,yBAAiB,IAAI;AAAA,MACvB;AAAA,IACF;AAAA,IACA,CAAC,QAAQ,YAAY,cAAc;AAAA,EACrC;AAEA,MAAI,CAAC,MAAO,QAAO;AAEnB,SACE,oBAAC,oBAAoB,UAApB,EAA6B,OAAO,QACnC,8BAAC,mBAAgB,MAAM,UAAW,UAAS,GAC7C;AAEJ;","names":["useMemo","createInstance","useMemo","createInstance"]}