npm - @verbaly/compiler - Versions diffs - 0.21.0 → 0.22.0 - Mend

@verbaly/compiler 0.21.0 → 0.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -24,7 +24,7 @@ npx verbaly extract        # sync catalogs + types
 npx verbaly check          # exit 1 if anything is missing (CI)
 npx verbaly extract --prune  # drop orphaned keys
 npx verbaly translate      # fill missing translations via Claude (or your provider)
-npx verbaly export         # write translator-ready XLIFF 2.0 / CSV files per locale
+npx verbaly export         # translator files (XLIFF 2.0, CSV) or mobile resources (Android, iOS)
 npx verbaly import <files> # fill catalogs back from translated XLIFF/CSV files
 npx verbaly pseudo         # generate a pseudo-locale catalog for i18n QA (en-XA)
 npx verbaly render         # pre-fill data-verbaly HTML per locale (SSG — kills the FOUC)
@@ -54,6 +54,17 @@ npx verbaly import verbaly-export/es.xlf   # fill the catalog back
 `export` writes one file per target locale with the source text alongside the current translation (`--missing` exports only the untranslated entries). `import` reads XLIFF 2.0/1.2 or CSV back and **validates every entry like `translate` does** — a translation that drops a `{param}`, a variant block or an `<em>` tag is rejected and reported, so a translator's typo can't break your UI. Existing translations are kept unless `--overwrite`; `--dry-run` previews everything.
+## 📱 Mobile resources
+The same catalogs can ship to a companion mobile app as drop-in native resources:
+```bash
+npx verbaly export --format android-xml   # verbaly-export/values-<locale>/strings.xml (drop into res/)
+npx verbaly export --format ios-strings   # verbaly-export/<locale>.lproj/Localizable.strings (drop into Xcode)
+```
+Your source locale becomes the platform default (`values/strings.xml`, `en.lproj`), and untranslated keys are skipped so the app falls back to it natively instead of showing empty text. Keys are sanitized to valid Android resource names (`hero.title` → `hero_title`; a collision fails loudly), values keep Verbaly's `{name}` syntax. Export-only by design: translations flow from your catalogs to the app.
 ## 📄 Static rendering (SSG)
 `verbaly render` walks your built site (`dist/` by default, `--site <path>` to change) and pre-fills every `data-verbaly` element **per locale** using the real runtime — plurals, `Intl` formatting, `data-verbaly-args`, attribute translation and `data-verbaly-rich` (same whitelist, XSS-safe). The source locale is filled in place; every other locale is mirrored to `dist/<locale>/…` with `<html lang>` set. Static HTML ships already translated — **no flash of untranslated content** — and the runtime attributes stay put, so client-side locale switching keeps working.

package/dist/cli.js CHANGED Viewed

@@ -13,11 +13,17 @@ function catalogPath(cfg, locale) {
 	return join(cfg.dir, `${locale}.json`);
 }
 function readCatalog(cfg, locale) {
+	let content;
 	try {
-		return JSON.parse(readFileSync(catalogPath(cfg, locale), "utf8"));
+		content = readFileSync(catalogPath(cfg, locale), "utf8");
 	} catch {
 		return {};
 	}
+	try {
+		return JSON.parse(content.replace(/^\uFEFF/, ""));
+	} catch (error) {
+		throw new Error(`[verbaly] ${catalogPath(cfg, locale)} is not valid JSON, fix or delete the file`, { cause: error });
+	}
 }
 function loadCatalogs(cfg) {
 	const catalogs = {};
@@ -1006,6 +1012,45 @@ function readDeps(root) {
 	}
 }
 //#endregion
