@lingo.dev/compiler 0.1.0

package/build/translators/pluralization/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/translators/pluralization/types.ts"],"sourcesContent":[],"mappings":";;;;KAkBY,mBAAA;gBACI"}

package/build/translators/pseudotranslator/index.cjs

@@ -0,0 +1,129 @@
+
+//#region src/translators/pseudotranslator/index.ts
+/**
+* Pseudo-translator that uses pseudolocalization
+* Useful for testing i18n without actual translation APIs
+*/
+var PseudoTranslator = class {
+	constructor(config, logger) {
+		this.config = config;
+		this.logger = logger;
+	}
+	translate(locale, entries) {
+		this.logger.debug(`[TRACE-PSEUDO] translate() ENTERED for ${locale} with ${Object.keys(entries).length} entries`);
+		const delay = this.config?.delayMedian ?? 0;
+		const actualDelay = this.getRandomDelay(delay);
+		this.logger.debug(`[TRACE-PSEUDO] Config delay: ${delay}ms, actual delay: ${actualDelay}ms`);
+		return new Promise((resolve) => {
+			this.logger.debug(`[TRACE-PSEUDO] Promise created, scheduling setTimeout for ${actualDelay}ms`);
+			setTimeout(() => {
+				this.logger.debug(`[TRACE-PSEUDO] setTimeout callback fired for ${locale}, processing entries`);
+				const result = Object.fromEntries(Object.entries(entries).map(([hash, entry]) => {
+					return [hash, `${locale}/${pseudolocalize(entry.text)}`];
+				}));
+				this.logger.debug(`[TRACE-PSEUDO] Pseudolocalization complete, resolving with ${Object.keys(result).length} translations`);
+				resolve(result);
+				this.logger.debug(`[TRACE-PSEUDO] Promise resolved for ${locale}`);
+			}, actualDelay);
+			this.logger.debug(`[TRACE-PSEUDO] setTimeout scheduled, returning promise`);
+		});
+	}
+	getRandomDelay(median) {
+		if (median === 0) return 0;
+		const min = median * .5;
+		const max = median * 1.5;
+		return Math.floor(Math.random() * (max - min + 1)) + min;
+	}
+};
+/**
+* Character map for pseudolocalization
+*/
+const PSEUDO_MAP = {
+	a: "á",
+	b: "ḅ",
+	c: "ç",
+	d: "ḍ",
+	e: "é",
+	f: "ƒ",
+	g: "ĝ",
+	h: "ĥ",
+	i: "í",
+	j: "ĵ",
+	k: "ḳ",
+	l: "ĺ",
+	m: "ṁ",
+	n: "ñ",
+	o: "ó",
+	p: "ṗ",
+	q: "ɋ",
+	r: "ŕ",
+	s: "ś",
+	t: "ţ",
+	u: "ú",
+	v: "ṿ",
+	w: "ŵ",
+	x: "ẋ",
+	y: "ý",
+	z: "ẑ",
+	A: "Á",
+	B: "Ḅ",
+	C: "Ç",
+	D: "Ḍ",
+	E: "É",
+	F: "Ƒ",
+	G: "Ĝ",
+	H: "Ĥ",
+	I: "Í",
+	J: "Ĵ",
+	K: "Ḳ",
+	L: "Ĺ",
+	M: "Ṁ",
+	N: "Ñ",
+	O: "Ó",
+	P: "Ṗ",
+	Q: "Ɋ",
+	R: "Ŕ",
+	S: "Ś",
+	T: "Ţ",
+	U: "Ú",
+	V: "Ṿ",
+	W: "Ŵ",
+	X: "Ẋ",
+	Y: "Ý",
+	Z: "Ẑ"
+};
+/**
+* Pseudolocalize a string
+* Adds brackets, expands length by ~30%, and uses accented characters
+* Preserves variable placeholders {name} and component tags <a0>, </a0>
+*/
+function pseudolocalize(text) {
+	if (!text.trim() || text.match(/^{.*}$/)) return text;
+	const preserveRegex = /(\{\w+}|<\/?\w+\/?>)/g;
+	const parts = [];
+	let lastIndex = 0;
+	let match;
+	while ((match = preserveRegex.exec(text)) !== null) {
+		if (match.index > lastIndex) parts.push({
+			text: text.substring(lastIndex, match.index),
+			preserve: false
+		});
+		parts.push({
+			text: match[0],
+			preserve: true
+		});
+		lastIndex = preserveRegex.lastIndex;
+	}
+	if (lastIndex < text.length) parts.push({
+		text: text.substring(lastIndex),
+		preserve: false
+	});
+	let result = "";
+	for (const part of parts) if (part.preserve) result += part.text;
+	else for (const char of part.text) result += PSEUDO_MAP[char] || char;
+	const padding = " ".repeat(Math.ceil(text.length * .3));
+	return `${result}${padding}`;
+}
+
+//#endregion
+exports.PseudoTranslator = PseudoTranslator;

