@rimelight/i18n 0.0.6 → 0.0.8

package/dist/utils.mjs

@@ -0,0 +1,43 @@
+//#region src/utils.ts
+function flatten(obj) {
+	const result = {};
+	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;
+}
+function unflatten(flat) {
+	const result = {};
+	for (const [key, value] of Object.entries(flat)) {
+		const parts = key.split(".");
+		if (parts.length < 2) continue;
+		const component = parts[0] ?? "";
+		if (!component) continue;
+		const translationKey = parts.slice(1).join(".");
+		if (!(component in result)) result[component] = {};
+		result[component][translationKey] = value;
+	}
+	return result;
+}
+function extractKeys(source) {
+	const keys = [];
+	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;
+}
+/**
+* Compares a target translation dictionary against a base/source translation dictionary, returning
+* any missing component keys.
+*/
+function findMissingKeys(base, target) {
+	const missing = [];
+	for (const [component, keys] of Object.entries(base)) {
+		if (!target[component] || typeof target[component] !== "object") {
+			missing.push(component);
+			continue;
+		}
+		for (const key of Object.keys(keys)) if (target[component][key] === void 0) missing.push(`${component}.${key}`);
+	}
+	return missing;
+}
+//#endregion
+export { extractKeys, findMissingKeys, flatten, unflatten };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelight/i18n",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "private": false,
   "description": "Rimelight Entertainment's Internationalization Package",
   "homepage": "https://rimelight.com/docs",
@@ -16,41 +16,51 @@
     "url": "git+https://github.com/Rimelight-Entertainment/rimelight.git"
   },
   "files": [
-    "src"
+    "dist"
   ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./integration": "./src/integration.ts",
-    "./middleware": "./src/middleware.ts",
-    "./runtime": "./src/runtime.ts",
-    "./types": "./src/types.ts",
-    "./utils": "./src/utils.ts"
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.mts",
+      "import": "./dist/plugin.mjs"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.mts",
+      "import": "./dist/hono.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.mts",
+      "import": "./dist/runtime.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/types.mjs"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.mts",
+      "import": "./dist/utils.mjs"
+    }
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@nanostores/i18n": "1.3.3",
-    "nanostores": "1.5.2"
+    "nanostores": "1.5.3"
   },
   "devDependencies": {
-    "@rimelight/config": "0.0.3",
-    "astro": "7.2.7",
+    "@rimelight/config": "0.0.4",
     "typescript": "6.0.3"
   },
-  "peerDependencies": {
-    "astro": ">=7.0.0"
-  },
-  "peerDependenciesMeta": {
-    "astro": {
-      "optional": true
-    }
-  },
   "engines": {
     "node": ">=26.7.0"
   },
   "scripts": {
+    "build": "vp pack",
     "check": "vp check --fix"
   }
 }

package/src/env.d.ts

@@ -1,13 +0,0 @@
-// 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

@@ -1,143 +0,0 @@
-import type { TranslationLoader } from "@nanostores/i18n"
-import type { ComponentsJSON, KVNamespaceBinding } from "./types"
-import {
-  useI18n as baseUseI18n,
-  useI18nAsync as baseUseI18nAsync,
-  t,
-  currentLocale,
-  useFormat,
-  clearCache,
-  getI18nInstance,
-  getFormatterInstance
-} from "@rimelight/i18n:runtime"
-import type { Translations } from "@nanostores/i18n"
-
-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
-): 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; params?: Record<string, any> } | undefined | null,
-  componentName: string,
-  baseTranslations: Body
-): ComponentMessages & Body
-export function useI18n(arg1: any, arg2?: any, arg3?: any): any {
-  if (typeof arg1 === "string") {
-    return baseUseI18n(arg1, arg2)
-  } else {
-    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<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; params?: Record<string, any> } | undefined | null,
-  componentName: string,
-  baseTranslations: Body
-): 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 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 = getLocale()
-    return astroGetRelativeLocaleUrl(locale, arg1)
-  }
-}
-
-let kvBinding: KVNamespaceBinding | null = null
-
-export function setKVBinding(kv: KVNamespaceBinding) {
-  kvBinding = kv
-}
-
-export function createTranslationLoader(
-  translations: Record<string, ComponentsJSON>
-): TranslationLoader {
-  return async (locale, components) => {
-    const localeTranslations = translations[locale] || {}
-
-    // If components is not provided, is not an array, or is empty, return the entire locale's translations.
-    if (!components || !Array.isArray(components) || components.length === 0) {
-      return localeTranslations
-    }
-
-    const activeKv = kvBinding
-    if (activeKv) {
-      try {
-        const results = await Promise.all(
-          components.map(async (name) => {
-            const key = `locale:${locale}:${name}`
-            const data = await activeKv.get(key, "json")
-            // Fall back to bundled translation for this component if missing in KV
-            if (data == null) {
-              return { [name]: localeTranslations[name] ?? {} }
-            }
-            return { [name]: data }
-          })
-        )
-        return Object.assign({}, ...results)
-      } catch {
-        // KV read failed — fall through to static
-      }
-    }
-
-    const results = await Promise.all(
-      components.map(async (name) => {
-        const data = localeTranslations[name]
-        return { [name]: data ?? {} }
-      })
-    )
-    return Object.assign({}, ...results)
-  }
-}
-
-/**
- * Returns the plural category (e.g. 'one', 'few', 'many', 'other') for a given number and locale
- * using the native browser Intl.PluralRules API.
- */
-export function getPluralCategory(count: number, locale: string = "en"): Intl.LDMLPluralRule {
-  return new Intl.PluralRules(locale).select(count)
-}

