@chipmobilesdk/rn-i18n 0.1.1 → 0.1.3

package/src/translation/interpolate.ts

@@ -1,23 +1,23 @@
-import type { TranslateVars } from '../config/types';
-
-const VARIABLE_PATTERN = /\{\{\s*([\w.]+)\s*\}\}/g;
-
-/**
- * Replaces `{{name}}` placeholders with named values. Missing variables keep
- * their placeholder text so the result stays deterministic, and each missing
- * name is reported through `onMissingVariable`.
- */
-export function interpolate(
-	text: string,
-	vars?: TranslateVars,
-	onMissingVariable?: (name: string) => void,
-): string {
-	return text.replace(VARIABLE_PATTERN, (placeholder, name: string) => {
-		const value = vars?.[name];
-		if (value === undefined || value === null) {
-			onMissingVariable?.(name);
-			return placeholder;
-		}
-		return String(value);
-	});
-}
+import type { TranslateVars } from '../config/types';
+
+const VARIABLE_PATTERN = /\{\{\s*([\w.]+)\s*\}\}/g;
+
+/**
+ * Replaces `{{name}}` placeholders with named values. Missing variables keep
+ * their placeholder text so the result stays deterministic, and each missing
+ * name is reported through `onMissingVariable`.
+ */
+export function interpolate(
+	text: string,
+	vars?: TranslateVars,
+	onMissingVariable?: (name: string) => void,
+): string {
+	return text.replace(VARIABLE_PATTERN, (placeholder, name: string) => {
+		const value = vars?.[name];
+		if (value === undefined || value === null) {
+			onMissingVariable?.(name);
+			return placeholder;
+		}
+		return String(value);
+	});
+}

package/src/translation/plurals.ts

@@ -1,69 +1,62 @@
-import type {
-	LocaleConfig,
-	PluralCategory,
-	PluralRule,
-	TranslationNode,
-} from '../config/types';
-
-export const PLURAL_CATEGORIES: readonly PluralCategory[] = [
-	'zero',
-	'one',
-	'two',
-	'few',
-	'many',
-	'other',
-];
-
-const oneOtherRule: PluralRule = count => (count === 1 ? 'one' : 'other');
-const otherOnlyRule: PluralRule = () => 'other';
-
-/**
- * Package-owned plural rules. Intl.PluralRules is not implemented by Hermes,
- * so rules are resolved from configuration to keep behavior identical across
- * devices and test environments. Languages without a built-in rule use the
- * documented default (`count === 1` selects `one`, everything else `other`)
- * unless the locale configuration supplies a custom rule.
- */
-const BUILT_IN_RULES: Record<string, PluralRule> = {
-	en: oneOtherRule,
-	ja: otherOnlyRule,
-	vi: otherOnlyRule,
-};
-
-export const DEFAULT_PLURAL_RULE: PluralRule = oneOtherRule;
-
-export function resolvePluralRule(locale: LocaleConfig): PluralRule {
-	if (locale.pluralRule) {
-		return locale.pluralRule;
-	}
-	const language = locale.code.split('-')[0]?.toLowerCase() ?? '';
-	return BUILT_IN_RULES[language] ?? DEFAULT_PLURAL_RULE;
-}
-
-/**
- * A plural group is an object whose keys are all plural categories, whose
- * values are all strings, and which provides the required `other` variant.
- */
-export function isPluralGroup(
-	node: TranslationNode,
-): node is Record<string, string> {
-	if (typeof node !== 'object' || node === null) {
-		return false;
-	}
-	const keys = Object.keys(node);
-	if (keys.length === 0 || !('other' in node)) {
-		return false;
-	}
-	return keys.every(
-		key =>
-			(PLURAL_CATEGORIES as readonly string[]).includes(key) &&
-			typeof (node as Record<string, unknown>)[key] === 'string',
-	);
-}
-
-export function selectPluralVariant(
-	group: Record<string, string>,
-	category: PluralCategory,
-): string {
-	return group[category] ?? group.other;
-}
+import type { LocaleConfig, PluralCategory, PluralRule, TranslationNode } from '../config/types';
+
+export const PLURAL_CATEGORIES: readonly PluralCategory[] = [
+	'zero',
+	'one',
+	'two',
+	'few',
+	'many',
+	'other',
+];
+
+const oneOtherRule: PluralRule = count => (count === 1 ? 'one' : 'other');
+const otherOnlyRule: PluralRule = () => 'other';
+
+/**
+ * Package-owned plural rules. Intl.PluralRules is not implemented by Hermes,
+ * so rules are resolved from configuration to keep behavior identical across
+ * devices and test environments. Languages without a built-in rule use the
+ * documented default (`count === 1` selects `one`, everything else `other`)
+ * unless the locale configuration supplies a custom rule.
+ */
+const BUILT_IN_RULES: Record<string, PluralRule> = {
+	en: oneOtherRule,
+	ja: otherOnlyRule,
+	vi: otherOnlyRule,
+};
+
+export const DEFAULT_PLURAL_RULE: PluralRule = oneOtherRule;
+
+export function resolvePluralRule(locale: LocaleConfig): PluralRule {
+	if (locale.pluralRule) {
+		return locale.pluralRule;
+	}
+	const language = locale.code.split('-')[0]?.toLowerCase() ?? '';
+	return BUILT_IN_RULES[language] ?? DEFAULT_PLURAL_RULE;
+}
+
+/**
+ * A plural group is an object whose keys are all plural categories, whose
+ * values are all strings, and which provides the required `other` variant.
+ */
+export function isPluralGroup(node: TranslationNode): node is Record<string, string> {
+	if (typeof node !== 'object' || node === null) {
+		return false;
+	}
+	const keys = Object.keys(node);
+	if (keys.length === 0 || !('other' in node)) {
+		return false;
+	}
+	return keys.every(
+		key =>
+			(PLURAL_CATEGORIES as readonly string[]).includes(key) &&
+			typeof (node as Record<string, unknown>)[key] === 'string',
+	);
+}
+
+export function selectPluralVariant(
+	group: Record<string, string>,
+	category: PluralCategory,
+): string {
+	return group[category] ?? group.other;
+}

