@rimelight/i18n 0.0.17 → 0.0.20

package/dist/cli.d.mts

@@ -0,0 +1,3 @@
+//#region src/cli.d.ts
+export declare function runCli(argv?: string[]): Promise<number>;
+//#endregion

package/dist/cli.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { a as fixTranslations, l as verifyTranslations, s as formatAuditReport } from "./utils-WDscZN9H.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+const HELP_TEXT = `
+Usage:
+  rimelight-i18n [action] [options]
+
+Actions:
+  check (default)  Verify translation files across locales for missing, stale, or invalid keys
+
+Options:
+  -d, --dir <path>     Directory containing <locale>.json files (auto-discovered if omitted)
+  -b, --base <locale>  Base/default locale code to compare against (default: "en")
+  -f, --fix            Auto-prune stale keys and generate missing key skeletons
+  --allow-empty        Do not treat empty strings as missing/invalid translations
+  -h, --help           Show this help message
+`;
+function findLocalesDir(customDir) {
+	const cwd = process.cwd();
+	if (customDir) {
+		const resolved = path.resolve(cwd, customDir);
+		return fs.existsSync(resolved) ? resolved : null;
+	}
+	for (const rel of [
+		"src/i18n",
+		"i18n",
+		"src/locales",
+		"locales",
+		"src/assets/i18n"
+	]) {
+		const resolved = path.join(cwd, rel);
+		if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) return resolved;
+	}
+	return null;
+}
+async function runCli(argv = process.argv.slice(2)) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		options: {
+			"dir": {
+				type: "string",
+				short: "d"
+			},
+			"base": {
+				type: "string",
+				short: "b",
+				default: "en"
+			},
+			"fix": {
+				type: "boolean",
+				short: "f",
+				default: false
+			},
+			"allow-empty": {
+				type: "boolean",
+				default: false
+			},
+			"help": {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		},
+		allowPositionals: true
+	});
+	if (values.help) {
+		console.log(HELP_TEXT);
+		return 0;
+	}
+	const action = positionals[0] || "check";
+	if (action !== "check") {
+		console.error(`Unknown action: '${action}'. Run 'rimelight-i18n --help' for usage.`);
+		return 1;
+	}
+	const localesDir = findLocalesDir(values.dir);
+	if (!localesDir) {
+		console.error(`✖ [i18n] Could not find translation directory. Pass --dir <path> (e.g. --dir src/i18n)`);
+		return 1;
+	}
+	const files = fs.readdirSync(localesDir).filter((f) => f.endsWith(".json"));
+	if (files.length === 0) {
+		console.error(`✖ [i18n] No .json translation files found in ${localesDir}`);
+		return 1;
+	}
+	const translations = {};
+	for (const file of files) {
+		const locale = path.basename(file, ".json");
+		const filePath = path.join(localesDir, file);
+		try {
+			const content = fs.readFileSync(filePath, "utf-8");
+			translations[locale] = JSON.parse(content);
+		} catch (err) {
+			console.error(`✖ [i18n] Failed to parse ${file}: ${err?.message || err}`);
+			return 1;
+		}
+	}
+	const baseLocale = values.base || "en";
+	if (!translations[baseLocale]) {
+		console.error(`✖ [i18n] Base locale '${baseLocale}' not found in ${localesDir} (found: ${Object.keys(translations).join(", ")})`);
+		return 1;
+	}
+	let report = verifyTranslations(translations, {
+		defaultLocale: baseLocale,
+		allowEmpty: values["allow-empty"]
+	});
+	if (!report.isValid && values.fix) {
+		console.log(`ℹ [i18n] Fixing translation files in ${localesDir}...`);
+		const fixed = fixTranslations(translations, baseLocale);
+		for (const [locale, data] of Object.entries(fixed)) {
+			const filePath = path.join(localesDir, `${locale}.json`);
+			fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+		}
+		report = verifyTranslations(fixed, {
+			defaultLocale: baseLocale,
+			allowEmpty: values["allow-empty"]
+		});
+		console.log(`✔ [i18n] Successfully updated translation files.`);
+	}
+	const formatted = formatAuditReport(report);
+	if (report.isValid) {
+		console.log(formatted);
+		return 0;
+	} else {
+		console.error(formatted);
+		if (!values.fix) console.error(`\nRun with --fix to automatically prune stale keys and generate missing skeletons.`);
+		return 1;
+	}
+}
+if (process.argv[1] && (import.meta.url === pathToFileURL(process.argv[1]).href || import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/")))) runCli().then((code) => {
+	if (code !== 0) process.exit(code);
+});
+//#endregion
+export { runCli };

package/dist/hono.d.mts

@@ -1,7 +1,25 @@
 //#region src/hono.d.ts
+export interface HonoI18nOptions {
+  /**
+   * List of supported locale codes. Defaults to configured Vite plugin locales.
+   */
+  locales?: string[];
+  /**
+   * The default fallback locale code. Defaults to configured Vite plugin defaultLocale.
+   */
+  defaultLocale?: string;
+  /**
+   * Whether the default locale is prefixed in URLs. Defaults to configured Vite plugin setting.
+   */
+  prefixDefaultLocale?: boolean;
+  /**
+   * The Cloudflare KV namespace binding name (default: "TRANSLATIONS_KV").
+   */
+  kvBinding?: string;
+}
 /**
  * Hono middleware for Rimelight i18n. Handles locale routing, redirection, currentLocale store
  * updates, and Cloudflare KV binding setup.
  */
-export declare function i18n(): (c: any, next: any) => Promise<any>;
+export declare function i18n(options?: HonoI18nOptions): (c: any, next: any) => Promise<any>;
 //#endregion

package/dist/hono.mjs

@@ -1,12 +1,8 @@
-import { n as currentLocale } from "./runtime-LitYNVlO.mjs";
-import { d as setKVBinding } from "./src-BDG_duDk.mjs";
-import { env } from "cloudflare:workers";
-import { defaultLocale, locales, prefixDefaultLocale } from "virtual:rimelight-i18n-config";
+import { n as currentLocale } from "./runtime-D8XFXD5B.mjs";
+import { d as setKVBinding, l as locales, n as defaultLocale, u as prefixDefaultLocale } from "./src--oNux7GS.mjs";
 //#region src/hono.ts
-const SUPPORTED_LOCALES = new Set(locales);
-const DEFAULT_LOCALE = defaultLocale;
-function getPreferredLocale(acceptLanguage) {
-	if (!acceptLanguage) return DEFAULT_LOCALE;
+function getPreferredLocale(acceptLanguage, supportedLocales, defaultLocale) {
+	if (!acceptLanguage) return defaultLocale;
 	const parsed = acceptLanguage.split(",").map((lang) => {
 		const parts = lang.split(";");
 		const code = (parts[0] ?? "").trim().toLowerCase();
@@ -24,20 +20,24 @@ function getPreferredLocale(acceptLanguage) {
 		};
 	}).toSorted((a, b) => b.q - a.q);
 	for (const item of parsed) {
-		if (SUPPORTED_LOCALES.has(item.code)) return item.code;
+		if (supportedLocales.has(item.code)) return item.code;
 		const base = item.base;
-		if (SUPPORTED_LOCALES.has(base)) return base;
+		if (supportedLocales.has(base)) return base;
 	}
-	return DEFAULT_LOCALE;
+	return defaultLocale;
 }
 /**
 * Hono middleware for Rimelight i18n. Handles locale routing, redirection, currentLocale store
 * updates, and Cloudflare KV binding setup.
 */
-function i18n() {
+function i18n(options) {
+	const supportedLocales = new Set(options?.locales ?? locales);
+	const defaultLocale$1 = options?.defaultLocale ?? defaultLocale;
+	const prefixDefaultLocale$1 = options?.prefixDefaultLocale ?? prefixDefaultLocale;
+	const kvKey = options?.kvBinding ?? "TRANSLATIONS_KV";
 	return async (c, next) => {
 		try {
-			const kv = Reflect.get(env, "TRANSLATIONS_KV") || c.env?.TRANSLATIONS_KV;
+			const kv = c.env?.[kvKey];
 			if (kv) setKVBinding(kv);
 		} catch {}
 		const url = new URL(c.req.url);
@@ -45,33 +45,33 @@ function i18n() {
 		if (c.req.method !== "GET" && c.req.method !== "HEAD") {
 			const paramLocale = c.req.param("locale");
 			const firstSegment = pathname.split("/").find(Boolean);
-			const activeLocale = (paramLocale && SUPPORTED_LOCALES.has(paramLocale) ? paramLocale : null) || (firstSegment && SUPPORTED_LOCALES.has(firstSegment) ? firstSegment : null) || DEFAULT_LOCALE;
+			const activeLocale = (paramLocale && supportedLocales.has(paramLocale) ? paramLocale : null) || (firstSegment && supportedLocales.has(firstSegment) ? firstSegment : null) || defaultLocale$1;
 			currentLocale.set(activeLocale);
 			return next();
 		}
 		if (pathname.startsWith("/api") || pathname.startsWith("/_") || pathname.includes(".")) return next();
 		const firstSegment = pathname.split("/").find(Boolean);
-		const firstIsLocale = firstSegment !== void 0 && SUPPORTED_LOCALES.has(firstSegment);
-		if (prefixDefaultLocale) {
+		const firstIsLocale = firstSegment !== void 0 && supportedLocales.has(firstSegment);
+		if (prefixDefaultLocale$1) {
 			const paramLocale = c.req.param("locale");
-			const activeLocale = (paramLocale && SUPPORTED_LOCALES.has(paramLocale) ? paramLocale : null) || (firstIsLocale ? firstSegment : null) || DEFAULT_LOCALE;
+			const activeLocale = (paramLocale && supportedLocales.has(paramLocale) ? paramLocale : null) || (firstIsLocale ? firstSegment : null) || defaultLocale$1;
 			currentLocale.set(activeLocale);
 			if (firstIsLocale) return next();
-			const locale = getPreferredLocale(c.req.header("accept-language") || null);
+			const locale = getPreferredLocale(c.req.header("accept-language") || null, supportedLocales, defaultLocale$1);
 			currentLocale.set(locale);
 			const targetPath = `/${locale}${pathname}${url.search}`;
 			return c.redirect(targetPath, 302);
 		} else {
 			if (firstIsLocale) {
-				if (firstSegment === DEFAULT_LOCALE) {
-					const rest = pathname.slice(DEFAULT_LOCALE.length + 1) || "/";
-					currentLocale.set(DEFAULT_LOCALE);
+				if (firstSegment === defaultLocale$1) {
+					const rest = pathname.slice(defaultLocale$1.length + 1) || "/";
+					currentLocale.set(defaultLocale$1);
 					return c.redirect(`${rest}${url.search}`, 302);
 				}
 				currentLocale.set(firstSegment);
 				return next();
 			}
-			currentLocale.set(DEFAULT_LOCALE);
+			currentLocale.set(defaultLocale$1);
 			return next();
 		}
 	};

package/dist/index.d.mts

@@ -1,16 +1,21 @@
-import { i as KVNamespaceBinding, n as CustomTranslations, o as NestedTranslationKeys, s as TranslationKey, t as ComponentsJSON } from "./types-dxt4IMnV.mjs";
-import { a as getFormatterInstance, c as initializeI18n, d as useI18n, f as useI18nAsync, i as currentLocale, o as getI18nInstance, r as clearCache, s as getPluralCategory, u as useFormat } from "./runtime-Bc8I8sA4.mjs";
+import { c as ReadableAtom, d as TranslationLoader, i as KVNamespaceBinding, m as WritableAtom, n as CustomTranslations, o as NestedTranslationKeys, t as ComponentsJSON, u as TranslationKey } from "./types-PBnVVzPm.mjs";
+import { a as getRawTranslation, c as tArray, i as getPluralCategory, l as tRaw, n as atom, o as initializeI18n, r as currentLocale } from "./runtime-B2W6s31-.mjs";
 import { i as i18n, n as RimelightI18nPlugins, t as RimelightI18nOptions } from "./plugin-CFEm0e4U.mjs";
-import { TranslationLoader } from "@nanostores/i18n";
 //#region src/index.d.ts
 declare let locales: string[];
 declare let defaultLocale: string;
 declare let prefixDefaultLocale: boolean;
+export interface TFunction {
+  <K extends string = TranslationKey>(key: K | TranslationKey, params?: Record<string, any>): string;
+  raw: <T = unknown>(key: string, fallback?: T) => T;
+  array: <T = string>(key: string, fallback?: T[]) => T[];
+}
 /**
  * Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")`).
