npm - @rimelight/i18n - Versions diffs - 0.0.4 → 0.0.5 - Mend

@rimelight/i18n 0.0.4 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +19 -0
package/package.json +30 -6
package/src/env.d.ts +13 -1
package/src/index.ts +37 -14
package/src/integration.ts +28 -19
package/src/middleware/routing.ts +13 -2
package/src/runtime.ts +176 -9
package/src/virtual.d.ts +0 -1
package/LICENSE +0 -21

package/README.md ADDED Viewed

@@ -0,0 +1,19 @@
+# Rimelight Entertainment Workspace
+## Structure
+### Apps (`/packages`)
+- **`rimelight.com`**: The main company website.
+- **`starter.rimelight.com`**: Our standardized starter template for Astro websites.
+### Packages (`/packages`)
+- **`@rimelight/auth`**: Authentication and authorization utilities for the Rimelight ecosystem.
+- **`@rimelight/cli`**: The command line interface for managing Rimelight projects.
+- **`@rimelight/cms`**: Enterprise content management, block rendering, and wiki engine.
+- **`@rimelight/docs`**: Documentation components and utilities.
+- **`@rimelight/i18n`**: Internationalization and localization tools.
+- **`@rimelight/security`**: Astro security integration (CSP, SRI, and more).
+- **`@rimelight/seo`**: SEO utilities including sitemap, robots, and meta components.
+- **`@rimelight/ui`**: Our component library used in all our web projects.

package/package.json CHANGED Viewed

@@ -1,8 +1,20 @@
 {
   "name": "@rimelight/i18n",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "private": false,
-  "description": "Rimelight i18n — unified translation loader with optional KV backing",
+  "description": "Rimelight Entertainment's Internationalization Package",
+  "homepage": "https://rimelight.com/docs",
+  "bugs": {
+    "url": "https://github.com/Rimelight-Entertainment/rimelight/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Rimelight Entertainment"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rimelight-Entertainment/rimelight.git"
+  },
   "files": [
     "src"
   ],
@@ -15,19 +27,31 @@
     "./types": "./src/types.ts",
     "./utils": "./src/utils.ts"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "check": "node -e \"process.exit(0)\""
+    "check": "pnpm audit --audit-level=moderate && vp check --fix"
   },
   "dependencies": {
     "@nanostores/i18n": "1.3.3",
-    "nanostores": "1.4.0"
+    "nanostores": "1.5.1"
+  },
+  "devDependencies": {
+    "@rimelight/config": "workspace:*",
+    "astro": "7.2.2",
+    "typescript": "6.0.3"
   },
   "peerDependencies": {
-    "astro": ">=6.0.0"
+    "astro": ">=7.0.0"
   },
   "peerDependenciesMeta": {
     "astro": {
       "optional": true
     }
-  }
+  },
+  "engines": {
+    "node": ">=26.7.0"
+  },
+  "packageManager": "pnpm@11.22.0"
 }

package/src/env.d.ts CHANGED Viewed

@@ -1 +1,13 @@
-/// <reference types="astro/client" />
+// Enables importing .astro components inside .ts files (e.g., email rendering)
+declare module "*.astro" {
+  export default {} as import("astro/runtime/server").AstroComponentFactory
+}
+declare module "astro:i18n" {
+  export function getRelativeLocaleUrl(locale: string, path?: string): string
+  export function getAbsoluteLocaleUrl(locale: string, path?: string): string
+}
+declare module "@rimelight/i18n:runtime" {
+  export * from "./runtime"
+}

package/src/index.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import type { ComponentsJSON, KVNamespaceBinding } from "./types"
 import {
   useI18n as baseUseI18n,
   useI18nAsync as baseUseI18nAsync,
+  t,
   currentLocale,
   useFormat,
   clearCache,
@@ -11,55 +12,77 @@ import {
 } from "@rimelight/i18n:runtime"
 import type { Translations } from "@nanostores/i18n"
-export { currentLocale, useFormat, clearCache, getI18nInstance, getFormatterInstance }
+export { t, currentLocale, useFormat, clearCache, getI18nInstance, getFormatterInstance }
+export interface ComponentMessages {
+  [key: string]: string
+}
+export function useI18n(componentName: string): ComponentMessages
 export function useI18n<Body extends Translations>(
   componentName: string,
   baseTranslations: Body
-): Body
+): ComponentMessages & Body
+export function useI18n(
+  astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null,
+  componentName: string
+): ComponentMessages
 export function useI18n<Body extends Translations>(
-  astro: { currentLocale?: string | undefined } | undefined | null,
+  astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null,
   componentName: string,
   baseTranslations: Body
-): Body
-export function useI18n(arg1: any, arg2: any, arg3?: any): any {
+): ComponentMessages & Body
+export function useI18n(arg1: any, arg2?: any, arg3?: any): any {
   if (typeof arg1 === "string") {
     return baseUseI18n(arg1, arg2)
   } else {
-    const activeLocale = arg1?.currentLocale ?? "en"
-    currentLocale.set(activeLocale)
+    const locale = arg1?.currentLocale || arg1?.params?.locale
+    if (locale) {
+      currentLocale.set(locale)
+    }
     return baseUseI18n(arg2, arg3)
   }
 }
