@rimelight/i18n 0.0.6 → 0.0.7

package/src/runtime.ts

@@ -1,316 +0,0 @@
-import { createI18n, formatter, translationsLoading } from "@nanostores/i18n"
-import type {
-  TranslationLoader,
-  Translations,
-  I18n,
-  Components,
-  ComponentsJSON
-} from "@nanostores/i18n"
-import { atom } from "nanostores"
-
-/**
- * A reactive store containing the current locale code. Set by middleware on each request, or
- * manually via `currentLocale.set(locale)`.
- */
-export const currentLocale = atom("")
-
-type I18nInstance = I18n
-type FormatterInstance = ReturnType<typeof formatter>
-
-let i18nInstance: I18nInstance | undefined
-let formatterInstance: FormatterInstance | undefined
-let baseLocaleDefault: string = "en"
-let rawTranslationsDict: Record<string, Components> = {}
-
-function throwNotInitialized(): never {
-  throw new Error("i18n not initialized. Call initializeI18n first.")
-}
-
-/**
- * Wraps a TranslationLoader so that the returned object is guaranteed to contain a key for every
- * requested component.
- *
- * The nanostores i18n library uses the keys of the object returned from `get` to clear its internal
- * "requested" set. If a requested component is missing from the result (e.g. because the backend
- * has no translations for it in the given locale yet), the internal loading atom is never set back
- * to `false`, which causes useI18nAsync / translationsLoading to hang forever.
- *
- * This wrapper normalises the loader output so missing components are filled in with empty
- * translation objects, falling back to the base translations defined at the call site.
- */
-function wrapLoader(loader: TranslationLoader): TranslationLoader {
-  return async (code, components): Promise<ComponentsJSON> => {
-    const raw = await loader(code, components)
-    const normalised: ComponentsJSON = Array.isArray(raw)
-      ? Object.assign({} as ComponentsJSON, ...raw)
-      : { ...raw }
-    for (const component of components) {
-      if (!(component in normalised)) normalised[component] = {}
-    }
-    return normalised
-  }
-}
-
-export interface InitializeI18nOptions {
-  /**
-   * The default locale code (e.g. 'en').
-   */
-  defaultLocale: string
-  /**
-   * Pre-loaded translations keyed by locale then component.
-   */
-  translations: Record<string, Components>
-  /**
-   * Optional dynamic loader called when a locale is not in cache.
-   */
-  get?: TranslationLoader
-}
-
-/**
- * Initializes the i18n system. Must be called once before any other i18n functions are used (the
- * integration virtual module does this automatically).
- */
-export function initializeI18n(options: InitializeI18nOptions): void {
-  const { defaultLocale, translations, get } = options
-  baseLocaleDefault = defaultLocale
-  rawTranslationsDict = translations || {}
-
-  if (!i18nInstance) {
-    currentLocale.set(defaultLocale)
-
-    // Convert plain JSON dictionaries to nanostores atoms expected by nanostores/i18n cache
-    const formattedCache: Record<string, Components> = {}
-    for (const [locale, components] of Object.entries(translations)) {
-      formattedCache[locale] = {}
-      for (const [compName, compBody] of Object.entries(components)) {
-        let bodyObj: Record<string, string> = {}
-        if (isStringRecord(compBody)) {
-          bodyObj = compBody
-        } else if (isStoreWithGet(compBody)) {
-          const res: unknown = compBody.get()
-          if (isStringRecord(res)) {
-            bodyObj = res
-          }
-        }
-        formattedCache[locale][compName] = atom(bodyObj)
-      }
-    }
-
-    i18nInstance = createI18n(currentLocale, {
-      baseLocale: defaultLocale,
-      get: wrapLoader(get ?? (async (): Promise<ComponentsJSON> => ({}))),
-      cache: formattedCache,
-      isSSR: true
-    })
-  }
-  formatterInstance = formatter(currentLocale)
-}
-
-/**
- * Returns the underlying nanostores/i18n instance. Throws if not initialized.
- */
-export function getI18nInstance(): I18nInstance {
-  if (!i18nInstance) throwNotInitialized()
-  return i18nInstance
-}
-
-/**
- * Returns the formatter instance. Throws if not initialized.
- */
-export function getFormatterInstance(): FormatterInstance {
-  if (!formatterInstance) throwNotInitialized()
-  return formatterInstance
-}
-
-/**
- * Returns a Formatter object for the current locale with methods for formatting numbers, dates, and
- * relative times using the native Intl API.
- */
-export function useFormat(): ReturnType<FormatterInstance["get"]> {
-  return getFormatterInstance().get()
-}
-
-/**
- * Helper to safely extract raw translation JSON object from cache regardless of whether it is an
- * atom or object. Checks exact locale code (e.g. 'zh-CN'), base language code (e.g. 'zh'), and
- * default locale fallback.
- */
-interface StoreWithGet {
-  get: () => unknown
-}
-
-function isStoreWithGet(obj: unknown): obj is StoreWithGet {
-  if (typeof obj !== "object" || obj === null) return false
-  const getFn = Reflect.get(obj, "get")
-  return typeof getFn === "function"
-}
-
-function isStringRecord(obj: unknown): obj is Record<string, string> {
-  return typeof obj === "object" && obj !== null
-}
-
-function getCachedComponent(
-  locale: string,
-  componentName: string
-): Record<string, string> | undefined {
-  const normalizedLocale = locale.toLowerCase()
-  const baseLanguage = normalizedLocale.split("-")[0] ?? normalizedLocale
-
-  const candidates = [locale, normalizedLocale, baseLanguage, baseLocaleDefault]
-
-  for (const code of candidates) {
-    const rawComp: unknown = rawTranslationsDict[code]?.[componentName]
-    if (isStoreWithGet(rawComp)) {
-      const res: unknown = rawComp.get()
-      if (isStringRecord(res)) return res
-    } else if (isStringRecord(rawComp)) {
-      return rawComp
-    }
-  }
-
-  if (!i18nInstance) return undefined
-  for (const code of candidates) {
-    const rawComp: unknown = i18nInstance.cache[code]?.[componentName]
-    if (isStoreWithGet(rawComp)) {
-      const res: unknown = rawComp.get()
-      if (isStringRecord(res)) return res
-    } else if (isStringRecord(rawComp)) {
-      return rawComp
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Returns the translated strings for a component in the current locale. Falls back to defaultLocale
- * loaded translations or `baseTranslations` if provided.
- */
-export interface ComponentMessages {
-  [key: string]: string
-}
-
-export function useI18n(componentName: string): ComponentMessages
-export function useI18n<Body extends Translations>(
-  componentName: string,
-  baseTranslations: Body
-): ComponentMessages & Body
-export function useI18n(componentName: string, baseTranslations?: Translations): ComponentMessages {
-  const i18n = getI18nInstance()
-  const activeLocale = currentLocale.get() || baseLocaleDefault
-  const fallbackDict: Record<string, string> = isStringRecord(baseTranslations)
-    ? baseTranslations
-    : {}
-  const baseDict =
-    getCachedComponent(activeLocale, componentName) ??
-    getCachedComponent(baseLocaleDefault, componentName) ??
-    fallbackDict
-
-  const store = i18n(componentName, baseDict)
-  const targetObj = store.get()
-
-  return new Proxy(targetObj, {
-    get(target: Record<string, string>, prop: string | symbol): string {
-      if (typeof prop === "symbol" || prop in Object.prototype) {
-        const val: unknown = Reflect.get(target, prop)
-        return typeof val === "string" ? val : ""
-      }
-      const val = target[prop] ?? baseDict[prop]
-      return val ?? prop
-    }
-  })
-}
-
-/**
- * Async version of useI18n that waits for translations to finish loading.
- */
-export async function useI18nAsync(componentName: string): Promise<ComponentMessages>
-export async function useI18nAsync<Body extends Translations>(
-  componentName: string,
-  baseTranslations: Body
-): Promise<ComponentMessages & Body>
-export async function useI18nAsync(
-  componentName: string,
-  baseTranslations?: Translations
-): Promise<ComponentMessages> {
-  const i18n = getI18nInstance()
-  const activeLocale = currentLocale.get() || baseLocaleDefault
-  const cachedActive = getCachedComponent(activeLocale, componentName)
-  const cachedDefault = getCachedComponent(baseLocaleDefault, componentName)
-  let baseDict: Record<string, string> = cachedActive ?? cachedDefault ?? {}
-  if (!cachedActive && !cachedDefault && isStringRecord(baseTranslations)) {
-    baseDict = baseTranslations
-  }
-
-  const store = i18n(componentName, baseDict)
-  const unsubscribe = store.listen(() => {})
-  await translationsLoading(i18n)
-  unsubscribe()
-  return store.get()
-}
-
-/**
- * Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")`).
- */
-export function t(key: string, params?: Record<string, any>): string
-export function t(
-  astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null,
-  key: string,
-  params?: Record<string, any>
-): string
-export function t(arg1: any, arg2?: any, arg3?: any): string {
-  let key: string
-  let params: Record<string, any> | undefined
-
-  if (typeof arg1 === "string") {
-    key = arg1
-    params = arg2
-  } else {
-    const locale = arg1?.currentLocale || arg1?.params?.locale
-    if (locale) {
-      currentLocale.set(locale)
-    }
-    key = arg2
-    params = arg3
-  }
-
-  const dotIndex = key.indexOf(".")
-  if (dotIndex === -1) {
-    return key
-  }
-  const componentName = key.slice(0, dotIndex)
-  const keyName = key.slice(dotIndex + 1)
-
-  const activeLocale = currentLocale.get() || baseLocaleDefault
-  const componentDict =
-    getCachedComponent(activeLocale, componentName) ??
-    getCachedComponent(baseLocaleDefault, componentName) ??
-    {}
-
-  const value = componentDict[keyName] ?? key
-
-  if (typeof value === "function") {
-    return (value as Function)(params)
-  }
-
-  if (params && typeof value === "string") {
-    return value.replace(/\{(\w+)\}/g, (_, k) => String(params[k] ?? `{${k}}`))
-  }
-
-  return value
-}
-
-/**
- * Clears the translation cache.
- *
- * @param locale - If provided, clears only that locale's cache. Otherwise clears all.
- */
-export function clearCache(locale?: string): void {
-  if (!i18nInstance) throwNotInitialized()
-  const cache = i18nInstance.cache
-  if (locale) {
-    cache[locale] = {}
-  } else {
-    for (const key in cache) cache[key] = {}
-  }
-}

package/src/types.ts

@@ -1,18 +0,0 @@
-import type { ComponentsJSON } from "@nanostores/i18n"
-
-export type { ComponentsJSON }
-
-export interface FlattenedTranslations {
-  [key: string]: string
-}
-
-export interface LocaleFile {
-  [component: string]: {
-    [key: string]: string
-  }
-}
-
-export interface KVNamespaceBinding {
-  get(key: string, type: "json"): Promise<Record<string, string> | null>
-  put(key: string, value: string): Promise<void>
-}

package/src/utils.ts

@@ -1,44 +0,0 @@
-import type { ComponentsJSON, FlattenedTranslations } from "./types"
-
-export function flatten(obj: ComponentsJSON): FlattenedTranslations {
-  const result: FlattenedTranslations = {}
-  for (const [component, translations] of Object.entries(obj)) {
-    if (translations && typeof translations === "object") {
-      for (const [key, value] of Object.entries(translations)) {
-        if (typeof value === "string") {
-          result[`${component}.${key}`] = value
-        }
-      }
-    }
-  }
-  return result
-}
-
-export function unflatten(flat: FlattenedTranslations): ComponentsJSON {
-  const result: ComponentsJSON = {}
-  for (const [key, value] of Object.entries(flat)) {
-    const parts = key.split(".")
-    if (parts.length < 2) continue
-    const component: string = parts[0] ?? ""
-    if (!component) continue
-    const translationKey = parts.slice(1).join(".")
-
-    if (!(component in result)) {
-      result[component] = {}
-    }
-    result[component]![translationKey] = value
-  }
-  return result
-}
-
-export function extractKeys(source: ComponentsJSON): string[] {
-  const keys: string[] = []
-  for (const [component, translations] of Object.entries(source)) {
-    if (translations && typeof translations === "object") {
-      for (const key of Object.keys(translations)) {
-        keys.push(`${component}.${key}`)
-      }
-    }
-  }
-  return keys
-}

package/src/virtual.d.ts

@@ -1,15 +0,0 @@
-declare module "@rimelight/i18n:runtime" {
-  export * from "@rimelight/i18n/runtime"
-}
-
-declare module "virtual:rimelight-i18n-config" {
-  export const locales: string[]
-  export const defaultLocale: string
-}
-
-declare module "cloudflare:workers" {
-  /**
-   * Ambient Cloudflare Workers env — populated at runtime by the CF runtime.
-   */
-  export const env: Record<string, any>
-}