@chipmobilesdk/rn-i18n 0.1.3 → 0.3.0

package/src/translation/resolver.ts

@@ -1,3 +1,4 @@
+import type { I18nDiagnostic, I18nDiagnosticHandler } from '../config/diagnostics';
 import type {
 	LocaleConfig,
 	MissingTranslationPolicy,
@@ -18,14 +19,30 @@ export interface ResolverContext {
 	missingTranslation: MissingTranslationPolicy;
 	/** Dedupe set so each failed lookup path warns exactly once. */
 	warned: Set<string>;
+	report: I18nDiagnosticHandler;
 }
 
-export function warnOnce(warned: Set<string>, dedupeKey: string, message: string): void {
+/**
+ * How many lookup paths are remembered. An app that misses many distinct keys
+ * forgets the oldest first, so memory stays bounded (I18N-11).
+ */
+const WARNED_CAPACITY = 500;
+
+export function warnOnce(
+	context: Pick<ResolverContext, 'warned' | 'report'>,
+	dedupeKey: string,
+	diagnostic: I18nDiagnostic,
+): void {
+	const { warned } = context;
 	if (warned.has(dedupeKey)) {
 		return;
 	}
 	warned.add(dedupeKey);
-	console.warn(message);
+	if (warned.size > WARNED_CAPACITY) {
+		const oldest = warned.values().next().value;
+		if (oldest !== undefined) warned.delete(oldest);
+	}
+	context.report(diagnostic);
 }
 
 /** Walks a dot-path key through a nested translation namespace. */
@@ -54,7 +71,7 @@ function pickValue(
 	node: TranslationNode,
 	locale: LocaleConfig,
 	options: TranslateOptions | undefined,
-	warned: Set<string>,
+	warnings: Pick<ResolverContext, 'warned' | 'report'>,
 	key: string,
 ): string | undefined {
 	if (typeof node === 'string') {
@@ -67,11 +84,12 @@ function pickValue(
 		}
 		return selectPluralVariant(node, resolvePluralRule(locale)(count));
 	}
-	warnOnce(
-		warned,
-		`invalid-value|${locale.code}|${key}`,
-		`[rn-i18n] Translation value for "${key}" in locale "${locale.code}" is not text or a plural group; treating it as missing.`,
-	);
+	warnOnce(warnings, `invalid-value|${locale.code}|${key}`, {
+		code: 'invalid_value',
+		key,
+		locale: locale.code,
+		message: `Translation value for "${key}" in locale "${locale.code}" is not text or a plural group; treating it as missing.`,
+	});
 	return undefined;
 }
 
@@ -96,11 +114,12 @@ export function translate(
 
 	const interpolateWith = (text: string, sourceLocale: string) =>
 		interpolate(text, mergedVars, name =>
-			warnOnce(
-				context.warned,
-				`missing-var|${sourceLocale}|${key}|${name}`,
-				`[rn-i18n] Missing interpolation variable "${name}" for key "${key}" in locale "${sourceLocale}".`,
-			),
+			warnOnce(context, `missing-var|${sourceLocale}|${key}|${name}`, {
+				code: 'missing_variable',
+				key,
+				locale: sourceLocale,
+				message: `Missing interpolation variable "${name}" for key "${key}" in locale "${sourceLocale}".`,
+			}),
 		);
 
 	for (const code of chain) {
@@ -112,16 +131,17 @@ export function translate(
 		if (node === undefined) {
 			continue;
 		}
-		const value = pickValue(node, locale, options, context.warned, key);
+		const value = pickValue(node, locale, options, context, key);
 		if (value === undefined) {
 			continue;
 		}
 		if (code !== activeCode) {
-			warnOnce(
-				context.warned,
-				`fallback|${activeCode}|${key}`,
-				`[rn-i18n] Key "${key}" is missing in locale "${activeCode}"; served from fallback locale "${code}".`,
-			);
+			warnOnce(context, `fallback|${activeCode}|${key}`, {
+				code: 'fallback_used',
+				key,
+				locale: activeCode,
+				message: `Key "${key}" is missing in locale "${activeCode}"; served from fallback locale "${code}".`,
+			});
 		}
 		return interpolateWith(value, code);
 	}
@@ -131,10 +151,11 @@ export function translate(
 		return interpolateWith(runtimeEntry.defaultText, activeCode);
 	}
 
-	warnOnce(
-		context.warned,
-		`missing|${activeCode}|${key}`,
-		`[rn-i18n] Missing translation for key "${key}" in locale "${activeCode}" and its entire fallback chain.`,
-	);
+	warnOnce(context, `missing|${activeCode}|${key}`, {
+		code: 'missing_translation',
+		key,
+		locale: activeCode,
+		message: `Missing translation for key "${key}" in locale "${activeCode}" and its entire fallback chain.`,
+	});
 	return context.missingTranslation.mode === 'placeholder' ? context.missingTranslation.text : key;
 }

package/src/translation/runtimeKeys.ts

@@ -1,4 +1,4 @@
-import type { RuntimeTranslationEntry } from '../config/types';
+import { I18nConfigError, type RuntimeTranslationEntry } from '../config/types';
 
 /**
  * Registry of declared runtime-only translation entries. Entries participate
@@ -17,10 +17,37 @@ export function createRuntimeRegistry(
 	return registry;
 }
 
+/**
+ * The same checks the configured entries get (I18N-06): an entry registered at
+ * runtime by a lazily loaded feature used to be written in unvalidated, so a
+ * missing key or a non-string default surfaced only when a screen rendered it.
+ */
+export function validateRuntimeEntries(entries: readonly RuntimeTranslationEntry[]): void {
+	const issues: string[] = [];
+	const seen = new Set<string>();
+	for (const entry of entries) {
+		if (!entry?.key) {
+			issues.push('Runtime-only entries must declare a non-empty key.');
+			continue;
+		}
+		if (seen.has(entry.key)) {
+			issues.push(`Duplicate runtime-only entry "${entry.key}".`);
+		}
+		seen.add(entry.key);
+		if (typeof entry.defaultText !== 'string') {
+			issues.push(`Runtime-only entry "${entry.key}" must declare default text.`);
+		}
+	}
+	if (issues.length > 0) {
+		throw new I18nConfigError(issues);
+	}
+}
+
 export function registerRuntimeEntries(
 	registry: RuntimeEntryRegistry,
 	entries: readonly RuntimeTranslationEntry[],
 ): void {
+	validateRuntimeEntries(entries);
 	for (const entry of entries) {
 		registry.set(entry.key, entry);
 	}