package/build/translators/pseudotranslator/index.mjs

@@ -0,0 +1,129 @@
+//#region src/translators/pseudotranslator/index.ts
+/**
+* Pseudo-translator that uses pseudolocalization
+* Useful for testing i18n without actual translation APIs
+*/
+var PseudoTranslator = class {
+	constructor(config, logger) {
+		this.config = config;
+		this.logger = logger;
+	}
+	translate(locale, entries) {
+		this.logger.debug(`[TRACE-PSEUDO] translate() ENTERED for ${locale} with ${Object.keys(entries).length} entries`);
+		const delay = this.config?.delayMedian ?? 0;
+		const actualDelay = this.getRandomDelay(delay);
+		this.logger.debug(`[TRACE-PSEUDO] Config delay: ${delay}ms, actual delay: ${actualDelay}ms`);
+		return new Promise((resolve) => {
+			this.logger.debug(`[TRACE-PSEUDO] Promise created, scheduling setTimeout for ${actualDelay}ms`);
+			setTimeout(() => {
+				this.logger.debug(`[TRACE-PSEUDO] setTimeout callback fired for ${locale}, processing entries`);
+				const result = Object.fromEntries(Object.entries(entries).map(([hash, entry]) => {
+					return [hash, `${locale}/${pseudolocalize(entry.text)}`];
+				}));
+				this.logger.debug(`[TRACE-PSEUDO] Pseudolocalization complete, resolving with ${Object.keys(result).length} translations`);
+				resolve(result);
+				this.logger.debug(`[TRACE-PSEUDO] Promise resolved for ${locale}`);
+			}, actualDelay);
+			this.logger.debug(`[TRACE-PSEUDO] setTimeout scheduled, returning promise`);
+		});
+	}
+	getRandomDelay(median) {
+		if (median === 0) return 0;
+		const min = median * .5;
+		const max = median * 1.5;
+		return Math.floor(Math.random() * (max - min + 1)) + min;
+	}
+};
+/**
+* Character map for pseudolocalization
+*/
+const PSEUDO_MAP = {
+	a: "á",
+	b: "ḅ",
+	c: "ç",
+	d: "ḍ",
+	e: "é",
+	f: "ƒ",
+	g: "ĝ",
+	h: "ĥ",
+	i: "í",
+	j: "ĵ",
+	k: "ḳ",
+	l: "ĺ",
+	m: "ṁ",
+	n: "ñ",
+	o: "ó",
+	p: "ṗ",
+	q: "ɋ",
+	r: "ŕ",
+	s: "ś",
+	t: "ţ",
+	u: "ú",
+	v: "ṿ",
+	w: "ŵ",
+	x: "ẋ",
+	y: "ý",
+	z: "ẑ",
+	A: "Á",
+	B: "Ḅ",
+	C: "Ç",
+	D: "Ḍ",
+	E: "É",
+	F: "Ƒ",
+	G: "Ĝ",
+	H: "Ĥ",
+	I: "Í",
+	J: "Ĵ",
+	K: "Ḳ",
+	L: "Ĺ",
+	M: "Ṁ",
+	N: "Ñ",
+	O: "Ó",
+	P: "Ṗ",
+	Q: "Ɋ",
+	R: "Ŕ",
+	S: "Ś",
+	T: "Ţ",
+	U: "Ú",
+	V: "Ṿ",
+	W: "Ŵ",
+	X: "Ẋ",
+	Y: "Ý",
+	Z: "Ẑ"
+};
+/**
+* Pseudolocalize a string
+* Adds brackets, expands length by ~30%, and uses accented characters
+* Preserves variable placeholders {name} and component tags <a0>, </a0>
+*/
+function pseudolocalize(text) {
+	if (!text.trim() || text.match(/^{.*}$/)) return text;
+	const preserveRegex = /(\{\w+}|<\/?\w+\/?>)/g;
+	const parts = [];
+	let lastIndex = 0;
+	let match;
+	while ((match = preserveRegex.exec(text)) !== null) {
+		if (match.index > lastIndex) parts.push({
+			text: text.substring(lastIndex, match.index),
+			preserve: false
+		});
+		parts.push({
+			text: match[0],
+			preserve: true
+		});
+		lastIndex = preserveRegex.lastIndex;
+	}
+	if (lastIndex < text.length) parts.push({
+		text: text.substring(lastIndex),
+		preserve: false
+	});
+	let result = "";
+	for (const part of parts) if (part.preserve) result += part.text;
+	else for (const char of part.text) result += PSEUDO_MAP[char] || char;
+	const padding = " ".repeat(Math.ceil(text.length * .3));
+	return `${result}${padding}`;
+}
+
+//#endregion
+export { PseudoTranslator };
+//# sourceMappingURL=index.mjs.map

