The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
// Locale + merged catalog store for the TUI, mirroring apps/desktop/src/i18n/runtime.ts.
//
// Resolution for `t(key)`: active catalog (en merged with the RPC-delivered pack
// for the active language) → bundled en → the bare key. Packs are flat dotted
// maps of strings; a string overriding a function-valued en leaf is wrapped into
// `(...args) => format(str, args)` with positional `{0}`, `{1}` placeholders.
import { atom } from 'nanostores'
import { en } from './en.js'
import { isRecord, mergeTranslations, type TranslationOverride } from './merge.js'
import type { CatalogPack, TranslationKey, Translations } from './types.js'
export const DEFAULT_LOCALE = 'en'
export const $locale = atom<string>(DEFAULT_LOCALE)
export const $catalog = atom<Translations>(en)
/** Fill `{0}`, `{1}`… from `args`; unknown indices are left as-is so a pack
* with a stray placeholder degrades to visible text, not `undefined`. */
export function formatPositional(template: string, args: readonly unknown[]): string {
return template.replace(/\{(\d+)\}/g, (match, index: string) => {
const value = args[Number(index)]
return value === undefined ? match : String(value)
})
}
/** Walk a dot-path (`a.b.c`) into a nested message tree. */
function resolvePath(source: unknown, key: string): unknown {
return key.split('.').reduce<unknown>((current, part) => (isRecord(current) ? current[part] : undefined), source)
}
/** A string is returned as-is, a function is called with `args`, else `null`. */
function render(value: unknown, args: readonly unknown[]): null | string {
if (typeof value === 'string') {
return value
}
if (typeof value === 'function') {
return (value as (...args: unknown[]) => string)(...args)
}
return null
}
/** The active → en → key resolution every translator shares. */
export function translateFrom(
source: (locale: string) => unknown,
locale: string,
key: string,
args: readonly unknown[]
): string {
const active = render(resolvePath(source(locale), key), args)
if (active !== null) {
return active
}
if (locale !== DEFAULT_LOCALE) {
const fallback = render(resolvePath(source(DEFAULT_LOCALE), key), args)
if (fallback !== null) {
return fallback
}
}
return key
}
/** Nest a flat `{ 'a.b': 'x' }` pack into `{ a: { b: 'x' } }`, wrapping strings
* that override function-valued base leaves. Keys absent from the base are
* dropped (the validator already warned about them on install). */
export function nestPack(base: unknown, messages: Record<string, string>): Record<string, unknown> {
const out: Record<string, unknown> = {}
for (const [flatKey, text] of Object.entries(messages)) {
if (typeof text !== 'string') {
continue
}
const baseLeaf = resolvePath(base, flatKey)
if (baseLeaf === undefined || isRecord(baseLeaf)) {
continue
}
const parts = flatKey.split('.')
const leafKey = parts.pop() as string
let cursor = out
for (const part of parts) {
const next = cursor[part]
if (isRecord(next)) {
cursor = next
} else {
const created: Record<string, unknown> = {}
cursor[part] = created
cursor = created
}
}
cursor[leafKey] = typeof baseLeaf === 'function' ? (...args: unknown[]) => formatPositional(text, args) : text
}
return out
}
/** Merge a pack (flat dotted map) over the bundled English catalog. */
export function catalogFromPack(messages: Record<string, string> | undefined): Translations {
if (!messages || Object.keys(messages).length === 0) {
return en
}
return mergeTranslations<Translations>(en, nestPack(en, messages) as TranslationOverride<Translations>)
}
/** Install a language: `pack` may be null when the backend has no TUI strings
* for `lang` (or predates `i18n.catalog`) — the UI then renders English under
* that locale id. */
export function applyLocale(lang: string, pack: CatalogPack | null | undefined): void {
$locale.set(lang || DEFAULT_LOCALE)
$catalog.set(catalogFromPack(pack?.messages))
}
export function resetLocale(): void {
applyLocale(DEFAULT_LOCALE, null)
}
export const getLocale = () => $locale.get()
/** The active merged catalog for non-React code that wants the typed tree. */
export const messages = (): Translations => $catalog.get()
/** Resolve one key for non-React code. Function-valued leaves take `args`. */
export function t(key: TranslationKey, ...args: unknown[]): string {
return translateFrom(locale => (locale === DEFAULT_LOCALE ? en : $catalog.get()), $locale.get(), key, args)
}