+export function useI18nAsync(componentName: string): Promise<Record<string, string>>
 export function useI18nAsync<Body extends Translations>(
   componentName: string,
   baseTranslations: Body
-): Promise<Body>
+): Promise<Record<string, string> & Body>
+export function useI18nAsync(
+  astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null,
+  componentName: string
+): Promise<Record<string, string>>
 export function useI18nAsync<Body extends Translations>(
-  astro: { currentLocale?: string | undefined } | undefined | null,
+  astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null,
   componentName: string,
   baseTranslations: Body
-): Promise<Body>
-export function useI18nAsync(arg1: any, arg2: any, arg3?: any): any {
+): Promise<Record<string, string> & Body>
+export function useI18nAsync(arg1: any, arg2?: any, arg3?: any): any {
   if (typeof arg1 === "string") {
     return baseUseI18nAsync(arg1, arg2)
   } else {
-    const activeLocale = arg1?.currentLocale ?? "en"
-    currentLocale.set(activeLocale)
+    const locale = arg1?.currentLocale || arg1?.params?.locale
+    if (locale) {
+      currentLocale.set(locale)
+    }
     return baseUseI18nAsync(arg2, arg3)
   }
 }
 import { getRelativeLocaleUrl as astroGetRelativeLocaleUrl } from "astro:i18n"
+export function getLocale(): string {
+  return currentLocale.get() || "en"
+}
 export function getRelativeLocaleUrl(path: string): string
 export function getRelativeLocaleUrl(locale: string, path: string): string
 export function getRelativeLocaleUrl(arg1: string, arg2?: string): string {
   if (arg2 !== undefined) {
     return astroGetRelativeLocaleUrl(arg1, arg2)
   } else {
-    const locale = currentLocale.get() || "en"
+    const locale = getLocale()
     return astroGetRelativeLocaleUrl(locale, arg1)
   }
 }

package/src/integration.ts CHANGED Viewed