package/src/translation/resolver.ts

@@ -1,146 +1,140 @@
-import type {
-	LocaleConfig,
-	MissingTranslationPolicy,
-	TranslateOptions,
-	TranslateVars,
-	TranslationNamespace,
-	TranslationNode,
-	TranslationResources,
-} from '../config/types';
-import { interpolate } from './interpolate';
-import { isPluralGroup, resolvePluralRule, selectPluralVariant } from './plurals';
-import type { RuntimeEntryRegistry } from './runtimeKeys';
-
-export interface ResolverContext {
-	localesByCode: ReadonlyMap<string, LocaleConfig>;
-	resources: TranslationResources;
-	runtimeEntries: RuntimeEntryRegistry;
-	missingTranslation: MissingTranslationPolicy;
-	/** Dedupe set so each failed lookup path warns exactly once. */
-	warned: Set<string>;
-}
-
-export function warnOnce(
-	warned: Set<string>,
-	dedupeKey: string,
-	message: string,
-): void {
-	if (warned.has(dedupeKey)) {
-		return;
-	}
-	warned.add(dedupeKey);
-	console.warn(message);
-}
-
-/** Walks a dot-path key through a nested translation namespace. */
-export function getTranslationNode(
-	namespace: TranslationNamespace | undefined,
-	key: string,
-): TranslationNode | undefined {
-	if (!namespace) {
-		return undefined;
-	}
-	let node: TranslationNode = namespace;
-	for (const segment of key.split('.')) {
-		if (typeof node !== 'object' || node === null) {
-			return undefined;
-		}
-		const next: TranslationNode | undefined = node[segment];
-		if (next === undefined) {
-			return undefined;
-		}
-		node = next;
-	}
-	return node;
-}
-
-function pickValue(
-	node: TranslationNode,
-	locale: LocaleConfig,
-	options: TranslateOptions | undefined,
-	warned: Set<string>,
-	key: string,
-): string | undefined {
-	if (typeof node === 'string') {
-		return node;
-	}
-	if (isPluralGroup(node)) {
-		const count = options?.count;
-		if (count === undefined) {
-			return node.other;
-		}
-		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.`,
-	);
-	return undefined;
-}
-
-/**
- * Resolves a key through the active locale, its ordered fallback chain, and
- * declared runtime-only default text, applying plural selection and named
- * variable interpolation. Misses are reported with one console warning per
- * lookup path; a full-chain miss applies the configured missing-translation
- * policy (FR-008…FR-011, FR-033).
- */
-export function translate(
-	context: ResolverContext,
-	activeCode: string,
-	key: string,
-	vars?: TranslateVars,
-	options?: TranslateOptions,
-): string {
-	const active = context.localesByCode.get(activeCode);
-	const chain = [activeCode, ...(active?.fallbackChain ?? [])];
-	const mergedVars: TranslateVars | undefined =
-		options?.count === undefined ? vars : { count: options.count, ...vars };
-
-	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}".`,
-			),
-		);
-
-	for (const code of chain) {
-		const locale = context.localesByCode.get(code);
-		if (!locale) {
-			continue;
-		}
-		const node = getTranslationNode(context.resources[code], key);
-		if (node === undefined) {
-			continue;
-		}
-		const value = pickValue(node, locale, options, context.warned, 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}".`,
-			);
-		}
-		return interpolateWith(value, code);
-	}
-
-	const runtimeEntry = context.runtimeEntries.get(key);
-	if (runtimeEntry) {
-		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.`,
-	);
-	return context.missingTranslation.mode === 'placeholder'
-		? context.missingTranslation.text
-		: key;
-}
+import type {
+	LocaleConfig,
+	MissingTranslationPolicy,
+	TranslateOptions,
+	TranslateVars,
+	TranslationNamespace,
+	TranslationNode,
+	TranslationResources,
+} from '../config/types';
+import { interpolate } from './interpolate';
+import { isPluralGroup, resolvePluralRule, selectPluralVariant } from './plurals';
+import type { RuntimeEntryRegistry } from './runtimeKeys';
+
+export interface ResolverContext {
+	localesByCode: ReadonlyMap<string, LocaleConfig>;
+	resources: TranslationResources;
+	runtimeEntries: RuntimeEntryRegistry;
+	missingTranslation: MissingTranslationPolicy;
+	/** Dedupe set so each failed lookup path warns exactly once. */
+	warned: Set<string>;
+}
+
+export function warnOnce(warned: Set<string>, dedupeKey: string, message: string): void {
+	if (warned.has(dedupeKey)) {
+		return;
+	}
+	warned.add(dedupeKey);
+	console.warn(message);
+}
+
+/** Walks a dot-path key through a nested translation namespace. */
+export function getTranslationNode(
+	namespace: TranslationNamespace | undefined,
+	key: string,
+): TranslationNode | undefined {
+	if (!namespace) {
+		return undefined;
+	}
+	let node: TranslationNode = namespace;
+	for (const segment of key.split('.')) {
+		if (typeof node !== 'object' || node === null) {
+			return undefined;
+		}
+		const next: TranslationNode | undefined = node[segment];
+		if (next === undefined) {
+			return undefined;
+		}
+		node = next;
+	}
+	return node;
+}
+
+function pickValue(
+	node: TranslationNode,
+	locale: LocaleConfig,
+	options: TranslateOptions | undefined,
+	warned: Set<string>,
+	key: string,
+): string | undefined {
+	if (typeof node === 'string') {
+		return node;
+	}
+	if (isPluralGroup(node)) {
+		const count = options?.count;
+		if (count === undefined) {
+			return node.other;
+		}
+		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.`,
+	);
+	return undefined;
+}
+
+/**
+ * Resolves a key through the active locale, its ordered fallback chain, and
+ * declared runtime-only default text, applying plural selection and named
+ * variable interpolation. Misses are reported with one console warning per
+ * lookup path; a full-chain miss applies the configured missing-translation
+ * policy (FR-008…FR-011, FR-033).
+ */
+export function translate(
+	context: ResolverContext,
+	activeCode: string,
+	key: string,
+	vars?: TranslateVars,
+	options?: TranslateOptions,
+): string {
+	const active = context.localesByCode.get(activeCode);
+	const chain = [activeCode, ...(active?.fallbackChain ?? [])];
+	const mergedVars: TranslateVars | undefined =
+		options?.count === undefined ? vars : { count: options.count, ...vars };
+
+	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}".`,
+			),
+		);
+
+	for (const code of chain) {
+		const locale = context.localesByCode.get(code);
+		if (!locale) {
+			continue;
+		}
+		const node = getTranslationNode(context.resources[code], key);
+		if (node === undefined) {
+			continue;
+		}
+		const value = pickValue(node, locale, options, context.warned, 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}".`,
+			);
+		}
+		return interpolateWith(value, code);
+	}
+
+	const runtimeEntry = context.runtimeEntries.get(key);
+	if (runtimeEntry) {
+		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.`,
+	);
+	return context.missingTranslation.mode === 'placeholder' ? context.missingTranslation.text : key;
+}

package/src/translation/runtimeKeys.ts

@@ -1,27 +1,27 @@
-import type { RuntimeTranslationEntry } from '../config/types';
-
-/**
- * Registry of declared runtime-only translation entries. Entries participate
- * in the same lookup pipeline as scanned template keys and are protected from
- * removal during locale JSON synchronization.
- */
-export type RuntimeEntryRegistry = Map<string, RuntimeTranslationEntry>;
-
-export function createRuntimeRegistry(
-	entries?: readonly RuntimeTranslationEntry[],
-): RuntimeEntryRegistry {
-	const registry: RuntimeEntryRegistry = new Map();
-	if (entries) {
-		registerRuntimeEntries(registry, entries);
-	}
-	return registry;
-}
-
-export function registerRuntimeEntries(
-	registry: RuntimeEntryRegistry,
-	entries: readonly RuntimeTranslationEntry[],
-): void {
-	for (const entry of entries) {
-		registry.set(entry.key, entry);
-	}
-}
+import type { RuntimeTranslationEntry } from '../config/types';
+
+/**
+ * Registry of declared runtime-only translation entries. Entries participate
+ * in the same lookup pipeline as scanned template keys and are protected from
+ * removal during locale JSON synchronization.
+ */
+export type RuntimeEntryRegistry = Map<string, RuntimeTranslationEntry>;
+
+export function createRuntimeRegistry(
+	entries?: readonly RuntimeTranslationEntry[],
+): RuntimeEntryRegistry {
+	const registry: RuntimeEntryRegistry = new Map();
+	if (entries) {
+		registerRuntimeEntries(registry, entries);
+	}
+	return registry;
+}
+
+export function registerRuntimeEntries(
+	registry: RuntimeEntryRegistry,
+	entries: readonly RuntimeTranslationEntry[],
+): void {
+	for (const entry of entries) {
+		registry.set(entry.key, entry);
+	}
+}