@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/exclude-Du-Zd_qI.js

@@ -0,0 +1,26 @@
+import { o as isValidManualId } from "./validate-BxpupdAf.js";
+//#region src/core/config/exclude.ts
+/**
+* `ai.exclude` entries (PLAN §4.6, §5.20; INTERNALS §2.15): a configured
+* locale, a message id, or a glob over the config-relative files that use a
+* message. One list keeps the config short, so the kind is read from the
+* entry: the loader rejects what fits none, and `vi18n translate` matches
+* with the same reading.
+*/
+/** Everything a message id may hold: base64url, plus a manual id's `.` and `:`. */
+const ID_CHARACTERS = /^[A-Za-z0-9_:.-]+$/;
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+/**
+* The kind of an entry, or null when it is none. A glob is anything with a
+* character no id or locale has, and must contain `/`, `*` or `?`: a bare
+* `legal.tsx` reads as the manual id it also is, so a file at the root is
+* written `./legal.tsx` or `**\/legal.tsx`.
+*/
+function excludeKind(entry, locales, idLength) {
+	if (!ID_CHARACTERS.test(entry)) return /[/*?]/.test(entry) ? "glob" : null;
+	if (locales.includes(entry)) return "locale";
+	if (isValidManualId(entry)) return "id";
+	return entry.length === idLength && BASE64URL.test(entry) ? "id" : null;
+}
+//#endregion
+export { excludeKind as t };

package/dist/export-DGsMbcTZ.js

@@ -0,0 +1,103 @@
+import { c as sourceIndexOf, n as EXTENSIONS, o as exchangeUnits } from "./units-CQ5Q99RC.js";
+import { r as plural } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { a as loadCatalogs, o as loadProject, t as CliExit, u as readErrors } from "./project-Dwx7iPm6.js";
+import { n as serializeExport } from "./formats-KPIg-08V.js";
+import { join, resolve } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/cli/commands/export.ts
+/**
+* `vi18n export --format po|json|flat|xliff2|arb|csv [--locale l]… [--out dir]
+* [--missing] [--ai]` (PLAN §4.4, §5.19, INTERNALS §2.6.9): each locale's
+* catalog in an exchange format, for a TMS or a translation agency. It reads
+* the catalogs as they are, so run `vi18n extract` first to send what the
+* code uses now.
+*/
+async function exportCatalogs(ctx, flags) {
+	const project = await loadProject(ctx);
+	const { config, codec, layout } = project;
+	const filtered = flags.missing || flags.ai;
+	const locales = exportLocales(config.locales, config.sourceLocale, flags.locales, filtered);
+	if (flags.out === null && locales.length !== 1) throw new CliExit(EXIT.usage, [{
+		code: "config-invalid",
+		severity: "error",
+		message: `${plural(locales.length, "locale")} to export: pass --out <dir> for one file per locale, or one --locale for stdout`
+	}]);
+	const loaded = await loadCatalogs(project);
+	const unreadable = readErrors(loaded.diagnostics);
+	if (unreadable.length > 0) throw new CliExit(EXIT.failure, unreadable);
+	const context = {
+		layout,
+		codec,
+		sourceIndex: sourceIndexOf(loaded.set.get(config.sourceLocale)?.catalog ?? null, layout, codec)
+	};
+	const data = {
+		format: flags.format,
+		files: []
+	};
+	const out = flags.out === null ? null : resolve(ctx.global.cwd, flags.out);
+	if (out !== null) await mkdir(out, { recursive: true });
+	for (const locale of locales) {
+		const isSourceLocale = locale === config.sourceLocale;
+		const catalog = loaded.set.get(locale)?.catalog ?? null;
+		const { units, unsourced } = exchangeUnits({
+			catalog,
+			context,
+			locale,
+			isSourceLocale
+		});
+		const selected = filtered && !isSourceLocale ? units.filter((unit) => flags.missing && !unit.usable || flags.ai && unit.state === "ai" && unit.translation !== "") : units;
+		if (unsourced > 0) ctx.out.note(`vi18n export: ${locale}: left out ${plural(unsourced, "entry", "entries")} whose source text the catalogs do not hold; run vi18n extract`);
+		const text = serializeExport(flags.format, selected, {
+			locale,
+			sourceLocale: config.sourceLocale,
+			isSourceLocale,
+			idScheme: codec.idScheme,
+			msgid: config.catalogs.msgid,
+			header: catalog?.header ?? null,
+			layout
+		});
+		if (out === null) {
+			data.files.push({
+				locale,
+				file: null,
+				entries: selected.length
+			});
+			if (ctx.global.json) data.content = text;
+			else ctx.io.stdout(ctx.out.redact(text));
+			continue;
+		}
+		const file = join(out, `${locale}${EXTENSIONS[flags.format]}`);
+		await writeFile(file, text);
+		const shown = ctx.out.display(file);
+		data.files.push({
+			locale,
+			file: shown,
+			entries: selected.length
+		});
+		ctx.out.result(`${locale} → ${shown} (${plural(selected.length, "entry", "entries")})`);
+	}
+	return {
+		exitCode: EXIT.ok,
+		data
+	};
+}
+/**
+* `--locale` as given (each must be configured), else every locale; with a
+* filter, every target locale, since the source locale has nothing missing.
+*/
+function exportLocales(configured, sourceLocale, requested, filtered) {
+	if (requested.length === 0) return filtered ? configured.filter((locale) => locale !== sourceLocale) : [...configured];
+	const out = [];
+	for (const locale of requested) {
+		if (!configured.includes(locale)) throw new CliExit(EXIT.usage, [{
+			code: "config-invalid",
+			severity: "error",
+			message: `--locale ${locale} is not in locales (${configured.join(", ")})`
+		}]);
+		if (!out.includes(locale)) out.push(locale);
+	}
+	return out;
+}
+//#endregion
+export { exportCatalogs };

package/dist/extract-Dujlsgnk.js

@@ -0,0 +1,298 @@
+import { m as updateCatalogFile, n as libraryCoverage, s as catalogPath } from "./library-D5CWvTQs.js";
+import { n as scanProject, r as isIncluded } from "./project-pXipT8iG.js";
+import { t as VERSION } from "./version-BlyLGlOa.js";
+import { a as writeGenFile, n as syncCatalogs, t as syncCatalog } from "./sync-CcVzger_.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, o as loadProject, r as computeDrift, s as occurrencesOf, u as readErrors } from "./project-Dwx7iPm6.js";
+import { dirname, join, resolve } from "node:path";
+import { watch } from "node:fs";
+import { stat } from "node:fs/promises";
+async function extract(ctx, flags) {
+	const project = await loadProject(ctx);
+	if (flags.watch) return watchMode(ctx, project);
+	const scanned = await scan(project, { vite: flags.vite });
+	ctx.out.report(scanned.diagnostics);
+	const loaded = await loadCatalogs(project);
+	ctx.out.report(loaded.diagnostics);
+	const data = {
+		check: flags.check,
+		wrote: [],
+		stats: {},
+		blocked: []
+	};
+	if (readErrors(loaded.diagnostics).length > 0) return {
+		exitCode: EXIT.failure,
+		data
+	};
+	if (hasErrors(scanned.diagnostics)) {
+		ctx.out.result(flags.check ? "vi18n extract --check: the code has errors; fix them before the catalogs are compared" : "nothing written: the code has errors; fix them and rerun vi18n extract");
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	if (flags.check) {
+		const drift = await computeDrift(project, scanned.messages, loaded.set);
+		data.stats = drift.sync.stats;
+		ctx.out.report(collisions(project, scanned, loaded.set, drift.sync));
+		ctx.out.report(drift.diagnostics);
+		const failed = hasErrors(ctx.out.diagnostics);
+		ctx.out.result(failed ? `vi18n extract --check: ${drift.locales.length + (drift.gen ? 1 : 0)} out-of-date file(s)` : "vi18n extract --check: catalogs are up to date");
+		return {
+			exitCode: failed ? EXIT.failure : EXIT.ok,
+			data
+		};
+	}
+	const options = {
+		mode: "full",
+		yes: flags.yes
+	};
+	const { config, codec } = project;
+	const sync = syncCatalogs({
+		config,
+		codec,
+		messages: scanned.messages,
+		catalogs: loaded.set,
+		options
+	});
+	data.stats = sync.stats;
+	ctx.out.report(sync.diagnostics);
+	const collided = collisions(project, scanned, loaded.set, sync);
+	ctx.out.report(collided);
+	if (hasErrors(collided)) return {
+		exitCode: EXIT.failure,
+		data
+	};
+	if (sync.blocked.length > 0) {
+		data.blocked = sync.blocked;
+		ctx.out.result(table([
+			"locale",
+			"removals",
+			"limit"
+		], sync.blocked.map((row) => [
+			row.locale,
+			row.removals,
+			row.limit
+		])));
+		ctx.out.result("nothing written: rerun with --yes if the removals are intended");
+		return {
+			exitCode: EXIT.failure,
+			data
+		};
+	}
+	data.wrote = await writeCatalogs(project, loaded.set, sync, scanned, options);
+	if (await writeGenFile(config)) data.wrote.push(rootRelative(config.root, join(dirname(config.configFile), "vi18n.gen.ts")));
+	printStats(ctx, data);
+	return {
+		exitCode: hasErrors(ctx.out.diagnostics) ? EXIT.failure : EXIT.ok,
+		data
+	};
+}
+/**
+* Collisions among the scan's texts and against the catalogs, ignoring the
+* entries this run deletes (an entry whose text left the code cannot
+* collide with the new text that took its id).
+*/
+function collisions(project, scanned, set, sync) {
+	return findCollisions(occurrencesOf(scanned), set, project.codec, {
+		referenced: new Set(project.config.extraction.keep),
+		ignoreKeys: new Set(sync.deletedKeys)
+	});
+}
+/**
+* Writes each changed locale with compare-and-swap: if the file changed
+* since it was read (an editor, the dev server), the locale's sync re-runs
+* on what is there now instead of overwriting it.
+*/
+async function writeCatalogs(project, set, sync, scanned, options) {
+	const { config, codec, layout } = project;
+	const sourceCatalog = set.get(config.sourceLocale)?.catalog ?? null;
+	const coverage = libraryCoverage(set, scanned.messages, config, codec);
+	return (await Promise.all(sync.changed.map(async (locale) => {
+		const loaded = set.get(locale);
+		const path = loaded?.path ?? catalogPath(config, locale);
+		const precomputed = sync.catalogs.get(locale) ?? null;
+		let first = true;
+		return (await updateCatalogFile(path, loaded?.hash ?? null, (current) => {
+			if (first && current === null && loaded?.catalog == null) {
+				first = false;
+				return precomputed;
+			}
+			first = false;
+			return syncCatalog({
+				config,
+				codec,
+				messages: scanned.messages,
+				locale,
+				catalog: current,
+				sourceCatalog,
+				options,
+				coverage
+			}).catalog;
+		}, {
+			locale,
+			layout,
+			isSourceLocale: locale === config.sourceLocale,
+			version: VERSION
+		})).written ? rootRelative(config.root, path) : null;
+	}))).filter((file) => file !== null);
+}
+function printStats(ctx, data) {
+	const rows = Object.entries(data.stats).map(([locale, s]) => [
+		locale,
+		s.added,
+		s.deleted,
+		s.cleared,
+		s.moved,
+		s.rekeyed,
+		s.updated
+	]);
+	if (rows.length > 0) ctx.out.result(table([
+		"locale",
+		"added",
+		"deleted",
+		"cleared",
+		"moved",
+		"rekeyed",
+		"updated"
+	], rows));
+	ctx.out.result(data.wrote.length === 0 ? "catalogs are up to date" : `wrote ${plural(data.wrote.length, "file")}: ${data.wrote.join(", ")}`);
+}
+/**
+* Add-only sync now and after every quiet period following a change under
+* an include root, until the signal aborts (SIGINT in the binary). Each pass
+* re-runs the cached whole-include scan: only changed files are parsed, and
+* collisions are checked against every module, which a scan of the changed
+* files alone could not do.
+*/
+async function watchMode(ctx, project) {
+	const { config } = project;
+	const data = {
+		check: false,
+		wrote: [],
+		stats: {},
+		blocked: []
+	};
+	const signal = ctx.io.signal;
+	const wrote = /* @__PURE__ */ new Set();
+	const pass = async () => {
+		const scanned = await scanProject(config, project.codec, { cache: true });
+		ctx.out.report(scanned.diagnostics);
+		if (scanned.aborted) return;
+		const loaded = await loadCatalogs(project);
+		ctx.out.report(loaded.diagnostics);
+		if (readErrors(loaded.diagnostics).length > 0) return;
+		const options = {
+			mode: "add-only",
+			yes: false
+		};
+		const sync = syncCatalogs({
+			config,
+			codec: project.codec,
+			messages: scanned.messages,
+			catalogs: loaded.set,
+			options
+		});
+		ctx.out.report(sync.diagnostics);
+		const collided = collisions(project, scanned, loaded.set, sync);
+		ctx.out.report(collided);
+		if (hasErrors(collided)) return;
+		const files = await writeCatalogs(project, loaded.set, sync, scanned, options);
+		for (const [locale, stats] of Object.entries(sync.stats)) {
+			const total = data.stats[locale] ??= {
+				added: 0,
+				deleted: 0,
+				cleared: 0,
+				moved: 0,
+				rekeyed: 0,
+				updated: 0
+			};
+			total.added += stats.added;
+			total.updated += stats.updated;
+		}
+		for (const file of files) wrote.add(file);
+		if (files.length > 0) ctx.out.note(`vi18n: updated ${files.join(", ")}`);
+	};
+	await writeGenFile(config);
+	const roots = await watchRoots(config.project.include);
+	const watchers = [];
+	let timer = null;
+	let running = Promise.resolve();
+	let pending = false;
+	let stopped = false;
+	let first = true;
+	const schedule = () => {
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			if (!pending) return;
+			pending = false;
+			running = running.then(pass).catch((error) => {
+				ctx.out.note(`vi18n: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		}, 200);
+	};
+	for (const root of roots) {
+		const onEvent = (_event, name) => {
+			if (stopped) return;
+			const file = name === null ? null : resolve(root.dir, name.toString());
+			if (file !== null && root.file !== null && file !== root.file) return;
+			if (file !== null && !isIncluded(file, config)) return;
+			pending = true;
+			if (!first) schedule();
+		};
+		try {
+			watchers.push(root.file === null ? watch(root.dir, { recursive: true }, onEvent) : watch(root.dir, {}, onEvent));
+		} catch (error) {
+			ctx.out.note(`vi18n: cannot watch ${root.dir}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	try {
+		await pass();
+	} catch (error) {
+		stopped = true;
+		for (const watcher of watchers) watcher.close();
+		throw error;
+	}
+	first = false;
+	if (pending) schedule();
+	await new Promise((done) => {
+		const stop = () => {
+			if (stopped) return;
+			stopped = true;
+			if (timer !== null) clearTimeout(timer);
+			for (const watcher of watchers) watcher.close();
+			running.then(done, done);
+		};
+		if (signal === void 0) return;
+		if (signal.aborted) stop();
+		else signal.addEventListener("abort", stop, { once: true });
+	});
+	return finishWatch(data, wrote);
+}
+function finishWatch(data, wrote) {
+	data.wrote = [...wrote].sort();
+	return {
+		exitCode: EXIT.ok,
+		data
+	};
+}
+/** Directories to watch: each include directory recursively, a file's parent for a file entry. */
+async function watchRoots(include) {
+	const roots = [];
+	for (const entry of include) try {
+		const info = await stat(entry);
+		roots.push(info.isDirectory() ? {
+			dir: entry,
+			file: null
+		} : {
+			dir: dirname(entry),
+			file: entry
+		});
+	} catch {}
+	return roots;
+}
+//#endregion
+export { extract };