@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/pipeline-wxS0SApG.js

@@ -0,0 +1 @@
+export { t as MAX_RETRIES, n as catalogPersister, r as createProvider, i as estimateUsage, a as firstRequests, o as planTranslations, s as replayProvider, c as runTranslations } from "./pipeline-C7g11THL.js";

package/dist/project-Dwx7iPm6.js

@@ -0,0 +1,381 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { a as isManualId } from "./validate-BxpupdAf.js";
+import { t as createCodec } from "./codec-DuvU2VQy.js";
+import { C as usableTranslation, S as entryKey, i as libraryTranslation, l as loadCatalogSet, o as catalogLayout, s as catalogPath } from "./library-D5CWvTQs.js";
+import { n as scanProject } from "./project-pXipT8iG.js";
+import { n as loadConfig } from "./load-gW-oJt1Q.js";
+import { i as genFileUpToDate, n as syncCatalogs, r as GEN_FILE } from "./sync-CcVzger_.js";
+import { r as resolveDuplicates, t as duplicateDiagnostics } from "./duplicates-yuRljQ6h.js";
+import { i as rootRelative, r as plural } from "./output-DsaHKHEt.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { dirname, join } from "node:path";
+import { readFile } from "node:fs/promises";
+//#region src/cli/project.ts
+/**
+* What several commands share: loading the config (exit 2 without one, so a
+* typo in `--cwd` never "succeeds" on an empty project), the cached include
+* scan, the catalog set, the referenced messages (code plus `keep` ids), each
+* locale's own-entry status, and the drift `extract --check` and `compile`
+* refuse to run past.
+*/
+/** Ends a command early with an exit code; `run` reports the diagnostics and prints the envelope. */
+var CliExit = class extends Error {
+	exitCode;
+	diagnostics;
+	data;
+	constructor(exitCode, diagnostics = [], data = null) {
+		super(diagnostics[0]?.message ?? `exit ${exitCode}`);
+		this.exitCode = exitCode;
+		this.diagnostics = diagnostics;
+		this.data = data;
+	}
+};
+async function loadProject(ctx) {
+	let config;
+	try {
+		config = await loadConfig({
+			cwd: ctx.global.cwd,
+			configFile: ctx.global.config
+		});
+	} catch (error) {
+		if (isDiagnosticError(error)) throw new CliExit(EXIT.usage, [error.diagnostic]);
+		throw new CliExit(EXIT.usage, [{
+			code: "config-invalid",
+			severity: "error",
+			message: `vi18n.config.ts could not be loaded: ${error instanceof Error ? error.message : String(error)}`
+		}]);
+	}
+	if (config.configFile === null) throw new CliExit(EXIT.usage, [{
+		code: "config-not-found",
+		severity: "error",
+		message: `no vi18n.config.ts in ${ctx.global.cwd} or any directory above it up to the workspace root; run vi18n init`
+	}]);
+	ctx.out.setRoot(config.root);
+	ctx.out.addSecret(ctx.io.env[config.ai.apiKeyEnv]);
+	return {
+		config,
+		codec: createCodec(config.ids.length),
+		layout: catalogLayout(config)
+	};
+}
+/**
+* The cached include scan, or with `vite` the scan through the project's
+* Vite config (`extract --vite`); an aborted scan (parse error, missing
+* compiler, empty root) ends the command.
+*/
+async function scan(project, options = {}) {
+	const result = options.vite === true ? await (await import("./vite-scan-B_YW4X_a.js")).scanWithVite(project.config) : await scanProject(project.config, project.codec, { cache: true });
+	if (result.aborted) throw new CliExit(EXIT.failure, result.diagnostics.filter(isAbortCause));
+	return result;
+}
+function isAbortCause(diagnostic) {
+	return diagnostic.severity === "error";
+}
+async function loadCatalogs(project) {
+	return loadCatalogSet(project.config, project.codec);
+}
+/** Every occurrence with its location, as `findCollisions` wants them (aggregation keeps only the first text of an id). */
+function occurrencesOf(scanned) {
+	const list = [];
+	for (const file of scanned.files) for (const occurrence of file.occurrences) list.push({
+		id: occurrence.id,
+		manual: occurrence.manual,
+		canonical: occurrence.canonical,
+		sourceHash: occurrence.sourceHash,
+		label: occurrence.label,
+		source: occurrence.source,
+		locations: [{
+			file: occurrence.file,
+			line: occurrence.line
+		}]
+	});
+	return list;
+}
+/**
+* The messages a locale must cover: the scan's, plus `keep` ids no code
+* declares, whose text comes from the source locale's entry (else any
+* locale's), as `compileLocales` resolves them. A `keep` id with no entry
+* anywhere is `keep-missing-entry`.
+*/
+function referencedMessages(project, messages, set) {
+	const { config, codec, layout } = project;
+	const identities = /* @__PURE__ */ new Map();
+	for (const [id, message] of messages) identities.set(id, message);
+	const diagnostics = [];
+	const wanted = config.extraction.keep.filter((id) => !identities.has(id));
+	if (wanted.length === 0) return {
+		identities,
+		diagnostics
+	};
+	const order = [config.sourceLocale, ...config.locales.filter((l) => l !== config.sourceLocale)];
+	for (const id of wanted) {
+		let text = null;
+		for (const locale of order) {
+			const catalog = set.get(locale)?.catalog;
+			if (catalog == null) continue;
+			for (const entry of catalog.entries) if (entry.source !== null && entryKey(entry, layout, codec) === id) {
+				text = entry.source;
+				break;
+			}
+			if (text !== null) break;
+		}
+		if (text === null) {
+			diagnostics.push({
+				code: "keep-missing-entry",
+				severity: "error",
+				message: `extraction.keep lists ${id}, but no code declares it and no catalog has an entry for it; add msg({ id: "${id}", message: "…" }) to the code or remove it from keep`,
+				id
+			});
+			continue;
+		}
+		try {
+			const canonical = codec.canonicalize(text);
+			identities.set(id, {
+				id,
+				manual: isManualId(id),
+				canonical,
+				sourceHash: codec.sourceHash(canonical),
+				label: codec.label(canonical)
+			});
+		} catch (error) {
+			if (!isDiagnosticError(error)) throw error;
+		}
+	}
+	return {
+		identities,
+		diagnostics
+	};
+}
+/**
+* The locale's **own** entries against the referenced messages: the one
+* definition (`usableTranslation`) that compilation, `check` and `status`
+* share, without walking fallbacks — a fallback hides a gap, it does not
+* fill it.
+*/
+function ownStatus(project, locale, loaded, identities) {
+	const { codec, layout, config } = project;
+	const status = {
+		locale,
+		total: identities.size,
+		translated: 0,
+		ai: 0,
+		missing: 0,
+		reasons: /* @__PURE__ */ new Map(),
+		invalid: [],
+		diagnostics: [],
+		schemeMismatch: false,
+		entries: /* @__PURE__ */ new Map()
+	};
+	const read = loaded?.catalog ?? null;
+	const index = /* @__PURE__ */ new Map();
+	if (read !== null) {
+		const resolved = resolveDuplicates(read, codec);
+		const file = rootRelative(config.root, loaded?.path ?? catalogPath(config, locale));
+		status.diagnostics.push(...duplicateDiagnostics(resolved.duplicates, file));
+		for (const entry of resolved.catalog.entries) {
+			const key = entryKey(entry, layout, codec);
+			if (key !== null && !index.has(key)) index.set(key, entry);
+		}
+		status.schemeMismatch = layout !== "source" && read.header.idScheme !== null && read.header.idScheme !== codec.idScheme;
+	}
+	for (const [id, identity] of identities) {
+		if (status.schemeMismatch && (layout === "id" || !identity.manual)) {
+			status.missing++;
+			status.reasons.set(id, "scheme-mismatch");
+			continue;
+		}
+		const entry = index.get(id);
+		const library = () => {
+			const found = libraryTranslation(loaded, identity, layout, codec);
+			if (found === null) return false;
+			if (found.state === "ai") status.ai++;
+			else status.translated++;
+			return true;
+		};
+		if (entry === void 0) {
+			if (library()) continue;
+			status.missing++;
+			status.reasons.set(id, "no-entry");
+			continue;
+		}
+		status.entries.set(id, entry);
+		const usable = usableTranslation(entry, layout, identity, codec, locale);
+		if (usable.ok) {
+			if (entry.state === "ai") status.ai++;
+			else status.translated++;
+			continue;
+		}
+		if (entry.translation === "" && library()) continue;
+		status.missing++;
+		status.reasons.set(id, usable.reason);
+		if (usable.reason === "invalid" || usable.reason === "fuzzy") status.invalid.push({
+			id,
+			reason: usable.reason,
+			line: entry.line
+		});
+		status.diagnostics.push(...usable.diagnostics);
+	}
+	return status;
+}
+/** (translated + ai) / total × 100 with one decimal; an empty locale has nothing left to do. */
+function percent(done, total) {
+	if (total === 0) return 100;
+	return Math.round(done / total * 1e3) / 10;
+}
+/** Unused-entry warnings listed per locale; the rest is counted in the drift message. */
+const UNUSED_LISTED = 20;
+/**
+* What `vi18n extract` would change, without writing (`extract --check`,
+* and `compile`'s refusal). The safety limit does not apply: drift is drift
+* whether or not extract would need `--yes` to fix it.
+*/
+async function computeDrift(project, messages, set) {
+	const { config, codec, layout } = project;
+	const sync = syncCatalogs({
+		config,
+		codec,
+		messages,
+		catalogs: set,
+		options: {
+			mode: "full",
+			yes: true
+		}
+	});
+	const diagnostics = [];
+	const keep = new Set(config.extraction.keep);
+	const changed = new Set(sync.changed);
+	for (const locale of config.locales) {
+		const loaded = set.get(locale);
+		const path = loaded?.path ?? catalogPath(config, locale);
+		const file = rootRelative(config.root, path);
+		const read = loaded?.catalog ?? null;
+		let wrapped = 0;
+		let unused = 0;
+		if (read !== null) {
+			if (read.header.idScheme !== null && read.header.idScheme !== codec.idScheme) diagnostics.push({
+				code: "id-scheme-mismatch",
+				severity: "error",
+				message: `${file} records ${read.header.idScheme}, but ids.length ${config.ids.length} gives ${codec.idScheme}; run vi18n extract to re-key it (translations are kept)`,
+				file,
+				locale
+			});
+			for (const entry of read.entries) {
+				if (entry.wrapped) {
+					wrapped++;
+					diagnostics.push({
+						code: "catalog-wrapped",
+						severity: "warning",
+						message: "a string is wrapped over several lines; vi18n extract rewrites it on one line",
+						file,
+						line: entry.line,
+						locale
+					});
+				}
+				if (entry.foreignContext !== null) {
+					diagnostics.push({
+						code: "catalog-foreign-context",
+						severity: "warning",
+						message: `msgctxt "${entry.foreignContext}" is not a manual id (no "."), so no message matches this entry; give it a manual id with a "." or remove it`,
+						file,
+						line: entry.line,
+						locale
+					});
+					continue;
+				}
+				const key = entryKey(entry, layout, codec);
+				if (key === null || messages.has(key) || keep.has(key)) continue;
+				unused++;
+				if (unused <= UNUSED_LISTED) diagnostics.push({
+					code: "catalog-unused-entry",
+					severity: "warning",
+					message: `${key} is not referenced by the code; vi18n extract deletes it`,
+					file,
+					line: entry.line,
+					locale,
+					id: key
+				});
+			}
+		}
+		if (!changed.has(locale)) continue;
+		diagnostics.push({
+			code: "catalog-drift",
+			severity: "error",
+			message: read === null ? `${file} does not exist yet; run vi18n extract` : `${file} is out of date (${driftSummary(sync.stats[locale], wrapped, unused)}); run vi18n extract`,
+			file,
+			locale
+		});
+	}
+	const gen = config.configFile === null ? null : await genDrift(config);
+	if (gen !== null) {
+		const path = join(dirname(config.configFile), GEN_FILE);
+		diagnostics.push({
+			code: "catalog-drift",
+			severity: "error",
+			message: gen === "missing" ? `${GEN_FILE} does not exist yet; run vi18n extract` : `${GEN_FILE} differs from what vi18n extract writes for the configured locales (edited by hand, or the locales changed); run vi18n extract`,
+			file: rootRelative(config.root, path)
+		});
+	}
+	return {
+		sync,
+		locales: sync.changed,
+		gen: gen !== null,
+		diagnostics
+	};
+}
+function driftSummary(stats, wrapped, unused) {
+	const parts = [];
+	if (stats !== void 0) {
+		if (stats.added > 0) parts.push(`${stats.added} to add`);
+		if (stats.deleted > 0) parts.push(`${stats.deleted} to delete`);
+		if (stats.cleared > 0) parts.push(`${stats.cleared} to clear`);
+		if (stats.moved > 0) parts.push(`${stats.moved} to move`);
+		if (stats.rekeyed > 0) parts.push(`${stats.rekeyed} to re-key`);
+		if (stats.updated > 0) parts.push(`${stats.updated} to update`);
+	}
+	if (wrapped > 0) parts.push(plural(wrapped, "wrapped entry", "wrapped entries"));
+	if (unused > UNUSED_LISTED) parts.push(`${unused} unused entries, ${UNUSED_LISTED} listed`);
+	return parts.length === 0 ? "formatting or header" : parts.join(", ");
+}
+/** Null when `vi18n.gen.ts` is up to date (an earlier release's content for the same locales counts). */
+async function genDrift(config) {
+	const path = join(dirname(config.configFile), GEN_FILE);
+	try {
+		return genFileUpToDate(config, await readFile(path, "utf8")) ? null : "stale";
+	} catch (error) {
+		if (error.code === "ENOENT") return "missing";
+		throw error;
+	}
+}
+/** Catalog read errors make every writer refuse: rewriting a file vi18n cannot fully read drops what it skipped. */
+function readErrors(diagnostics) {
+	return diagnostics.filter((d) => d.code === "catalog-parse" && d.severity === "error");
+}
+/** Target locales from `--locale` (default: every configured locale but the source); unknown ones are usage errors. */
+function targetLocales(config, requested) {
+	const targets = config.locales.filter((locale) => locale !== config.sourceLocale);
+	if (requested.length === 0) return targets;
+	const out = [];
+	for (const locale of requested) {
+		if (locale === config.sourceLocale) throw new CliExit(EXIT.usage, [{
+			code: "config-invalid",
+			severity: "error",
+			message: `--locale ${locale} is the source locale, which is compiled from code and has nothing to translate`
+		}]);
+		if (!targets.includes(locale)) throw new CliExit(EXIT.usage, [{
+			code: "config-invalid",
+			severity: "error",
+			message: `--locale ${locale} is not in locales (${config.locales.join(", ")})`
+		}]);
+		if (!out.includes(locale)) out.push(locale);
+	}
+	return out;
+}
+function hasErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+/** UTF-16 code-unit order, as every vi18n file uses. */
+function compareText(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+//#endregion
+export { loadCatalogs as a, ownStatus as c, referencedMessages as d, scan as f, hasErrors as i, percent as l, compareText as n, loadProject as o, targetLocales as p, computeDrift as r, occurrencesOf as s, CliExit as t, readErrors as u };