- * When augmented via CustomTranslations, keys are strictly type-checked and autocompleted.
+ * When augmented via CustomTranslations, keys are strictly type-checked and autocompleted. Also
+ * provides `t.raw()` and `t.array()` methods to retrieve structured data or string arrays.
  */
-export declare function t<K extends string = TranslationKey>(key: K | TranslationKey, params?: Record<string, any>): string;
+export declare const t: TFunction;
 export declare function getLocale(): string;
 /**
  * Returns a standard BCP 47 / RFC 5646 language tag suitable for HTML `<html lang="...">`. Maps
@@ -36,4 +41,4 @@ export declare function getLanguageAlternates(pathname: string, siteUrl?: string
 export declare function setKVBinding(kv: KVNamespaceBinding): void;
 export declare function createTranslationLoader(translations: Record<string, ComponentsJSON>): TranslationLoader;
 //#endregion
-export { type CustomTranslations, type NestedTranslationKeys, type RimelightI18nOptions, type RimelightI18nPlugins, type TranslationKey, clearCache, currentLocale, defaultLocale, getFormatterInstance, getI18nInstance, getPluralCategory, i18n, i18n as rimelightI18n, initializeI18n, locales, prefixDefaultLocale, useFormat, useI18n, useI18nAsync };
+export { type CustomTranslations, type NestedTranslationKeys, type ReadableAtom, type RimelightI18nOptions, type RimelightI18nPlugins, type TranslationKey, type WritableAtom, atom, currentLocale, defaultLocale, getPluralCategory, getRawTranslation, i18n, i18n as rimelightI18n, initializeI18n, locales, prefixDefaultLocale, tArray, tRaw };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as getPluralCategory, c as useFormat, i as getI18nInstance, l as useI18n, n as currentLocale, o as initializeI18n, r as getFormatterInstance, t as clearCache, u as useI18nAsync } from "./runtime-LitYNVlO.mjs";
+import { a as initializeI18n, c as tRaw, i as getRawTranslation, n as currentLocale, r as getPluralCategory, s as tArray, t as atom } from "./runtime-D8XFXD5B.mjs";
 import { t as i18n } from "./plugin-wd6n-2-C.mjs";
-import { a as getLocale, c as getRelativeLocaleUrlList, d as setKVBinding, f as t, i as getLanguageAlternates, l as locales, n as defaultLocale, o as getOgLocale, r as getHtmlLang, s as getRelativeLocaleUrl, t as createTranslationLoader, u as prefixDefaultLocale } from "./src-BDG_duDk.mjs";
-export { clearCache, createTranslationLoader, currentLocale, defaultLocale, getFormatterInstance, getHtmlLang, getI18nInstance, getLanguageAlternates, getLocale, getOgLocale, getPluralCategory, getRelativeLocaleUrl, getRelativeLocaleUrlList, i18n, i18n as rimelightI18n, initializeI18n, locales, prefixDefaultLocale, setKVBinding, t, useFormat, useI18n, useI18nAsync };
+import { a as getLocale, c as getRelativeLocaleUrlList, d as setKVBinding, f as t, i as getLanguageAlternates, l as locales, n as defaultLocale, o as getOgLocale, r as getHtmlLang, s as getRelativeLocaleUrl, t as createTranslationLoader, u as prefixDefaultLocale } from "./src--oNux7GS.mjs";
+export { atom, createTranslationLoader, currentLocale, defaultLocale, getHtmlLang, getLanguageAlternates, getLocale, getOgLocale, getPluralCategory, getRawTranslation, getRelativeLocaleUrl, getRelativeLocaleUrlList, i18n, i18n as rimelightI18n, initializeI18n, locales, prefixDefaultLocale, setKVBinding, t, tArray, tRaw };

package/dist/runtime-B2W6s31-.d.mts

@@ -0,0 +1,60 @@
+import { d as TranslationLoader, m as WritableAtom } from "./types-PBnVVzPm.mjs";
+//#region src/runtime.d.ts
+/**
+ * Creates a lightweight reactive atom store compatible with Nanostores / Svelte store contracts.
+ */
+declare function atom<T>(initialValue: T): WritableAtom<T>;
+/**
+ * A reactive store containing the current locale code. Set by middleware on each request, or
+ * manually via `currentLocale.set(locale)`.
+ */
+declare const currentLocale: WritableAtom<string>;
+interface InitializeI18nOptions {
+  /**
+   * The default locale code (e.g. 'en').
+   */
+  defaultLocale: string;
+  /**
+   * Pre-loaded translations keyed by locale then component.
+   */
+  translations: Record<string, Record<string, any>>;
+  /**
+   * Optional dynamic loader called when a locale or component is not in cache.
+   */
+  get?: TranslationLoader | undefined;
+}
+/**
+ * Initializes the i18n system. Must be called once before any other i18n functions are used (the
+ * integration virtual module does this automatically).
+ */
+declare function initializeI18n(options: InitializeI18nOptions): void;
+/**
+ * Safely retrieves the raw translation entry (string, array, or object) for a given dot-notation
+ * key.
+ */
+declare function getRawTranslation(key: string): unknown;
+/**
+ * Returns raw translation data (such as arrays or nested objects) typed as T.
+ */
+declare function tRaw<T = unknown>(key: string, fallback?: T): T;
+/**
+ * Returns an array of translations (e.g. lists of strings or structured objects). Falls back to an
+ * empty array or the provided fallback if not found or not an array.
+ */
+declare function tArray<T = string>(key: string, fallback?: T[]): T[];
+/**
+ * Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")` or
+ * nested/array paths like `t("page_resume.experiences.0.role")`).
+ */
+declare function t(key: string, params?: Record<string, any>): string;
+declare namespace t {
+  var raw: typeof tRaw;
+  var array: typeof tArray;
+}
+/**
+ * Returns the plural category (e.g. 'one', 'few', 'many', 'other') for a given number and locale
+ * using the native browser Intl.PluralRules API.
+ */
+declare function getPluralCategory(count: number, locale?: string): Intl.LDMLPluralRule;
+//#endregion
+export { getRawTranslation as a, tArray as c, getPluralCategory as i, tRaw as l, atom as n, initializeI18n as o, currentLocale as r, t as s, InitializeI18nOptions as t };