package/src/integration.ts

@@ -1,185 +0,0 @@
-import type { AstroIntegration } from "astro"
-import fs from "node:fs"
-import path from "node:path"
-
-export interface RimelightI18nOptions {
-  validateExtraction?: boolean
-  translations?: Record<string, Record<string, any>>
-  kvBinding?: string
-  translationLoader?: string
-}
-
-export function rimelightI18n(options?: RimelightI18nOptions): AstroIntegration[] {
-  const validateExtraction = options?.validateExtraction ?? true
-  const translations = options?.translations
-  const kvBinding = options?.kvBinding ?? "TRANSLATIONS_KV"
-  const translationLoader = options?.translationLoader
-
-  // Normalise translations passed in options
-  const normalisedTranslations: Record<string, any> = {}
-  if (translations) {
-    for (const [locale, val] of Object.entries(translations)) {
-      normalisedTranslations[locale] = val
-    }
-  }
-
-  // ---------- Vite virtual module: @rimelight/i18n:runtime ----------
-  // This replicates what astro-nanostores-i18n integration.js used to do:
-  // it creates a virtual module that calls initializeI18n() once at module
-  // evaluation time and re-exports all runtime helpers.
-  const VIRTUAL_MODULE_ID = "@rimelight/i18n:runtime"
-  const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID
-
-  // Use the package export specifier so Vite resolves it through normal
-  // module resolution rather than an absolute filesystem path.
-  const runtimeSpecifier = "@rimelight/i18n/runtime"
-
-  const loaderImport = translationLoader
-    ? `import translationLoader from ${JSON.stringify(translationLoader)};`
-    : ""
-  const loaderOption = translationLoader ? ", get: translationLoader" : ""
-
-  // ----------------------------------------------------------------
-
-  const rimelightI18nCore: AstroIntegration = {
-    name: "@rimelight/i18n",
-    hooks: {
-      "astro:config:setup": ({ config, addMiddleware, updateConfig, logger }) => {
-        const locales = config.i18n?.locales ?? ["en"]
-        const defaultLocale = config.i18n?.defaultLocale ?? "en"
-
-        const virtualModuleContent = `\
-import { initializeI18n, useFormat, useI18n, useI18nAsync, t,
-         currentLocale, getI18nInstance, getFormatterInstance, clearCache }
-  from ${JSON.stringify(runtimeSpecifier)};
-${loaderImport}
-
-initializeI18n({
-  defaultLocale: ${JSON.stringify(defaultLocale)},
-  translations: ${JSON.stringify(normalisedTranslations)}${loaderOption}
-});
-
-export { useFormat, useI18n, useI18nAsync, t, currentLocale,
-         getI18nInstance, getFormatterInstance, clearCache };
-`
-
-        addMiddleware({
-          entrypoint: "@rimelight/i18n/middleware",
-          order: "pre"
-        })
-
-        updateConfig({
-          vite: {
-            ssr: {
-              noExternal: ["@rimelight/i18n"]
-            },
-            plugins: [
-              // Virtual module: @rimelight/i18n:runtime
-              {
-                name: "vite-plugin-rimelight-i18n-runtime",
-                resolveId(id) {
-                  if (id === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_MODULE_ID
-                  return null
-                },
-                load(id) {
-                  if (id === RESOLVED_VIRTUAL_MODULE_ID) return virtualModuleContent
-                  return null
-                }
-              },
-              // Virtual module: virtual:rimelight-i18n-config (locale metadata)
-              {
-                name: "vite-plugin-rimelight-i18n-config",
-                resolveId(id) {
-                  if (id === "virtual:rimelight-i18n-config") return "\0" + id
-                  return null
-                },
-                load(id) {
-                  if (id === "\0virtual:rimelight-i18n-config") {
-                    return `
-                      export const locales = ${JSON.stringify(locales)};
-                      export const defaultLocale = ${JSON.stringify(defaultLocale)};
-                    `
-                  }
-                  return null
-                }
-              }
-            ]
-          }
-        })
-
-        if (validateExtraction) {
-          logger.info("i18n extraction validation active")
-        }
-      },
-
-      "astro:config:done": ({ injectTypes }) => {
-        // Inject ambient type declarations for the virtual module so TypeScript
-        // and editor tooling know the shape of @rimelight/i18n:runtime.
-        injectTypes({
-          filename: "rimelight-i18n.d.ts",
-          content: `\
-declare module "@rimelight/i18n:runtime" {
-  import type { Translations } from '@nanostores/i18n';
-  export type { InitializeI18nOptions } from '@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 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;
-}
-`
-        })
-      },
-
-      "astro:build:done": async ({ logger }) => {
-        if (translations) {
-          const seedData: { keys: { key: string; value: string }[] } = { keys: [] }
-          for (const [locale, localeData] of Object.entries(translations)) {
-            for (const [component, componentData] of Object.entries(localeData)) {
-              seedData.keys.push({
-                key: `locale:${locale}:${component}`,
-                value: JSON.stringify(componentData)
-              })
-            }
-          }
-          const outDir = process.env.WRANGLER_OUT_DIR ?? "dist"
-          const seedFile = path.join(outDir, "_translations-seed.json")
-          fs.mkdirSync(path.dirname(seedFile), { recursive: true })
-          fs.writeFileSync(seedFile, JSON.stringify(seedData, null, 2))
-          logger.info(`translations seed file written to ${seedFile}`)
-
-          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)")
-        }
-      }
-    }
-  }
-
-  return [rimelightI18nCore]
-}

