@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/compile-B5Mz6WJm.js

@@ -0,0 +1,245 @@
+import { i as toRuntimeConfig } from "./runtime-DTMmliT1.js";
+import { a as assetCatalogsModule, i as SERVER_FILES, o as serverCatalogVersion, s as serverCatalogsDir, t as compileLocales } from "./locales-DX4MOBFE.js";
+import { t as findCollisions } from "./collisions-CfpZU8e4.js";
+import { a as table, i as rootRelative, r as plural } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, f as scan, i as hasErrors, n as compareText, o as loadProject, r as computeDrift, s as occurrencesOf, u as readErrors } from "./project-Dwx7iPm6.js";
+import { dirname, join, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+//#region src/cli/commands/compile.ts
+/**
+* `vi18n compile [--out dir] [--assets dir] [--strict] [--pseudo] [--check]`
+* (INTERNALS §2.12, PLAN §5.3): compiled catalogs for code Vite does not
+* build (a wrangler Worker, e-mail rendering), loaded with
+* `registerCatalogs`. It refuses to run while `extract --check` reports
+* drift, so what ships always matches the code. A committed `--out`
+* directory can still lag behind the catalogs (a translation edited,
+* `extract` run without `compile`): `--check` compares it with what would be
+* written, for CI.
+*
+* `--assets` is the Workers layout of `ssr.catalogs: "assets"` (spike S12):
+* the catalogs go to the static-assets directory under the server message
+* set's version, and `<out>/catalogs.js` reads them through `env.ASSETS`, so
+* the Worker bundles none and only the locales requests use take memory.
+*/
+async function compile(ctx, flags) {
+	const project = await loadProject(ctx);
+	const { config, codec } = project;
+	const data = {
+		out: null,
+		assets: null,
+		files: [],
+		missing: {},
+		drift: []
+	};
+	const scanned = await scan(project);
+	ctx.out.report(scanned.diagnostics.filter((d) => d.severity === "error"));
+	const loaded = await loadCatalogs(project);
+	const unreadable = readErrors(loaded.diagnostics);
+	if (unreadable.length > 0) {
+		ctx.out.report(unreadable);
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	const collided = findCollisions(occurrencesOf(scanned), loaded.set, codec, { referenced: new Set(config.extraction.keep) });
+	if (hasErrors(collided)) {
+		ctx.out.report(collided);
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	const refusals = (await computeDrift(project, scanned.messages, loaded.set)).diagnostics.filter((d) => d.code === "catalog-drift" || d.code === "id-scheme-mismatch");
+	if (refusals.length > 0) {
+		ctx.out.report(refusals);
+		ctx.out.note("vi18n compile: the catalogs do not match the code; run vi18n extract first");
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	const pseudo = flags.pseudo ? config.pseudoLocales : [];
+	const locales = [...config.locales, ...pseudo];
+	const compiled = compileLocales({
+		config,
+		codec,
+		messages: scanned.messages,
+		keep: config.extraction.keep,
+		catalogs: loaded.set,
+		locales
+	});
+	let missingTotal = 0;
+	for (const locale of config.locales) {
+		const result = compiled.get(locale);
+		ctx.out.report(result.diagnostics);
+		if (locale === config.sourceLocale) continue;
+		let count = 0;
+		for (const status of result.status.values()) if (status.state === "missing") count++;
+		data.missing[locale] = count;
+		missingTotal += count;
+	}
+	if (flags.out !== null) {
+		const out = resolve(ctx.global.cwd, flags.out);
+		data.out = rootRelative(config.root, out);
+		if (!flags.check) await mkdir(out, { recursive: true });
+		const files = [];
+		const runtime = toRuntimeConfig(config, {
+			base: "/",
+			pseudo: flags.pseudo
+		});
+		const assets = flags.assets === null ? null : resolve(ctx.global.cwd, flags.assets);
+		let version = null;
+		if (assets === null) for (const locale of locales) {
+			const messages = compiled.get(locale).messages;
+			files.push([join(out, `${locale}.json`), bundleJson(messages)]);
+		}
+		else {
+			data.assets = rootRelative(config.root, assets);
+			version = serverCatalogVersion({
+				idScheme: codec.idScheme,
+				v: null,
+				ids: compiled.get(config.sourceLocale).messages.keys(),
+				sourceHashOf: (id) => scanned.messages.get(id)?.sourceHash ?? ""
+			});
+			for (const locale of locales) {
+				const messages = compiled.get(locale).messages;
+				const path = join(assets, serverCatalogsDir(version), locale, SERVER_FILES.catalog);
+				files.push([path, bundleJson(messages)]);
+			}
+			runtime.ssr.maxLoadedLocales = config.ssr.maxLoadedLocales;
+		}
+		files.push([join(out, "sources.json"), sourcesJson(scanned.messages)]);
+		files.push([join(out, "config.json"), JSON.stringify(runtime) + "\n"]);
+		if (version !== null) {
+			files.push([join(out, "catalogs.js"), assetCatalogsModule({
+				locales,
+				dir: serverCatalogsDir(version),
+				deploy: `deploy ${flags.assets} (written by vi18n compile --assets) with this Worker`,
+				modules: "compile without --assets to bundle the catalogs as modules"
+			})]);
+			files.push([join(out, "catalogs.d.ts"), CATALOGS_DTS]);
+		}
+		const fix = `vi18n compile --out ${flags.out}${assets === null ? "" : ` --assets ${flags.assets}`}${flags.pseudo ? " --pseudo" : ""}`;
+		for (const [path, content] of files) {
+			const file = rootRelative(config.root, path);
+			data.files.push(file);
+			if (!flags.check) {
+				await mkdir(dirname(path), { recursive: true });
+				await writeIfChanged(path, content);
+				continue;
+			}
+			const current = await readIfExists(path);
+			if (current !== null && current.replace(/\r\n/g, "\n") === content) continue;
+			data.drift.push(file);
+			ctx.out.report([{
+				code: "catalog-drift",
+				severity: "error",
+				message: current === null ? `${file} does not exist yet; run ${fix}` : `${file} is out of date; run ${fix}`,
+				file
+			}]);
+		}
+		if (version !== null && assets !== null && !flags.check) {
+			const locales = [...config.locales, ...config.pseudoLocales];
+			const removed = await removeOtherVersions(assets, version, locales);
+			if (removed > 0) ctx.out.note(`removed ${plural(removed, "earlier catalog version")} from ${ctx.out.display(rootRelative(config.root, join(assets, "vi18n")))}`);
+		}
+	}
+	const where = data.out === null ? "" : ctx.out.display(data.out) + (data.assets === null ? "" : ` and ${ctx.out.display(data.assets)}`);
+	const rows = Object.entries(data.missing).map(([locale, count]) => [locale, count]);
+	if (rows.length > 0) ctx.out.result(table(["locale", "missing"], rows));
+	if (data.out !== null && flags.check) ctx.out.result(data.drift.length > 0 ? `vi18n compile --check: ${data.drift.length} out-of-date file(s) in ${where}` : `vi18n compile --check: ${where} ${data.assets === null ? "is" : "are"} up to date`);
+	else if (data.out !== null) ctx.out.result(`wrote ${plural(data.files.length, "file")} to ${where}`);
+	const failed = hasErrors(ctx.out.diagnostics) || flags.strict && missingTotal > 0;
+	if (flags.strict && missingTotal > 0) ctx.out.note(`vi18n compile --strict: ${plural(missingTotal, "missing translation")}`);
+	return {
+		exitCode: failed ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/** Types of the generated `catalogs.js` for TypeScript apps (no `allowJs` needed). */
+const CATALOGS_DTS = `// Generated by vi18n compile --assets: catalog loaders for registerCatalogs().
+declare const catalogs: { [locale: string]: () => Promise<{ [id: string]: unknown }> };
+export default catalogs;
+`;
+/** A version directory name (`hash8`): base64url, 8 characters. */
+const VERSION_NAME = /^[\w-]{8}$/;
+/**
+* Removes the versions of `<assets>/vi18n/` other than `version` that this
+* command wrote: directories named like a version holding only
+* `<locale>/catalog.json` for configured locales. Anything else there (a
+* Vite build's stable manifests, the app's own files) is left alone.
+*/
+async function removeOtherVersions(assets, version, locales) {
+	const root = join(assets, "vi18n");
+	let removed = 0;
+	for (const entry of await readdir(root, { withFileTypes: true }).catch(() => [])) {
+		if (!entry.isDirectory() || entry.name === version || !VERSION_NAME.test(entry.name)) continue;
+		const dir = join(root, entry.name);
+		if (!await onlyCatalogs(dir, locales)) continue;
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+		removed++;
+	}
+	return removed;
+}
+async function onlyCatalogs(dir, locales) {
+	for (const entry of await readdir(dir, { withFileTypes: true })) {
+		if (!entry.isDirectory() || !locales.includes(entry.name)) return false;
+		if ((await readdir(join(dir, entry.name), { withFileTypes: true })).some((file) => !file.isFile() || file.name !== SERVER_FILES.catalog)) return false;
+	}
+	return true;
+}
+/** `BundleData` with keys in code-unit order and no whitespace: byte-stable for diffs and caches. */
+function bundleJson(messages) {
+	const ids = [...messages.keys()].sort(compareText);
+	const data = Object.create(null);
+	for (const id of ids) data[id] = messages.get(id);
+	return JSON.stringify(data) + "\n";
+}
+/**
+* Every exact source literal of a generated-id message → its id, so
+* untransformed code (`t("Hello {name}")` in a Worker) finds the compiled
+* message (PLAN §5.3). Manual ids are looked up by id and need no entry.
+*/
+function sourcesJson(messages) {
+	const pairs = [];
+	for (const message of messages.values()) {
+		if (message.manual) continue;
+		for (const source of message.sources) pairs.push([source, message.id]);
+	}
+	pairs.sort((a, b) => compareText(a[0], b[0]));
+	const data = Object.create(null);
+	for (const [source, id] of pairs) data[source] = id;
+	return JSON.stringify(data) + "\n";
+}
+async function readIfExists(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+/** Unchanged files keep their mtime (watchers, incremental deploys); others are replaced atomically. */
+async function writeIfChanged(path, content) {
+	try {
+		if (await readFile(path, "utf8") === content) return;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	const temp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await writeFile(temp, content);
+		await rename(temp, path);
+	} catch (error) {
+		await rm(temp, { force: true });
+		throw error;
+	}
+}
+//#endregion
+export { compile };