@@ -15,11 +15,11 @@ export function rimelightI18n(options?: RimelightI18nOptions): AstroIntegration[
   const kvBinding = options?.kvBinding ?? "TRANSLATIONS_KV"
   const translationLoader = options?.translationLoader
-  // Normalise locale keys: "pt" → "pt-br" for nanostores compatibility
+  // Normalise translations passed in options
   const normalisedTranslations: Record<string, any> = {}
   if (translations) {
     for (const [locale, val] of Object.entries(translations)) {
-      normalisedTranslations[locale === "pt" ? "pt-br" : locale] = val
+      normalisedTranslations[locale] = val
     }
   }
@@ -49,7 +49,7 @@ export function rimelightI18n(options?: RimelightI18nOptions): AstroIntegration[
         const defaultLocale = config.i18n?.defaultLocale ?? "en"
         const virtualModuleContent = `\
-import { initializeI18n, useFormat, useI18n, useI18nAsync,
+import { initializeI18n, useFormat, useI18n, useI18nAsync, t,
          currentLocale, getI18nInstance, getFormatterInstance, clearCache }
   from ${JSON.stringify(runtimeSpecifier)};
 ${loaderImport}
@@ -59,7 +59,7 @@ initializeI18n({
   translations: ${JSON.stringify(normalisedTranslations)}${loaderOption}
 });
-export { useFormat, useI18n, useI18nAsync, currentLocale,
+export { useFormat, useI18n, useI18nAsync, t, currentLocale,
          getI18nInstance, getFormatterInstance, clearCache };
 `
@@ -124,8 +124,14 @@ declare module "@rimelight/i18n:runtime" {
   export const currentLocale: import('nanostores').PreinitializedWritableAtom<string> & object;
   export declare function initializeI18n(options: import('@rimelight/i18n/runtime').InitializeI18nOptions): void;
   export declare function useFormat(): import('@nanostores/i18n').Formatter;
-  export declare function useI18n<Body extends Translations>(componentName: string, baseTranslations: Body): Body;
-  export declare function useI18nAsync<Body extends Translations>(componentName: string, baseTranslations: Body): Promise<Body>;
+  export type ComponentMessages = Record<string, string>;
+  export declare function useI18n(componentName: string): ComponentMessages;
+  export declare function useI18n<Body extends Translations>(componentName: string, baseTranslations: Body): ComponentMessages & Body;
+  export declare function useI18nAsync(componentName: string): Promise<Record<string, string>>;
+  export declare function useI18nAsync<Body extends Translations>(componentName: string, baseTranslations: Body): Promise<Record<string, string> & Body>;
+  export declare function t(key: string, params?: Record<string, any>): string;
+  export declare function t(astro: { currentLocale?: string | undefined; params?: Record<string, any> } | undefined | null, key: string, params?: Record<string, any>): string;
+  export declare function getLocale(): string;
   export declare function getI18nInstance(): ReturnType<typeof import('@nanostores/i18n').createI18n>;
   export declare function getFormatterInstance(): ReturnType<typeof import('@nanostores/i18n').formatter>;
   export declare function clearCache(locale?: string): void;
@@ -151,19 +157,22 @@ declare module "@rimelight/i18n:runtime" {
           fs.writeFileSync(seedFile, JSON.stringify(seedData, null, 2))
           logger.info(`translations seed file written to ${seedFile}`)
-          try {
-            const { execSync } = await import("node:child_process")
-            execSync(`npx wrangler kv:bulk put --binding "${kvBinding}" "${seedFile}"`, {
-              stdio: "pipe",
-              timeout: 30_000
-            })
-            logger.info(`KV "${kvBinding}" seeded with translations`)
-          } catch {
-            logger.warn(
-              `could not seed KV automatically — run ` +
-                `"npx wrangler kv:bulk put --binding "${kvBinding}" "${seedFile}"" ` +
-                `to seed translations into KV`
-            )
+          const autoSeed = process.env.WRANGLER_SEED_KV === "true" || process.env.CI === "true"
+          if (autoSeed) {
+            try {
+              const { execSync } = await import("node:child_process")
+              execSync(`npx wrangler kv:bulk put --binding "${kvBinding}" "${seedFile}"`, {
+                stdio: "pipe",
+                timeout: 30_000
+              })
+              logger.info(`KV "${kvBinding}" seeded with translations`)
+            } catch {
+              logger.warn(
+                `could not seed KV automatically — run ` +
+                  `"npx wrangler kv:bulk put --binding "${kvBinding}" "${seedFile}"" ` +
+                  `to seed translations into KV`
+              )
+            }
           }
         } else {
           logger.info("i18n build complete (no translations to seed)")

package/src/middleware/routing.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { locales, defaultLocale } from "virtual:rimelight-i18n-config"
+import { currentLocale } from "../runtime"
 const SUPPORTED_LOCALES = new Set(locales)
 const DEFAULT_LOCALE = defaultLocale
@@ -41,6 +42,17 @@ export const i18n = async (context: any, next: any) => {
   const url = new URL(context.request.url)
   const pathname = url.pathname
+  // Extract active locale from request context
+  const paramLocale = context.params?.locale
+  const firstSegment = pathname.split("/").find(Boolean)
+  const activeLocale =
+    (paramLocale && SUPPORTED_LOCALES.has(paramLocale) ? paramLocale : null) ||
+    (firstSegment && SUPPORTED_LOCALES.has(firstSegment) ? firstSegment : null) ||
+    context.currentLocale ||
+    DEFAULT_LOCALE
+  currentLocale.set(activeLocale)
   // Only handle GET/HEAD requests
   if (context.request.method !== "GET" && context.request.method !== "HEAD") {
     return next()
@@ -52,8 +64,6 @@ export const i18n = async (context: any, next: any) => {
   }
   // Check if pathname starts with a supported locale prefix
-  const firstSegment = pathname.split("/").find(Boolean)
   if (firstSegment && SUPPORTED_LOCALES.has(firstSegment)) {
     return next()
   }
@@ -61,6 +71,7 @@ export const i18n = async (context: any, next: any) => {
   // Redirect to the preferred locale
   const acceptLanguage = context.request.headers.get("accept-language")
   const locale = getPreferredLocale(acceptLanguage)
+  currentLocale.set(locale)
   const targetPath = `/${locale}${pathname}${url.search}`
   return context.redirect(targetPath, 302)

package/src/runtime.ts CHANGED Viewed

@@ -19,6 +19,8 @@ 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.")
@@ -70,12 +72,34 @@ export interface InitializeI18nOptions {
  */
 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: translations,
+      cache: formattedCache,
       isSSR: true
     })
   }
@@ -107,32 +131,175 @@ export function useFormat(): ReturnType<FormatterInstance["get"]> {
 }
 /**
- * Returns the translated strings for a component in the current locale. Falls back to
- * `baseTranslations` for any key not present in the loaded locale.
+ * 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
-): Body {
-  return getI18nInstance()(componentName, baseTranslations).get()
+): 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. Required when using a
- * dynamic translationLoader (e.g. KV-backed loading).
+ * 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<Body> {
+): Promise<ComponentMessages & Body>
+export async function useI18nAsync(
+  componentName: string,
+  baseTranslations?: Translations
+): Promise<ComponentMessages> {
   const i18n = getI18nInstance()
-  const store = i18n(componentName, baseTranslations)
+  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.
  *

package/src/virtual.d.ts CHANGED Viewed

@@ -11,6 +11,5 @@ declare module "cloudflare:workers" {
   /**
    * Ambient Cloudflare Workers env — populated at runtime by the CF runtime.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export const env: Record<string, any>
 }

package/LICENSE DELETED Viewed

@@ -1,21 +0,0 @@
-MIT License
-Copyright (c) 2026 Rimelight Entertainment
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.