package/src/middleware/kv.ts

@@ -1,10 +0,0 @@
-import { setKVBinding } from "../index"
-import { env } from "cloudflare:workers"
-
-export const onRequest = async (_context: unknown, next: () => Promise<Response>) => {
-  const kv = Reflect.get(env, "TRANSLATIONS_KV")
-  if (kv) {
-    setKVBinding(kv)
-  }
-  return next()
-}

package/src/middleware/routing.ts

@@ -1,78 +0,0 @@
-import { locales, defaultLocale } from "virtual:rimelight-i18n-config"
-import { currentLocale } from "../runtime"
-
-const SUPPORTED_LOCALES = new Set(locales)
-const DEFAULT_LOCALE = defaultLocale
-
-function getPreferredLocale(acceptLanguage: string | null): string {
-  if (!acceptLanguage) return DEFAULT_LOCALE
-
-  const parsed = acceptLanguage
-    .split(",")
-    .map((lang) => {
-      const parts = lang.split(";")
-      const code = (parts[0] ?? "").trim().toLowerCase()
-      const base = code.split("-")[0] ?? ""
-      let q = 1.0
-      const qualityPart = parts[1]
-      if (qualityPart) {
-        const qMatch = qualityPart.match(/q=([0-9.]+)/)
-        if (qMatch) {
-          q = parseFloat(qMatch[1] ?? "1")
-        }
-      }
-      return { code, base, q }
-    })
-    .toSorted((a, b) => b.q - a.q)
-
-  for (const item of parsed) {
-    if (SUPPORTED_LOCALES.has(item.code)) {
-      return item.code
-    }
-    const base: string = item.base
-    if (SUPPORTED_LOCALES.has(base)) {
-      return base
-    }
-  }
-
-  return DEFAULT_LOCALE
-}
-
-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()
-  }
-
-  // Skip API routes, internal Astro routes, and files with extensions
-  if (pathname.startsWith("/api") || pathname.startsWith("/_") || pathname.includes(".")) {
-    return next()
-  }
-
-  // Check if pathname starts with a supported locale prefix
-  if (firstSegment && SUPPORTED_LOCALES.has(firstSegment)) {
-    return next()
-  }
-
-  // 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/middleware.ts

@@ -1,12 +0,0 @@
-import { env } from "cloudflare:workers"
-import { setKVBinding } from "./index"
-
-export const onRequest = async (_context: unknown, next: () => Promise<Response>) => {
-  const kv = Reflect.get(env, "TRANSLATIONS_KV")
-  if (kv) {
-    setKVBinding(kv)
-  }
-  return next()
-}
-
-export { i18n } from "./middleware/routing"