package/build/translators/pseudotranslator/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["config: PseudoTranslatorConfig","logger: Logger","PSEUDO_MAP: Record<string, string>","parts: Array<{ text: string; preserve: boolean }>","match: RegExpExecArray | null"],"sources":["../../../src/translators/pseudotranslator/index.ts"],"sourcesContent":["/**\n * Pseudotranslator for testing without actual translation APIs\n */\n\nimport type { TranslatableEntry, Translator } from \"../api\";\nimport { Logger } from \"../../utils/logger\";\nimport type { LocaleCode } from \"lingo.dev/spec\";\n\nexport interface PseudoTranslatorConfig {\n  delayMedian?: number;\n}\n\n/**\n * Pseudo-translator that uses pseudolocalization\n * Useful for testing i18n without actual translation APIs\n */\nexport class PseudoTranslator implements Translator<PseudoTranslatorConfig> {\n  constructor(\n    readonly config: PseudoTranslatorConfig,\n    private readonly logger: Logger,\n  ) {}\n\n  translate(locale: LocaleCode, entries: Record<string, TranslatableEntry>) {\n    this.logger.debug(\n      `[TRACE-PSEUDO] translate() ENTERED for ${locale} with ${Object.keys(entries).length} entries`,\n    );\n    const delay = this.config?.delayMedian ?? 0;\n    const actualDelay = this.getRandomDelay(delay);\n\n    this.logger.debug(\n      `[TRACE-PSEUDO] Config delay: ${delay}ms, actual delay: ${actualDelay}ms`,\n    );\n\n    return new Promise<Record<string, string>>((resolve) => {\n      this.logger.debug(\n        `[TRACE-PSEUDO] Promise created, scheduling setTimeout for ${actualDelay}ms`,\n      );\n\n      setTimeout(() => {\n        this.logger.debug(\n          `[TRACE-PSEUDO] setTimeout callback fired for ${locale}, processing entries`,\n        );\n\n        const result = Object.fromEntries(\n          Object.entries(entries).map(([hash, entry]) => {\n            return [hash, `${locale}/${pseudolocalize(entry.text)}`];\n          }),\n        );\n\n        this.logger.debug(\n          `[TRACE-PSEUDO] Pseudolocalization complete, resolving with ${Object.keys(result).length} translations`,\n        );\n        resolve(result);\n        this.logger.debug(`[TRACE-PSEUDO] Promise resolved for ${locale}`);\n      }, actualDelay);\n\n      this.logger.debug(\n        `[TRACE-PSEUDO] setTimeout scheduled, returning promise`,\n      );\n    });\n  }\n\n  private getRandomDelay(median: number): number {\n    if (median === 0) return 0;\n    // Generate random delay with distribution around median\n    // Use a simple approach: median ± 50%\n    const min = median * 0.5;\n    const max = median * 1.5;\n    return Math.floor(Math.random() * (max - min + 1)) + min;\n  }\n}\n\n/**\n * Character map for pseudolocalization\n */\nconst PSEUDO_MAP: Record<string, string> = {\n  a: \"á\",\n  b: \"ḅ\",\n  c: \"ç\",\n  d: \"ḍ\",\n  e: \"é\",\n  f: \"ƒ\",\n  g: \"ĝ\",\n  h: \"ĥ\",\n  i: \"í\",\n  j: \"ĵ\",\n  k: \"ḳ\",\n  l: \"ĺ\",\n  m: \"ṁ\",\n  n: \"ñ\",\n  o: \"ó\",\n  p: \"ṗ\",\n  q: \"ɋ\",\n  r: \"ŕ\",\n  s: \"ś\",\n  t: \"ţ\",\n  u: \"ú\",\n  v: \"ṿ\",\n  w: \"ŵ\",\n  x: \"ẋ\",\n  y: \"ý\",\n  z: \"ẑ\",\n  A: \"Á\",\n  B: \"Ḅ\",\n  C: \"Ç\",\n  D: \"Ḍ\",\n  E: \"É\",\n  F: \"Ƒ\",\n  G: \"Ĝ\",\n  H: \"Ĥ\",\n  I: \"Í\",\n  J: \"Ĵ\",\n  K: \"Ḳ\",\n  L: \"Ĺ\",\n  M: \"Ṁ\",\n  N: \"Ñ\",\n  O: \"Ó\",\n  P: \"Ṗ\",\n  Q: \"Ɋ\",\n  R: \"Ŕ\",\n  S: \"Ś\",\n  T: \"Ţ\",\n  U: \"Ú\",\n  V: \"Ṿ\",\n  W: \"Ŵ\",\n  X: \"Ẋ\",\n  Y: \"Ý\",\n  Z: \"Ẑ\",\n};\n\n/**\n * Pseudolocalize a string\n * Adds brackets, expands length by ~30%, and uses accented characters\n * Preserves variable placeholders {name} and component tags <a0>, </a0>\n */\nexport function pseudolocalize(text: string): string {\n  // Don't pseudolocalize if it's just whitespace or a variable placeholder\n  if (!text.trim() || text.match(/^{.*}$/)) {\n    return text;\n  }\n\n  // Regular expression to match patterns we should NOT translate:\n  // - Variable placeholders: {varName}\n  // - Component tags: <tagName> or </tagName>\n  const preserveRegex = /(\\{\\w+}|<\\/?\\w+\\/?>)/g;\n\n  // Split text into parts that should be preserved and parts that should be translated\n  const parts: Array<{ text: string; preserve: boolean }> = [];\n  let lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = preserveRegex.exec(text)) !== null) {\n    // Add text before the match (to be translated)\n    if (match.index > lastIndex) {\n      parts.push({\n        text: text.substring(lastIndex, match.index),\n        preserve: false,\n      });\n    }\n\n    // Add the matched pattern (to be preserved)\n    parts.push({\n      text: match[0],\n      preserve: true,\n    });\n\n    lastIndex = preserveRegex.lastIndex;\n  }\n\n  // Add remaining text (to be translated)\n  if (lastIndex < text.length) {\n    parts.push({\n      text: text.substring(lastIndex),\n      preserve: false,\n    });\n  }\n\n  // Convert characters in translatable parts only\n  let result = \"\";\n  for (const part of parts) {\n    if (part.preserve) {\n      // Keep placeholders and tags as-is\n      result += part.text;\n    } else {\n      // Pseudolocalize the text\n      for (const char of part.text) {\n        result += PSEUDO_MAP[char] || char;\n      }\n    }\n  }\n\n  // Add padding to simulate longer translations (~30% longer)\n  const padding = \" \".repeat(Math.ceil(text.length * 0.3));\n\n  // Wrap in brackets to identify translated strings\n  return `${result}${padding}`;\n}\n"],"mappings":";;;;;AAgBA,IAAa,mBAAb,MAA4E;CAC1E,YACE,AAASA,QACT,AAAiBC,QACjB;EAFS;EACQ;;CAGnB,UAAU,QAAoB,SAA4C;AACxE,OAAK,OAAO,MACV,0CAA0C,OAAO,QAAQ,OAAO,KAAK,QAAQ,CAAC,OAAO,UACtF;EACD,MAAM,QAAQ,KAAK,QAAQ,eAAe;EAC1C,MAAM,cAAc,KAAK,eAAe,MAAM;AAE9C,OAAK,OAAO,MACV,gCAAgC,MAAM,oBAAoB,YAAY,IACvE;AAED,SAAO,IAAI,SAAiC,YAAY;AACtD,QAAK,OAAO,MACV,6DAA6D,YAAY,IAC1E;AAED,oBAAiB;AACf,SAAK,OAAO,MACV,gDAAgD,OAAO,sBACxD;IAED,MAAM,SAAS,OAAO,YACpB,OAAO,QAAQ,QAAQ,CAAC,KAAK,CAAC,MAAM,WAAW;AAC7C,YAAO,CAAC,MAAM,GAAG,OAAO,GAAG,eAAe,MAAM,KAAK,GAAG;MACxD,CACH;AAED,SAAK,OAAO,MACV,8DAA8D,OAAO,KAAK,OAAO,CAAC,OAAO,eAC1F;AACD,YAAQ,OAAO;AACf,SAAK,OAAO,MAAM,uCAAuC,SAAS;MACjE,YAAY;AAEf,QAAK,OAAO,MACV,yDACD;IACD;;CAGJ,AAAQ,eAAe,QAAwB;AAC7C,MAAI,WAAW,EAAG,QAAO;EAGzB,MAAM,MAAM,SAAS;EACrB,MAAM,MAAM,SAAS;AACrB,SAAO,KAAK,MAAM,KAAK,QAAQ,IAAI,MAAM,MAAM,GAAG,GAAG;;;;;;AAOzD,MAAMC,aAAqC;CACzC,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACJ;;;;;;AAOD,SAAgB,eAAe,MAAsB;AAEnD,KAAI,CAAC,KAAK,MAAM,IAAI,KAAK,MAAM,SAAS,CACtC,QAAO;CAMT,MAAM,gBAAgB;CAGtB,MAAMC,QAAoD,EAAE;CAC5D,IAAI,YAAY;CAChB,IAAIC;AAEJ,SAAQ,QAAQ,cAAc,KAAK,KAAK,MAAM,MAAM;AAElD,MAAI,MAAM,QAAQ,UAChB,OAAM,KAAK;GACT,MAAM,KAAK,UAAU,WAAW,MAAM,MAAM;GAC5C,UAAU;GACX,CAAC;AAIJ,QAAM,KAAK;GACT,MAAM,MAAM;GACZ,UAAU;GACX,CAAC;AAEF,cAAY,cAAc;;AAI5B,KAAI,YAAY,KAAK,OACnB,OAAM,KAAK;EACT,MAAM,KAAK,UAAU,UAAU;EAC/B,UAAU;EACX,CAAC;CAIJ,IAAI,SAAS;AACb,MAAK,MAAM,QAAQ,MACjB,KAAI,KAAK,SAEP,WAAU,KAAK;KAGf,MAAK,MAAM,QAAQ,KAAK,KACtB,WAAU,WAAW,SAAS;CAMpC,MAAM,UAAU,IAAI,OAAO,KAAK,KAAK,KAAK,SAAS,GAAI,CAAC;AAGxD,QAAO,GAAG,SAAS"}