package/dist/runtime-D8XFXD5B.mjs

@@ -0,0 +1,164 @@
+//#region src/runtime.ts
+/**
+* Creates a lightweight reactive atom store compatible with Nanostores / Svelte store contracts.
+*/
+function atom(initialValue) {
+	let value = initialValue;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => value,
+		set: (nextValue) => {
+			if (value !== nextValue) {
+				value = nextValue;
+				for (const listener of listeners) listener(value);
+			}
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			listener(value);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		listen: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* A reactive store containing the current locale code. Set by middleware on each request, or
+* manually via `currentLocale.set(locale)`.
+*/
+const currentLocale = atom("");
+let baseLocaleDefault = "en";
+let rawTranslationsDict = {};
+function isObjectRecord(obj) {
+	return typeof obj === "object" && obj !== null;
+}
+/**
+* Initializes the i18n system. Must be called once before any other i18n functions are used (the
+* integration virtual module does this automatically).
+*/
+function initializeI18n(options) {
+	const { defaultLocale, translations } = options;
+	baseLocaleDefault = defaultLocale;
+	rawTranslationsDict = translations ? { ...translations } : {};
+	if (!currentLocale.get()) currentLocale.set(defaultLocale);
+}
+/**
+* Helper to safely resolve nested dot-notation and array indices while guarding against prototype
+* pollution.
+*/
+function resolvePath(obj, path) {
+	if (obj == null || typeof obj !== "object") return void 0;
+	if (Object.prototype.hasOwnProperty.call(obj, path)) return obj[path];
+	const segments = path.split(".");
+	let current = obj;
+	for (let i = 0; i < segments.length; i++) {
+		if (current == null || typeof current !== "object") return;
+		const seg = segments[i];
+		if (seg === "__proto__" || seg === "constructor" || seg === "prototype") return;
+		if (Object.prototype.hasOwnProperty.call(current, seg) || Array.isArray(current) && seg in current) current = current[seg];
+		else {
+			const remainingKey = segments.slice(i).join(".");
+			if (Object.prototype.hasOwnProperty.call(current, remainingKey)) return current[remainingKey];
+			return;
+		}
+	}
+	return current;
+}
+function getLocaleCandidateChain(activeLocale, defaultLocale) {
+	const chain = [];
+	function addCandidates(code) {
+		if (!code) return;
+		const exact = code;
+		const normalized = code.toLowerCase();
+		const baseLang = normalized.split("-")[0] ?? normalized;
+		if (!chain.includes(exact)) chain.push(exact);
+		if (!chain.includes(normalized)) chain.push(normalized);
+		if (!chain.includes(baseLang)) chain.push(baseLang);
+	}
+	addCandidates(activeLocale);
+	addCandidates(defaultLocale);
+	addCandidates("en");
+	return chain;
+}
+function getCachedComponent(locale, componentName) {
+	const candidates = getLocaleCandidateChain(locale, baseLocaleDefault);
+	for (const code of candidates) {
+		const rawComp = rawTranslationsDict[code]?.[componentName];
+		if (isObjectRecord(rawComp)) return rawComp;
+	}
+}
+function resolveKeyInLocales(locale, componentName, keyName) {
+	const candidates = getLocaleCandidateChain(locale, baseLocaleDefault);
+	for (const code of candidates) {
+		const rawComp = rawTranslationsDict[code]?.[componentName];
+		if (isObjectRecord(rawComp)) {
+			const val = resolvePath(rawComp, keyName);
+			if (val !== void 0) return val;
+		}
+	}
+}
+/**
+* Safely retrieves the raw translation entry (string, array, or object) for a given dot-notation
+* key.
+*/
+function getRawTranslation(key) {
+	const dotIndex = key.indexOf(".");
+	const activeLocale = currentLocale.get() || baseLocaleDefault;
+	if (dotIndex === -1) return getCachedComponent(activeLocale, key) ?? getCachedComponent(baseLocaleDefault, key);
+	return resolveKeyInLocales(activeLocale, key.slice(0, dotIndex), key.slice(dotIndex + 1));
+}
+/**
+* Returns raw translation data (such as arrays or nested objects) typed as T.
+*/
+function tRaw(key, fallback) {
+	const val = getRawTranslation(key);
+	if (val !== void 0) return val;
+	return fallback;
+}
+/**
+* Returns an array of translations (e.g. lists of strings or structured objects). Falls back to an
+* empty array or the provided fallback if not found or not an array.
+*/
+function tArray(key, fallback = []) {
+	const val = getRawTranslation(key);
+	if (Array.isArray(val)) return val;
+	return fallback;
+}
+/**
+* Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")` or
+* nested/array paths like `t("page_resume.experiences.0.role")`).
+*/
+function t(key, params) {
+	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;
+	let value = resolveKeyInLocales(activeLocale, componentName, keyName) ?? key;
+	if (params && typeof params["count"] === "number" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+		const pluralCategory = getPluralCategory(params["count"], activeLocale);
+		value = value[pluralCategory] ?? value["other"] ?? key;
+	}
+	if (typeof value === "function") return value(params);
+	if (params && typeof value === "string") return value.replace(/\{(\w+)\}/g, (_, k) => String(params[k] ?? `{${k}}`));
+	if (typeof value === "string") return value;
+	if (value !== void 0 && value !== null && typeof value === "object") return JSON.stringify(value);
+	return value != null ? `${value}` : "";
+}
+t.raw = tRaw;
+t.array = tArray;
+/**
+* Returns the plural category (e.g. 'one', 'few', 'many', 'other') for a given number and locale
+* using the native browser Intl.PluralRules API.
+*/
+function getPluralCategory(count, locale = "en") {
+	return new Intl.PluralRules(locale).select(count);
+}
+//#endregion
+export { initializeI18n as a, tRaw as c, getRawTranslation as i, currentLocale as n, t as o, getPluralCategory as r, tArray as s, atom as t };

package/dist/runtime.d.mts

@@ -1,2 +1,2 @@
-import { a as getFormatterInstance, c as initializeI18n, d as useI18n, f as useI18nAsync, i as currentLocale, l as t, n as InitializeI18nOptions, o as getI18nInstance, r as clearCache, s as getPluralCategory, t as ComponentMessages, u as useFormat } from "./runtime-Bc8I8sA4.mjs";
-export { ComponentMessages, InitializeI18nOptions, clearCache, currentLocale, getFormatterInstance, getI18nInstance, getPluralCategory, initializeI18n, t, useFormat, useI18n, useI18nAsync };
+import { a as getRawTranslation, c as tArray, i as getPluralCategory, l as tRaw, n as atom, o as initializeI18n, r as currentLocale, s as t, t as InitializeI18nOptions } from "./runtime-B2W6s31-.mjs";
+export { InitializeI18nOptions, atom, currentLocale, getPluralCategory, getRawTranslation, initializeI18n, t, tArray, tRaw };

package/dist/runtime.mjs

@@ -1,2 +1,2 @@
-import { a as getPluralCategory, c as useFormat, i as getI18nInstance, l as useI18n, n as currentLocale, o as initializeI18n, r as getFormatterInstance, s as t, t as clearCache, u as useI18nAsync } from "./runtime-LitYNVlO.mjs";
-export { clearCache, currentLocale, getFormatterInstance, getI18nInstance, getPluralCategory, initializeI18n, t, useFormat, useI18n, useI18nAsync };
+import { a as initializeI18n, c as tRaw, i as getRawTranslation, n as currentLocale, o as t, r as getPluralCategory, s as tArray, t as atom } from "./runtime-D8XFXD5B.mjs";
+export { atom, currentLocale, getPluralCategory, getRawTranslation, initializeI18n, t, tArray, tRaw };

package/dist/{src-BDG_duDk.mjs → src--oNux7GS.mjs}

@@ -1,4 +1,4 @@
-import { n as currentLocale, o as initializeI18n, s as t$1 } from "./runtime-LitYNVlO.mjs";
+import { a as initializeI18n, c as tRaw, n as currentLocale, o as t$1, s as tArray } from "./runtime-D8XFXD5B.mjs";
 //#region src/index.ts
 let locales = ["en"];
 let defaultLocale = "en";
@@ -20,11 +20,15 @@ if (translations && Object.keys(translations).length > 0) initializeI18n({
 });
 /**
 * Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")`).
-* When augmented via CustomTranslations, keys are strictly type-checked and autocompleted.
+* When augmented via CustomTranslations, keys are strictly type-checked and autocompleted. Also
+* provides `t.raw()` and `t.array()` methods to retrieve structured data or string arrays.
 */
-function t(key, params) {
+const t = Object.assign(function(key, params) {
 	return t$1(key, params);
-}
+}, {
+	raw: tRaw,
+	array: tArray
+});
 function getLocale() {
 	return currentLocale.get() || defaultLocale || "en";
 }
@@ -48,7 +52,7 @@ function getOgLocale() {
 	return {
 		en: "en_US",
 		pt: "pt_BR",
-		es: "es_ES"
+		es: "es-ES"
 	}[loc] || `${loc}_${loc.toUpperCase()}`;
 }
 function getRelativeLocaleUrl(arg1, arg2) {

package/dist/types-PBnVVzPm.d.mts

@@ -0,0 +1,64 @@
+//#region src/types.d.ts
+type ComponentsJSON = Record<string, Record<string, any>>;
+type Translations = Record<string, any>;
+type TranslationLoader = (locale: string, components: string[]) => Promise<ComponentsJSON | Record<string, any>>;
+interface ReadableAtom<T> {
+  get(): T;
+  subscribe(listener: (value: T) => void): () => void;
+  listen(listener: (value: T) => void): () => void;
+}
+interface WritableAtom<T> extends ReadableAtom<T> {
+  set(value: T): void;
+}
+interface FlattenedTranslations {
+  [key: string]: string;
+}
+interface PlaceholderMismatch {
+  key: string;
+  basePlaceholders: string[];
+  targetPlaceholders: string[];
+}
+interface TranslationAuditReport {
+  isValid: boolean;
+  totalKeys: number;
+  locales: string[];
+  defaultLocale: string;
+  missingKeys: Record<string, string[]>;
+  staleKeys: Record<string, string[]>;
+  emptyKeys: Record<string, string[]>;
+  placeholderMismatches: Record<string, PlaceholderMismatch[]>;
+  stats: {
+    completion: Record<string, string>;
+  };
+}
+interface VerifyTranslationsOptions {
+  defaultLocale?: string;
+  allowEmpty?: boolean;
+}
+interface LocaleFile {
+  [component: string]: {
+    [key: string]: string;
+  };
+}
+interface KVNamespaceBinding {
+  get(key: string, type: "json"): Promise<Record<string, string> | null>;
+  put(key: string, value: string): Promise<void>;
+}
+/**
+ * Derives dot-notated nested translation keys (e.g. "page_home.section_hero_title" or
+ * "page_resume.experiences.0.role") from a translation schema type.
+ */
+type NestedTranslationKeys<T> = T extends (infer U)[] ? `${number}` | (U extends object ? `${number}.${NestedTranslationKeys<U>}` : never) : T extends object ? { [K in keyof T & (string | number)]: T[K] extends (infer U)[] ? `${K}` | `${K}.${number}` | (U extends object ? `${K}.${number}.${NestedTranslationKeys<U>}` : never) : T[K] extends object ? `${K}` | `${K}.${NestedTranslationKeys<T[K]>}` : `${K}`; }[keyof T & (string | number)] : never;
+/**
+ * Augmented interface for app-level strongly typed translation keys. Applications can declare:
+ *
+ * ```ts
+ * declare module "@rimelight/i18n" {
+ *   interface CustomTranslations extends typeof import("./i18n/en.json") {}
+ * }
+ * ```
+ */
+interface CustomTranslations {}
+type TranslationKey = [keyof CustomTranslations] extends [never] ? string : NestedTranslationKeys<CustomTranslations>;
+//#endregion
+export { LocaleFile as a, ReadableAtom as c, TranslationLoader as d, Translations as f, KVNamespaceBinding as i, TranslationAuditReport as l, WritableAtom as m, CustomTranslations as n, NestedTranslationKeys as o, VerifyTranslationsOptions as p, FlattenedTranslations as r, PlaceholderMismatch as s, ComponentsJSON as t, TranslationKey as u };

package/dist/types.d.mts

@@ -1,2 +1,2 @@
-import { a as LocaleFile, i as KVNamespaceBinding, n as CustomTranslations, o as NestedTranslationKeys, r as FlattenedTranslations, s as TranslationKey, t as ComponentsJSON } from "./types-dxt4IMnV.mjs";
-export { type ComponentsJSON, CustomTranslations, FlattenedTranslations, KVNamespaceBinding, LocaleFile, NestedTranslationKeys, TranslationKey };
+import { a as LocaleFile, c as ReadableAtom, d as TranslationLoader, f as Translations, i as KVNamespaceBinding, l as TranslationAuditReport, m as WritableAtom, n as CustomTranslations, o as NestedTranslationKeys, p as VerifyTranslationsOptions, r as FlattenedTranslations, s as PlaceholderMismatch, t as ComponentsJSON, u as TranslationKey } from "./types-PBnVVzPm.mjs";
+export { ComponentsJSON, CustomTranslations, FlattenedTranslations, KVNamespaceBinding, LocaleFile, NestedTranslationKeys, PlaceholderMismatch, ReadableAtom, TranslationAuditReport, TranslationKey, TranslationLoader, Translations, VerifyTranslationsOptions, WritableAtom };

package/dist/utils-WDscZN9H.mjs

@@ -0,0 +1,202 @@
+//#region src/utils.ts
+/**
+* Flattens deeply nested translation objects or arrays into dot-notated paths.
+*/
+function flatten(obj, prefix = "", result = {}) {
+	if (obj == null || typeof obj !== "object") return result;
+	for (const [key, value] of Object.entries(obj)) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		const fullPath = prefix ? `${prefix}.${key}` : key;
+		if (value != null && typeof value === "object" && !Array.isArray(value)) flatten(value, fullPath, result);
+		else if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			const arrayPath = `${fullPath}.${i}`;
+			if (item != null && typeof item === "object") flatten(item, arrayPath, result);
+			else result[arrayPath] = String(item ?? "");
+		}
+		else result[fullPath] = value != null ? String(value) : "";
+	}
+	return result;
+}
+/**
+* Unflattens a dot-notated translation map back into a nested object structure.
+*/
+function unflatten(flat) {
+	const result = {};
+	for (const [key, value] of Object.entries(flat)) {
+		const parts = key.split(".");
+		let current = result;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (part === "__proto__" || part === "constructor" || part === "prototype") break;
+			const isLast = i === parts.length - 1;
+			const nextPart = parts[i + 1];
+			const nextIsNum = nextPart !== void 0 && /^\d+$/.test(nextPart);
+			if (isLast) current[part] = value;
+			else {
+				if (current[part] == null || typeof current[part] !== "object") current[part] = nextIsNum ? [] : {};
+				current = current[part];
+			}
+		}
+	}
+	return result;
+}
+/**
+* Extracts all dotted translation keys from a translation dictionary.
+*/
+function extractKeys(source) {
+	return Object.keys(flatten(source));
+}
+/**
+* Extracts all interpolation variables like `{name}` or `{count}` from a string.
+*/
+function extractPlaceholders(str) {
+	const matches = str.match(/\{(\w+)\}/g);
+	if (!matches) return [];
+	return Array.from(new Set(matches.map((m) => m.slice(1, -1))));
+}
+/**
+* Compares a target translation dictionary against a base translation dictionary, returning any
+* missing deep dotted keys.
+*/
+function findMissingKeys(base, target) {
+	const baseFlat = flatten(base);
+	const targetFlat = flatten(target);
+	const missing = [];
+	for (const key of Object.keys(baseFlat)) if (!(key in targetFlat)) missing.push(key);
+	return missing;
+}
+/**
+* Compares a target translation dictionary against a base translation dictionary, returning any
+* stale/orphaned keys present in target but absent in base.
+*/
+function findStaleKeys(base, target) {
+	const baseFlat = flatten(base);
+	const targetFlat = flatten(target);
+	const stale = [];
+	for (const key of Object.keys(targetFlat)) if (!(key in baseFlat)) stale.push(key);
+	return stale;
+}
+/**
+* Runs a comprehensive audit across all translation dictionaries comparing against
+* base/defaultLocale.
+*/
+function verifyTranslations(translations, options = {}) {
+	const defaultLocale = options.defaultLocale || "en";
+	const allowEmpty = options.allowEmpty ?? false;
+	const locales = Object.keys(translations);
+	const baseDict = translations[defaultLocale] || {};
+	const baseFlat = flatten(baseDict);
+	const totalKeys = Object.keys(baseFlat).length;
+	const missingKeys = {};
+	const staleKeys = {};
+	const emptyKeys = {};
+	const placeholderMismatches = {};
+	const completion = {};
+	let isValid = true;
+	for (const locale of locales) {
+		const targetDict = translations[locale] || {};
+		const targetFlat = flatten(targetDict);
+		const missing = findMissingKeys(baseDict, targetDict);
+		const stale = findStaleKeys(baseDict, targetDict);
+		const empty = [];
+		const mismatches = [];
+		if (locale !== defaultLocale) {
+			if (missing.length > 0) {
+				missingKeys[locale] = missing;
+				isValid = false;
+			}
+			if (stale.length > 0) {
+				staleKeys[locale] = stale;
+				isValid = false;
+			}
+		}
+		for (const [key, val] of Object.entries(targetFlat)) {
+			if (!allowEmpty && typeof val === "string" && val.trim() === "") {
+				empty.push(key);
+				isValid = false;
+			}
+			if (key in baseFlat) {
+				const baseHolders = extractPlaceholders(baseFlat[key] ?? "").sort();
+				const targetHolders = extractPlaceholders(val).sort();
+				if (JSON.stringify(baseHolders) !== JSON.stringify(targetHolders)) {
+					mismatches.push({
+						key,
+						basePlaceholders: baseHolders,
+						targetPlaceholders: targetHolders
+					});
+					isValid = false;
+				}
+			}
+		}
+		if (empty.length > 0) emptyKeys[locale] = empty;
+		if (mismatches.length > 0) placeholderMismatches[locale] = mismatches;
+		const matchedCount = totalKeys - missing.length;
+		completion[locale] = `${totalKeys > 0 ? Math.round(matchedCount / totalKeys * 100) : 100}%`;
+	}
+	return {
+		isValid,
+		totalKeys,
+		locales,
+		defaultLocale,
+		missingKeys,
+		staleKeys,
+		emptyKeys,
+		placeholderMismatches,
+		stats: { completion }
+	};
+}
+/**
+* Formats a TranslationAuditReport into a human-readable diagnostic message.
+*/
+function formatAuditReport(report) {
+	if (report.isValid) return `✔ [i18n] Verified ${report.locales.length} locales (${report.locales.join(", ")}) — ${report.totalKeys} keys synchronized with 0 issues.`;
+	const lines = [];
+	lines.push(`✖ [i18n] Translation verification failed:`);
+	for (const locale of report.locales) {
+		const missing = report.missingKeys[locale];
+		const stale = report.staleKeys[locale];
+		const empty = report.emptyKeys[locale];
+		const mismatches = report.placeholderMismatches[locale];
+		if (!missing && !stale && !empty && !mismatches) continue;
+		lines.push(`\n  [${locale}] (${report.stats.completion[locale]} complete):`);
+		if (missing && missing.length > 0) {
+			lines.push(`    Missing Keys (${missing.length}):`);
+			for (const k of missing) lines.push(`      - ${k}`);
+		}
+		if (stale && stale.length > 0) {
+			lines.push(`    Stale Keys (${stale.length}, not in '${report.defaultLocale}'):`);
+			for (const k of stale) lines.push(`      - ${k}`);
+		}
+		if (empty && empty.length > 0) {
+			lines.push(`    Empty Keys (${empty.length}):`);
+			for (const k of empty) lines.push(`      - ${k}`);
+		}
+		if (mismatches && mismatches.length > 0) {
+			lines.push(`    Placeholder Mismatches (${mismatches.length}):`);
+			for (const m of mismatches) lines.push(`      - ${m.key}: expected {${m.basePlaceholders.join(", ")}}, found {${m.targetPlaceholders.join(", ")}}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Automatically prunes stale keys and injects missing key skeletons from the base locale.
+*/
+function fixTranslations(translations, defaultLocale = "en") {
+	const baseFlat = flatten(translations[defaultLocale] || {});
+	const fixed = {};
+	for (const [locale, dict] of Object.entries(translations)) {
+		if (locale === defaultLocale) {
+			fixed[locale] = dict;
+			continue;
+		}
+		const targetFlat = flatten(dict);
+		const newFlat = {};
+		for (const [baseKey, baseVal] of Object.entries(baseFlat)) if (baseKey in targetFlat) newFlat[baseKey] = targetFlat[baseKey];
+		else newFlat[baseKey] = baseVal;
+		fixed[locale] = unflatten(newFlat);
+	}
+	return fixed;
+}
+//#endregion
+export { fixTranslations as a, unflatten as c, findStaleKeys as i, verifyTranslations as l, extractPlaceholders as n, flatten as o, findMissingKeys as r, formatAuditReport as s, extractKeys as t };

package/dist/utils.d.mts

@@ -1,11 +1,42 @@
-import { r as FlattenedTranslations, t as ComponentsJSON } from "./types-dxt4IMnV.mjs";
+import { l as TranslationAuditReport, p as VerifyTranslationsOptions, r as FlattenedTranslations, t as ComponentsJSON } from "./types-PBnVVzPm.mjs";
 //#region src/utils.d.ts
-export declare function flatten(obj: ComponentsJSON): FlattenedTranslations;
+/**
+ * Flattens deeply nested translation objects or arrays into dot-notated paths.
+ */
+export declare function flatten(obj: Record<string, any>, prefix?: string, result?: FlattenedTranslations): FlattenedTranslations;
+/**
+ * Unflattens a dot-notated translation map back into a nested object structure.
+ */
 export declare function unflatten(flat: FlattenedTranslations): ComponentsJSON;
-export declare function extractKeys(source: ComponentsJSON): string[];
 /**
- * Compares a target translation dictionary against a base/source translation dictionary, returning
- * any missing component keys.
+ * Extracts all dotted translation keys from a translation dictionary.
+ */
+export declare function extractKeys(source: Record<string, any>): string[];
+/**
+ * Extracts all interpolation variables like `{name}` or `{count}` from a string.
+ */
+export declare function extractPlaceholders(str: string): string[];
+/**
+ * Compares a target translation dictionary against a base translation dictionary, returning any
+ * missing deep dotted keys.
+ */
+export declare function findMissingKeys(base: Record<string, any>, target: Record<string, any>): string[];
+/**
+ * Compares a target translation dictionary against a base translation dictionary, returning any
+ * stale/orphaned keys present in target but absent in base.
+ */
+export declare function findStaleKeys(base: Record<string, any>, target: Record<string, any>): string[];
+/**
+ * Runs a comprehensive audit across all translation dictionaries comparing against
+ * base/defaultLocale.
+ */
+export declare function verifyTranslations(translations: Record<string, Record<string, any>>, options?: VerifyTranslationsOptions): TranslationAuditReport;
+/**
+ * Formats a TranslationAuditReport into a human-readable diagnostic message.
+ */
+export declare function formatAuditReport(report: TranslationAuditReport): string;
+/**
+ * Automatically prunes stale keys and injects missing key skeletons from the base locale.
  */
-export declare function findMissingKeys(base: Record<string, Record<string, any>>, target: Record<string, Record<string, any>>): string[];
+export declare function fixTranslations(translations: Record<string, Record<string, any>>, defaultLocale?: string): Record<string, Record<string, any>>;
 //#endregion

package/dist/utils.mjs

@@ -1,43 +1,2 @@
-//#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 };
+import { a as fixTranslations, c as unflatten, i as findStaleKeys, l as verifyTranslations, n as extractPlaceholders, o as flatten, r as findMissingKeys, s as formatAuditReport, t as extractKeys } from "./utils-WDscZN9H.mjs";
+export { extractKeys, extractPlaceholders, findMissingKeys, findStaleKeys, fixTranslations, flatten, formatAuditReport, unflatten, verifyTranslations };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelight/i18n",
-  "version": "0.0.17",
+  "version": "0.0.20",
   "private": false,
   "description": "Rimelight Entertainment's Internationalization Package",
   "homepage": "https://rimelight.com/docs",
@@ -15,6 +15,9 @@
     "type": "git",
     "url": "git+https://github.com/Rimelight-Entertainment/rimelight.git"
   },
+  "bin": {
+    "rimelight-i18n": "./dist/cli.mjs"
+  },
   "files": [
     "dist"
   ],
@@ -43,21 +46,21 @@
     "./utils": {
       "types": "./dist/utils.d.mts",
       "import": "./dist/utils.mjs"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.mts",
+      "import": "./dist/cli.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@nanostores/i18n": "1.3.3",
-    "nanostores": "1.5.3"
-  },
   "devDependencies": {
-    "@rimelight/config": "0.0.15",
+    "@rimelight/config": "0.0.20",
     "typescript": "6.0.3"
   },
   "engines": {
-    "node": ">=26.8.2"
+    "node": ">=26.9.0"
   },
   "scripts": {
     "build": "vp pack",

package/dist/runtime-Bc8I8sA4.d.mts

@@ -1,72 +0,0 @@
-import { Components, I18n, TranslationLoader, Translations, formatter } from "@nanostores/i18n";
-//#region src/runtime.d.ts
-/**
- * A reactive store containing the current locale code. Set by middleware on each request, or
- * manually via `currentLocale.set(locale)`.
- */
-declare const currentLocale: import("nanostores").PreinitializedWritableAtom<string> & object;
-type I18nInstance = I18n;
-type FormatterInstance = ReturnType<typeof formatter>;
-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).
- */
-declare function initializeI18n(options: InitializeI18nOptions): void;
-/**
- * Returns the underlying nanostores/i18n instance. Throws if not initialized.
- */
-declare function getI18nInstance(): I18nInstance;
-/**
- * Returns the formatter instance. Throws if not initialized.
- */
-declare function getFormatterInstance(): FormatterInstance;
-/**
- * Returns a Formatter object for the current locale with methods for formatting numbers, dates, and
- * relative times using the native Intl API.
- */
-declare function useFormat(): ReturnType<FormatterInstance["get"]>;
-/**
- * Returns the translated strings for a component in the current locale. Falls back to defaultLocale
- * loaded translations or `baseTranslations` if provided.
- */
-interface ComponentMessages {
-  [key: string]: string;
-}
-declare function useI18n(componentName: string): ComponentMessages;
-declare function useI18n<Body extends Translations>(componentName: string, baseTranslations: Body): ComponentMessages & Body;
-/**
- * Async version of useI18n that waits for translations to finish loading.
- */
-declare function useI18nAsync(componentName: string): Promise<ComponentMessages>;
-declare function useI18nAsync<Body extends Translations>(componentName: string, baseTranslations: Body): Promise<ComponentMessages & Body>;
-/**
- * Translates a single string key using dot-notation (e.g. `t("page_home.section_hero_title")`).
- */
-declare function t(key: string, params?: Record<string, any>): string;
-/**
- * Returns the plural category (e.g. 'one', 'few', 'many', 'other') for a given number and locale
- * using the native browser Intl.PluralRules API.
- */
-declare function getPluralCategory(count: number, locale?: string): Intl.LDMLPluralRule;
-/**
- * Clears the translation cache.
- *
- * @param locale - If provided, clears only that locale's cache. Otherwise clears all.
- */
-declare function clearCache(locale?: string): void;
-//#endregion
-export { getFormatterInstance as a, initializeI18n as c, useI18n as d, useI18nAsync as f, currentLocale as i, t as l, InitializeI18nOptions as n, getI18nInstance as o, clearCache as r, getPluralCategory as s, ComponentMessages as t, useFormat as u };

package/dist/runtime-LitYNVlO.mjs

@@ -1,183 +0,0 @@
-import { createI18n, formatter, translationsLoading } from "@nanostores/i18n";
-import { atom } from "nanostores";
-//#region src/runtime.ts
-/**
-* A reactive store containing the current locale code. Set by middleware on each request, or
-* manually via `currentLocale.set(locale)`.
-*/
-const currentLocale = atom("");
-let i18nInstance;
-let formatterInstance;
-let baseLocaleDefault = "en";
-let rawTranslationsDict = {};
-function throwNotInitialized() {
-	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) {
-	return async (code, components) => {
-		const raw = await loader(code, components);
-		const normalised = Array.isArray(raw) ? Object.assign({}, ...raw) : { ...raw };
-		for (const component of components) if (!(component in normalised)) normalised[component] = {};
-		return normalised;
-	};
-}
-/**
-* Initializes the i18n system. Must be called once before any other i18n functions are used (the
-* integration virtual module does this automatically).
-*/
-function initializeI18n(options) {
-	const { defaultLocale, translations, get } = options;
-	baseLocaleDefault = defaultLocale;
-	rawTranslationsDict = translations || {};
-	if (!i18nInstance) {
-		currentLocale.set(defaultLocale);
-		const formattedCache = {};
-		for (const [locale, components] of Object.entries(translations)) {
-			formattedCache[locale] = {};
-			for (const [compName, compBody] of Object.entries(components)) {
-				let bodyObj = {};
-				if (isStringRecord(compBody)) bodyObj = compBody;
-				else if (isStoreWithGet(compBody)) {
-					const res = compBody.get();
-					if (isStringRecord(res)) bodyObj = res;
-				}
-				formattedCache[locale][compName] = atom(bodyObj);
-			}
-		}
-		i18nInstance = createI18n(currentLocale, {
-			baseLocale: defaultLocale,
-			get: wrapLoader(get ?? (async () => ({}))),
-			cache: formattedCache,
-			isSSR: true
-		});
-	}
-	formatterInstance = formatter(currentLocale);
-}
-/**
-* Returns the underlying nanostores/i18n instance. Throws if not initialized.
-*/
-function getI18nInstance() {
-	if (!i18nInstance) throwNotInitialized();
-	return i18nInstance;
-}
-/**
-* Returns the formatter instance. Throws if not initialized.
-*/
-function getFormatterInstance() {
-	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.
-*/
-function useFormat() {
-	return getFormatterInstance().get();
-}
-function isStoreWithGet(obj) {
-	if (typeof obj !== "object" || obj === null) return false;
-	return typeof Reflect.get(obj, "get") === "function";
-}
-function isStringRecord(obj) {
-	return typeof obj === "object" && obj !== null;
-}
-function getCachedComponent(locale, componentName) {
-	const normalizedLocale = locale.toLowerCase();
-	const candidates = [
-		locale,
-		normalizedLocale,
-		normalizedLocale.split("-")[0] ?? normalizedLocale,
-		baseLocaleDefault
-	];
-	for (const code of candidates) {
-		const rawComp = rawTranslationsDict[code]?.[componentName];
-		if (isStoreWithGet(rawComp)) {
-			const res = rawComp.get();
-			if (isStringRecord(res)) return res;
-		} else if (isStringRecord(rawComp)) return rawComp;
-	}
-	if (!i18nInstance) return void 0;
-	for (const code of candidates) {
-		const rawComp = i18nInstance.cache[code]?.[componentName];
-		if (isStoreWithGet(rawComp)) {
-			const res = rawComp.get();
-			if (isStringRecord(res)) return res;
-		} else if (isStringRecord(rawComp)) return rawComp;
-	}
-}
-function useI18n(componentName, baseTranslations) {
-	const i18n = getI18nInstance();
-	const activeLocale = currentLocale.get() || baseLocaleDefault;
-	const fallbackDict = isStringRecord(baseTranslations) ? baseTranslations : {};
-	const baseDict = getCachedComponent(activeLocale, componentName) ?? getCachedComponent(baseLocaleDefault, componentName) ?? fallbackDict;
-	const targetObj = i18n(componentName, baseDict).get();
-	return new Proxy(targetObj, { get(target, prop) {
-		if (typeof prop === "symbol" || prop in Object.prototype) {
-			const val = Reflect.get(target, prop);
-			return typeof val === "string" ? val : "";
-		}
-		return target[prop] ?? baseDict[prop] ?? prop;
-	} });
-}
-async function useI18nAsync(componentName, baseTranslations) {
-	const i18n = getI18nInstance();
-	const cachedActive = getCachedComponent(currentLocale.get() || baseLocaleDefault, componentName);
-	const cachedDefault = getCachedComponent(baseLocaleDefault, componentName);
-	let baseDict = 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")`).
-*/
-function t(key, params) {
-	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;
-	let value = (getCachedComponent(activeLocale, componentName) ?? getCachedComponent(baseLocaleDefault, componentName) ?? {})[keyName] ?? key;
-	if (params && typeof params["count"] === "number" && typeof value === "object" && value !== null) {
-		const pluralCategory = getPluralCategory(params["count"], activeLocale);
-		value = value[pluralCategory] ?? value["other"] ?? key;
-	}
-	if (typeof value === "function") return value(params);
-	if (params && typeof value === "string") return value.replace(/\{(\w+)\}/g, (_, k) => String(params[k] ?? `{${k}}`));
-	return typeof value === "string" ? value : String(value);
-}
-/**
-* Returns the plural category (e.g. 'one', 'few', 'many', 'other') for a given number and locale
-* using the native browser Intl.PluralRules API.
-*/
-function getPluralCategory(count, locale = "en") {
-	return new Intl.PluralRules(locale).select(count);
-}
-/**
-* Clears the translation cache.
-*
-* @param locale - If provided, clears only that locale's cache. Otherwise clears all.
-*/
-function clearCache(locale) {
-	if (!i18nInstance) throwNotInitialized();
-	const cache = i18nInstance.cache;
-	if (locale) cache[locale] = {};
-	else for (const key in cache) cache[key] = {};
-}
-//#endregion
-export { getPluralCategory as a, useFormat as c, getI18nInstance as i, useI18n as l, currentLocale as n, initializeI18n as o, getFormatterInstance as r, t as s, clearCache as t, useI18nAsync as u };

package/dist/types-dxt4IMnV.d.mts

@@ -1,32 +0,0 @@
-import { ComponentsJSON } from "@nanostores/i18n";
-//#region src/types.d.ts
-interface FlattenedTranslations {
-  [key: string]: string;
-}
-interface LocaleFile {
-  [component: string]: {
-    [key: string]: string;
-  };
-}
-interface KVNamespaceBinding {
-  get(key: string, type: "json"): Promise<Record<string, string> | null>;
-  put(key: string, value: string): Promise<void>;
-}
-/**
- * Derives dot-notated nested translation keys (e.g. "page_home.section_hero_title") from a
- * translation schema type.
- */
-type NestedTranslationKeys<T> = T extends object ? { [K in keyof T & (string | number)]: T[K] extends object ? `${K}.${NestedTranslationKeys<T[K]>}` : `${K}`; }[keyof T & (string | number)] : never;
-/**
- * Augmented interface for app-level strongly typed translation keys. Applications can declare:
- *
- * ```ts
- * declare module "@rimelight/i18n" {
- *   interface CustomTranslations extends typeof import("./i18n/en.json") {}
- * }
- * ```
- */
-interface CustomTranslations {}
-type TranslationKey = [keyof CustomTranslations] extends [never] ? string : NestedTranslationKeys<CustomTranslations>;
-//#endregion
-export { LocaleFile as a, KVNamespaceBinding as i, CustomTranslations as n, NestedTranslationKeys as o, FlattenedTranslations as r, TranslationKey as s, ComponentsJSON as t };