+//#region src/mobile.ts
+function androidValuesDir(locale, sourceLocale) {
+	if (locale === sourceLocale) return "values";
+	const parts = locale.split("-");
+	if (parts.length === 1) return `values-${locale}`;
+	if (parts.length === 2 && /^[a-zA-Z]{2}$/.test(parts[1])) return `values-${parts[0]}-r${parts[1].toUpperCase()}`;
+	return `values-b+${parts.join("+")}`;
+}
+function toAndroidXml(entries) {
+	const names = /* @__PURE__ */ new Map();
+	return [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+		"<resources>",
+		...entries.map(({ key, text }) => {
+			const name = androidName(key);
+			const clash = names.get(name);
+			if (clash !== void 0) throw new Error(`[verbaly] android-xml: keys "${clash}" and "${key}" both become resource name "${name}", rename one of them.`);
+			names.set(name, key);
+			return `  <string name="${name}">${androidText(text)}</string>`;
+		}),
+		"</resources>",
+		""
+	].join("\n");
+}
+function toIosStrings(entries) {
+	return [...entries.map(({ key, text }) => `"${iosText(key)}" = "${iosText(text)}";`), ""].join("\n");
+}
+function androidName(key) {
+	const name = key.replace(/[^A-Za-z0-9_]/g, "_");
+	return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+function androidText(text) {
+	const escaped = text.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	return /^[@?]/.test(escaped) ? `\\${escaped}` : escaped;
+}
+function iosText(text) {
+	return text.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+//#endregion
 //#region src/translate.ts
 async function translateCatalogs(cfg, catalogs, provider, options = {}) {
 	const batchSize = options.batchSize ?? 20;
@@ -1064,11 +1109,15 @@ function sameMembers(a, b) {
 }
 //#endregion
 //#region src/exchange.ts
+function isMobileFormat(format) {
+	return format === "android-xml" || format === "ios-strings";
+}
 function exportCatalogs(cfg, catalogs, options = {}) {
 	const format = options.format ?? "xliff";
 	const dir = resolve(cfg.root, options.out ?? "verbaly-export");
 	const source = catalogs[cfg.sourceLocale] ?? {};
 	const targets = targetLocales(cfg, options.locales);
+	if (isMobileFormat(format)) return exportMobile(cfg, catalogs, format, dir, source, targets);
 	const files = [];
 	mkdirSync(dir, { recursive: true });
 	for (const locale of targets) {
@@ -1095,6 +1144,31 @@ function exportCatalogs(cfg, catalogs, options = {}) {
 		files
 	};
 }
+function exportMobile(cfg, catalogs, format, dir, source, targets) {
+	const keys = Object.keys(source).filter((key) => source[key]).sort();
+	const files = [];
+	for (const locale of [cfg.sourceLocale, ...targets]) {
+		const catalog = locale === cfg.sourceLocale ? source : catalogs[locale] ?? {};
+		const entries = keys.map((key) => ({
+			key,
+			text: catalog[key] ?? ""
+		})).filter((entry) => entry.text);
+		const path = join(dir, format === "android-xml" ? join(androidValuesDir(locale, cfg.sourceLocale), "strings.xml") : join(`${locale}.lproj`, "Localizable.strings"));
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, format === "android-xml" ? toAndroidXml(entries) : toIosStrings(entries));
+		files.push({
+			locale,
+			path,
+			total: entries.length,
+			untranslated: keys.length - entries.length
+		});
+	}
+	return {
+		format,
+		dir,
+		files
+	};
+}
 function importCatalogs(cfg, catalogs, files, options = {}) {
 	const source = catalogs[cfg.sourceLocale] ?? {};
 	const result = {
@@ -1527,7 +1601,7 @@ Usage:
   verbaly extract    scan sources, update catalogs and types
   verbaly check      verify translations are complete (CI)
   verbaly translate  fill missing translations via a provider (default: claude)
-  verbaly export     write translator-ready files per locale (XLIFF 2.0 or CSV)
+  verbaly export     write translator files (XLIFF 2.0, CSV) or mobile resources (Android, iOS)
   verbaly import <files…>  fill catalogs back from translated XLIFF/CSV files
   verbaly pseudo     generate a pseudo-locale catalog for i18n QA (default: en-XA)
   verbaly render     pre-fill data-verbaly HTML per locale (SSG, kills the FOUC)
@@ -1540,7 +1614,7 @@ Options:
   --prune            drop keys no longer referenced (extract)
   --model <id>       model override for the claude provider (translate)
   --dry-run          list what would happen, write nothing (translate, import, extract)
-  --format <f>       export format: xliff (default) or csv (export)
+  --format <f>       export format: xliff (default), csv, android-xml or ios-strings (export)
   --out <path>       export directory (export, default: verbaly-export)
   --missing          export only untranslated entries (export)
   --overwrite        replace existing translations on import (import)
@@ -1684,8 +1758,18 @@ async function runCli(args = process.argv.slice(2)) {
 	}
 	if (command === "export") {
 		const format = values.format ?? "xliff";
-		if (format !== "xliff" && format !== "csv") {
-			console.error(`[verbaly] unknown format "${values.format}", use xliff or csv`);
+		if (![
+			"xliff",
+			"csv",
+			"android-xml",
+			"ios-strings"
+		].includes(format)) {
+			console.error(`[verbaly] unknown format "${values.format}", use xliff, csv, android-xml or ios-strings`);
+			process.exitCode = 1;
+			return;
+		}
+		if (values.missing && isMobileFormat(format)) {
+			console.error(`[verbaly] --missing is for translator formats (xliff, csv): ${format} already skips untranslated keys so the app falls back to the source locale`);
 			process.exitCode = 1;
 			return;
 		}
@@ -1699,8 +1783,9 @@ async function runCli(args = process.argv.slice(2)) {
 			console.log("[verbaly] no target locales to export (add locales to your config)");
 			return;
 		}
+		const note = isMobileFormat(result.format) ? "untranslated skipped" : "untranslated";
 		console.log(`[verbaly] exported ${result.files.length} locales (${result.format}) → ${result.dir}`);
-		for (const file of result.files) console.log(`  ${file.locale}: ${file.total} messages (${file.untranslated} untranslated) → ${file.path}`);
+		for (const file of result.files) console.log(`  ${file.locale}: ${file.total} messages (${file.untranslated} ${note}) → ${file.path}`);
 		return;
 	}
 	if (command === "import") {