package/build/translators/translation-service.cjs

@@ -0,0 +1,182 @@
+const require_index = require('./pseudotranslator/index.cjs');
+const require_service = require('./pluralization/service.cjs');
+
+//#region src/translators/translation-service.ts
+var TranslationService = class {
+	useCache = true;
+	pluralizationService;
+	constructor(translator, cache, config, logger) {
+		this.translator = translator;
+		this.cache = cache;
+		this.config = config;
+		this.logger = logger;
+		const isPseudo = this.translator instanceof require_index.PseudoTranslator;
+		this.useCache = !isPseudo;
+		if (this.config.pluralization?.enabled !== false && !isPseudo) {
+			this.logger.info("Initializing pluralization service...");
+			this.pluralizationService = new require_service.PluralizationService({
+				...this.config.pluralization,
+				sourceLocale: this.config.sourceLocale
+			}, this.logger);
+		}
+	}
+	/**
+	* Translate entries to target locale
+	*
+	* @param locale Target locale (including source locale)
+	* @param metadata Metadata schema with all entries
+	* @param requestedHashes Optional: only translate specific hashes
+	* @returns Translation result with translations and errors
+	*/
+	async translate(locale, metadata, requestedHashes) {
+		const startTime = performance.now();
+		const workingHashes = requestedHashes || Object.keys(metadata.entries);
+		this.logger.info(`Translation requested for ${workingHashes.length} hashes in locale: ${locale}`);
+		this.logger.debug(`[TRACE] Checking cache for locale: ${locale}`);
+		const cacheStartTime = performance.now();
+		const cachedTranslations = this.useCache ? await this.cache.get(locale) : {};
+		const cacheEndTime = performance.now();
+		this.logger.debug(`[TRACE] Cache check completed in ${(cacheEndTime - cacheStartTime).toFixed(2)}ms, found ${Object.keys(cachedTranslations).length} entries`);
+		const uncachedHashes = workingHashes.filter((hash) => !cachedTranslations[hash]);
+		this.logger.debug(`[TRACE] ${uncachedHashes.length} hashes need processing, ${workingHashes.length - uncachedHashes.length} are cached`);
+		const cachedCount = workingHashes.length - uncachedHashes.length;
+		if (uncachedHashes.length === 0) {
+			const endTime$1 = performance.now();
+			this.logger.info(`Cache hit for all ${workingHashes.length} hashes in ${locale} in ${(endTime$1 - startTime).toFixed(2)}ms`);
+			return {
+				translations: this.pickTranslations(cachedTranslations, workingHashes),
+				errors: [],
+				stats: {
+					total: workingHashes.length,
+					cached: cachedCount,
+					translated: 0,
+					failed: 0
+				}
+			};
+		}
+		this.logger.info(`Generating translations for ${uncachedHashes.length} uncached hashes in ${locale}...`);
+		const filteredMetadata = {
+			...metadata,
+			entries: Object.fromEntries(uncachedHashes.map((hash) => [hash, metadata.entries[hash]]).filter(([_, entry]) => entry !== void 0))
+		};
+		if (this.pluralizationService) {
+			this.logger.info(`Processing pluralization for ${Object.keys(filteredMetadata.entries).length} entries...`);
+			const pluralStats = await this.pluralizationService.process(filteredMetadata);
+			this.logger.info(`Pluralization stats: ${pluralStats.pluralized} pluralized, ${pluralStats.rejected} rejected, ${pluralStats.failed} failed`);
+		}
+		const overriddenTranslations = {};
+		const hashesNeedingTranslation = [];
+		this.logger.debug(`[TRACE] Checking for overrides in ${uncachedHashes.length} entries`);
+		for (const hash of uncachedHashes) {
+			const entry = filteredMetadata.entries[hash];
+			if (!entry) continue;
+			if (entry.overrides && entry.overrides[locale]) {
+				overriddenTranslations[hash] = entry.overrides[locale];
+				this.logger.debug(`[TRACE] Using override for ${hash} in locale ${locale}: "${entry.overrides[locale]}"`);
+			} else hashesNeedingTranslation.push(hash);
+		}
+		const overrideCount = Object.keys(overriddenTranslations).length;
+		if (overrideCount > 0) this.logger.info(`Found ${overrideCount} override(s) for locale ${locale}, skipping AI translation for these entries`);
+		this.logger.debug(`[TRACE] Preparing ${hashesNeedingTranslation.length} entries for translation (after overrides)`);
+		const entriesToTranslate = this.prepareEntries(filteredMetadata, hashesNeedingTranslation);
+		this.logger.debug(`[TRACE] Prepared ${Object.keys(entriesToTranslate).length} entries`);
+		let newTranslations = { ...overriddenTranslations };
+		const errors = [];
+		if (locale === this.config.sourceLocale) {
+			this.logger.debug(`[TRACE] Source locale detected, returning sourceText for ${hashesNeedingTranslation.length} entries`);
+			for (const [hash, entry] of Object.entries(entriesToTranslate)) newTranslations[hash] = entry.text;
+		} else if (Object.keys(entriesToTranslate).length > 0) {
+			try {
+				this.logger.debug(`[TRACE] Calling translator.translate() for ${locale} with ${Object.keys(entriesToTranslate).length} entries`);
+				this.logger.debug(`[TRACE] About to await translator.translate()...`);
+				const translateStartTime = performance.now();
+				this.logger.debug(`[TRACE] Executing translator.translate() NOW`);
+				const translatedTexts = await this.translator.translate(locale, entriesToTranslate);
+				this.logger.debug(`[TRACE] translator.translate() returned`);
+				newTranslations = {
+					...overriddenTranslations,
+					...translatedTexts
+				};
+				const translateEndTime = performance.now();
+				this.logger.debug(`[TRACE] translator.translate() completed in ${(translateEndTime - translateStartTime).toFixed(2)}ms`);
+				this.logger.debug(`[TRACE] Received ${Object.keys(translatedTexts).length} translations (+ ${overrideCount} overrides)`);
+			} catch (error) {
+				this.logger.error(`Translation failed completely:`, error);
+				return {
+					translations: this.pickTranslations(cachedTranslations, workingHashes),
+					errors: [{
+						hash: "all",
+						sourceText: "all",
+						error: error instanceof Error ? error.message : "Unknown translation error"
+					}],
+					stats: {
+						total: workingHashes.length,
+						cached: cachedCount,
+						translated: 0,
+						failed: uncachedHashes.length
+					}
+				};
+			}
+			for (const hash of uncachedHashes) if (!newTranslations[hash]) {
+				const entry = filteredMetadata.entries[hash];
+				errors.push({
+					hash,
+					sourceText: entry?.sourceText || "",
+					error: "Translation not returned by translator"
+				});
+			}
+		}
+		if (this.useCache && Object.keys(newTranslations).length > 0) try {
+			this.logger.debug(`[TRACE] Updating cache with ${Object.keys(newTranslations).length} translations for ${locale}`);
+			const updateStartTime = performance.now();
+			await this.cache.update(locale, newTranslations);
+			const updateEndTime = performance.now();
+			this.logger.debug(`[TRACE] Cache update completed in ${(updateEndTime - updateStartTime).toFixed(2)}ms`);
+			this.logger.info(`Updated cache with ${Object.keys(newTranslations).length} translations for ${locale}`);
+		} catch (error) {
+			this.logger.error(`Failed to update cache:`, error);
+		}
+		const allTranslations = {
+			...cachedTranslations,
+			...newTranslations
+		};
+		const result = this.pickTranslations(allTranslations, workingHashes);
+		const endTime = performance.now();
+		this.logger.info(`Translation completed for ${locale}: ${Object.keys(newTranslations).length} new, ${cachedCount} cached, ${errors.length} errors in ${(endTime - startTime).toFixed(2)}ms`);
+		return {
+			translations: result,
+			errors,
+			stats: {
+				total: workingHashes.length,
+				cached: cachedCount,
+				translated: Object.keys(newTranslations).length,
+				failed: errors.length
+			}
+		};
+	}
+	/**
+	* Prepare metadata entries for translation
+	*/
+	prepareEntries(metadata, hashes) {
+		const entries = {};
+		for (const hash of hashes) {
+			const entry = metadata.entries[hash];
+			if (entry) entries[hash] = {
+				text: entry.sourceText,
+				context: entry.context || {}
+			};
+		}
+		return entries;
+	}
+	/**
+	* Pick only requested translations from the full set
+	*/
+	pickTranslations(allTranslations, requestedHashes) {
+		const result = {};
+		for (const hash of requestedHashes) if (allTranslations[hash]) result[hash] = allTranslations[hash];
+		return result;
+	}
+};
+
+//#endregion
+exports.TranslationService = TranslationService;

package/build/translators/translation-service.mjs

@@ -0,0 +1,183 @@
+import { PseudoTranslator } from "./pseudotranslator/index.mjs";
+import { PluralizationService } from "./pluralization/service.mjs";
+
+//#region src/translators/translation-service.ts
+var TranslationService = class {
+	useCache = true;
+	pluralizationService;
+	constructor(translator, cache, config, logger) {
+		this.translator = translator;
+		this.cache = cache;
+		this.config = config;
+		this.logger = logger;
+		const isPseudo = this.translator instanceof PseudoTranslator;
+		this.useCache = !isPseudo;
+		if (this.config.pluralization?.enabled !== false && !isPseudo) {
+			this.logger.info("Initializing pluralization service...");
+			this.pluralizationService = new PluralizationService({
+				...this.config.pluralization,
+				sourceLocale: this.config.sourceLocale
+			}, this.logger);
+		}
+	}
+	/**
+	* Translate entries to target locale
+	*
+	* @param locale Target locale (including source locale)
+	* @param metadata Metadata schema with all entries
+	* @param requestedHashes Optional: only translate specific hashes
+	* @returns Translation result with translations and errors
+	*/
+	async translate(locale, metadata, requestedHashes) {
+		const startTime = performance.now();
+		const workingHashes = requestedHashes || Object.keys(metadata.entries);
+		this.logger.info(`Translation requested for ${workingHashes.length} hashes in locale: ${locale}`);
+		this.logger.debug(`[TRACE] Checking cache for locale: ${locale}`);
+		const cacheStartTime = performance.now();
+		const cachedTranslations = this.useCache ? await this.cache.get(locale) : {};
+		const cacheEndTime = performance.now();
+		this.logger.debug(`[TRACE] Cache check completed in ${(cacheEndTime - cacheStartTime).toFixed(2)}ms, found ${Object.keys(cachedTranslations).length} entries`);
+		const uncachedHashes = workingHashes.filter((hash) => !cachedTranslations[hash]);
+		this.logger.debug(`[TRACE] ${uncachedHashes.length} hashes need processing, ${workingHashes.length - uncachedHashes.length} are cached`);
+		const cachedCount = workingHashes.length - uncachedHashes.length;
+		if (uncachedHashes.length === 0) {
+			const endTime$1 = performance.now();
+			this.logger.info(`Cache hit for all ${workingHashes.length} hashes in ${locale} in ${(endTime$1 - startTime).toFixed(2)}ms`);
+			return {
+				translations: this.pickTranslations(cachedTranslations, workingHashes),
+				errors: [],
+				stats: {
+					total: workingHashes.length,
+					cached: cachedCount,
+					translated: 0,
+					failed: 0
+				}
+			};
+		}
+		this.logger.info(`Generating translations for ${uncachedHashes.length} uncached hashes in ${locale}...`);
+		const filteredMetadata = {
+			...metadata,
+			entries: Object.fromEntries(uncachedHashes.map((hash) => [hash, metadata.entries[hash]]).filter(([_, entry]) => entry !== void 0))
+		};
+		if (this.pluralizationService) {
+			this.logger.info(`Processing pluralization for ${Object.keys(filteredMetadata.entries).length} entries...`);
+			const pluralStats = await this.pluralizationService.process(filteredMetadata);
+			this.logger.info(`Pluralization stats: ${pluralStats.pluralized} pluralized, ${pluralStats.rejected} rejected, ${pluralStats.failed} failed`);
+		}
+		const overriddenTranslations = {};
+		const hashesNeedingTranslation = [];
+		this.logger.debug(`[TRACE] Checking for overrides in ${uncachedHashes.length} entries`);
+		for (const hash of uncachedHashes) {
+			const entry = filteredMetadata.entries[hash];
+			if (!entry) continue;
+			if (entry.overrides && entry.overrides[locale]) {
+				overriddenTranslations[hash] = entry.overrides[locale];
+				this.logger.debug(`[TRACE] Using override for ${hash} in locale ${locale}: "${entry.overrides[locale]}"`);
+			} else hashesNeedingTranslation.push(hash);
+		}
+		const overrideCount = Object.keys(overriddenTranslations).length;
+		if (overrideCount > 0) this.logger.info(`Found ${overrideCount} override(s) for locale ${locale}, skipping AI translation for these entries`);
+		this.logger.debug(`[TRACE] Preparing ${hashesNeedingTranslation.length} entries for translation (after overrides)`);
+		const entriesToTranslate = this.prepareEntries(filteredMetadata, hashesNeedingTranslation);
+		this.logger.debug(`[TRACE] Prepared ${Object.keys(entriesToTranslate).length} entries`);
+		let newTranslations = { ...overriddenTranslations };
+		const errors = [];
+		if (locale === this.config.sourceLocale) {
+			this.logger.debug(`[TRACE] Source locale detected, returning sourceText for ${hashesNeedingTranslation.length} entries`);
+			for (const [hash, entry] of Object.entries(entriesToTranslate)) newTranslations[hash] = entry.text;
+		} else if (Object.keys(entriesToTranslate).length > 0) {
+			try {
+				this.logger.debug(`[TRACE] Calling translator.translate() for ${locale} with ${Object.keys(entriesToTranslate).length} entries`);
+				this.logger.debug(`[TRACE] About to await translator.translate()...`);
+				const translateStartTime = performance.now();
+				this.logger.debug(`[TRACE] Executing translator.translate() NOW`);
+				const translatedTexts = await this.translator.translate(locale, entriesToTranslate);
+				this.logger.debug(`[TRACE] translator.translate() returned`);
+				newTranslations = {
+					...overriddenTranslations,
+					...translatedTexts
+				};
+				const translateEndTime = performance.now();
+				this.logger.debug(`[TRACE] translator.translate() completed in ${(translateEndTime - translateStartTime).toFixed(2)}ms`);
+				this.logger.debug(`[TRACE] Received ${Object.keys(translatedTexts).length} translations (+ ${overrideCount} overrides)`);
+			} catch (error) {
+				this.logger.error(`Translation failed completely:`, error);
+				return {
+					translations: this.pickTranslations(cachedTranslations, workingHashes),
+					errors: [{
+						hash: "all",
+						sourceText: "all",
+						error: error instanceof Error ? error.message : "Unknown translation error"
+					}],
+					stats: {
+						total: workingHashes.length,
+						cached: cachedCount,
+						translated: 0,
+						failed: uncachedHashes.length
+					}
+				};
+			}
+			for (const hash of uncachedHashes) if (!newTranslations[hash]) {
+				const entry = filteredMetadata.entries[hash];
+				errors.push({
+					hash,
+					sourceText: entry?.sourceText || "",
+					error: "Translation not returned by translator"
+				});
+			}
+		}
+		if (this.useCache && Object.keys(newTranslations).length > 0) try {
+			this.logger.debug(`[TRACE] Updating cache with ${Object.keys(newTranslations).length} translations for ${locale}`);
+			const updateStartTime = performance.now();
+			await this.cache.update(locale, newTranslations);
+			const updateEndTime = performance.now();
+			this.logger.debug(`[TRACE] Cache update completed in ${(updateEndTime - updateStartTime).toFixed(2)}ms`);
+			this.logger.info(`Updated cache with ${Object.keys(newTranslations).length} translations for ${locale}`);
+		} catch (error) {
+			this.logger.error(`Failed to update cache:`, error);
+		}
+		const allTranslations = {
+			...cachedTranslations,
+			...newTranslations
+		};
+		const result = this.pickTranslations(allTranslations, workingHashes);
+		const endTime = performance.now();
+		this.logger.info(`Translation completed for ${locale}: ${Object.keys(newTranslations).length} new, ${cachedCount} cached, ${errors.length} errors in ${(endTime - startTime).toFixed(2)}ms`);
+		return {
+			translations: result,
+			errors,
+			stats: {
+				total: workingHashes.length,
+				cached: cachedCount,
+				translated: Object.keys(newTranslations).length,
+				failed: errors.length
+			}
+		};
+	}
+	/**
+	* Prepare metadata entries for translation
+	*/
+	prepareEntries(metadata, hashes) {
+		const entries = {};
+		for (const hash of hashes) {
+			const entry = metadata.entries[hash];
+			if (entry) entries[hash] = {
+				text: entry.sourceText,
+				context: entry.context || {}
+			};
+		}
+		return entries;
+	}
+	/**
+	* Pick only requested translations from the full set
+	*/
+	pickTranslations(allTranslations, requestedHashes) {
+		const result = {};
+		for (const hash of requestedHashes) if (allTranslations[hash]) result[hash] = allTranslations[hash];
+		return result;
+	}
+};
+
+//#endregion
+export { TranslationService };
+//# sourceMappingURL=translation-service.mjs.map