@i18n-micro/cli 0.0.0-stage → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+ 
+ Copyright (c) 2024 s00d
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# @i18n-micro/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Command-line tools for [nuxt-i18n-micro](https://github.com/s00d/nuxt-i18n-micro): a CI gate for your translations, safe removal of unused keys, translation of what is missing, and a rename that follows the code.
+
+```bash
+npm install -D @i18n-micro/cli
+npx i18n-micro check                                       # the CI gate: exit 0, 1 on findings, 2 on failure
+npx i18n-micro translate --dryRun                          # what a run would send
+I18N_TRANSLATE_TOKEN=... npx i18n-micro translate --service deepl
+npx i18n-micro clean --dryRun                              # keys nothing in the project uses
+npx i18n-micro rename --from common.save --to actions.save
+```
+
+| Group                | Commands                                     |
+| -------------------- | -------------------------------------------- |
+| Inspect              | `info`, `check`, `stats`, `lint`, `search`   |
+| Translation workflow | `extract`, `translate`, `sync`, `clean`      |
+| Refactoring          | `text-to-i18n`, `rename`, `pseudo`, `format` |
+| Exchange             | `export`, `import`, `sync-remote`            |
+
+It runs inside a Nuxt project and reads `locales`, `defaultLocale`, `translationDir` and layers from `nuxt.config` through the project's own Nuxt. Requires Node.js 20 or newer.
+
+- [Guide](https://s00d.github.io/nuxt-i18n-micro/guide/cli)
+- [All commands and flags](https://s00d.github.io/nuxt-i18n-micro/api/cli), also available as `i18n-micro <command> --help`
+
+This package replaces `nuxt-i18n-micro-cli`. The [guide](https://s00d.github.io/nuxt-i18n-micro/guide/cli#moving-from-nuxt-i18n-micro-cli) maps the old commands to the new ones.
+
+## License
+
+MIT

package/bin/i18n-micro.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// Committed, unlike dist: pnpm links workspace bins at install time, before `dist` is built.
+import '../dist/cli.mjs'

package/dist/chunks/check-BaP_H-mS.mjs

@@ -0,0 +1,175 @@
+import { A as log, _ as findingsError, a as flattenStrings, s as groupBy, x as usageError } from "./json-BV_apCMu.mjs";
+import { d as splitList, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { n as relativeFile, t as Project } from "./project-DgWgr7pF.mjs";
+import { f as usageDoubts, u as scanProject } from "./source-Bx2lHSW7.mjs";
+import { t as CHECK_TYPES } from "./spec-BwZlT28L.mjs";
+import { r as findUnused } from "./clean-Do9z6D5j.mjs";
+import { t as extraKeys } from "./sync-C0NVDabK.mjs";
+// src/commands/check.ts
+/** What the runtime fills in: any run without braces or spaces. */
+var PLACEHOLDER = /\{([^{}\s]+)\}/g;
+function placeholdersOf(text) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const [, name] of text.matchAll(PLACEHOLDER)) counts.set(name, (counts.get(name) ?? 0) + 1);
+	return counts;
+}
+/** Japanese and the like have one form, and their translation of `a | b` lost nothing. */
+function hasPluralForms(code) {
+	try {
+		return new Intl.PluralRules(code).resolvedOptions().pluralCategories.length > 1;
+	} catch {
+		return true;
+	}
+}
+function placeholderDrift(source, translated, code) {
+	const expected = placeholdersOf(source);
+	const actual = placeholdersOf(translated);
+	const exact = !source.includes("|") && !translated.includes("|");
+	const short = (a, b) => [...a].filter(([name, count]) => (b.get(name) ?? 0) < (exact ? count : 1)).map(([name]) => name);
+	const lost = short(expected, actual).map((name) => `lost {${name}}`);
+	const added = short(actual, expected).map((name) => `added {${name}}`);
+	const plural = source.includes("|") && !translated.includes("|") && hasPluralForms(code) ? ["lost the plural forms"] : [];
+	const drift = [
+		...lost,
+		...added,
+		...plural
+	];
+	return drift.length > 0 ? drift.join(", ") : null;
+}
+function missingAndEmpty(reference, locale, code) {
+	return reference.scopes.flatMap((scope) => Object.entries(reference.leaves(scope)).flatMap(([key, value]) => {
+		const file = relativeFile(code, scope);
+		const current = locale.resolve(key, scope);
+		if (current === void 0) return [{
+			type: "missing",
+			locale: code,
+			file,
+			key,
+			detail: String(value)
+		}];
+		if (current === "") return [{
+			type: "empty",
+			locale: code,
+			file,
+			key,
+			detail: String(value)
+		}];
+		if (typeof value !== "string" || typeof current !== "string") return [];
+		const detail = placeholderDrift(value, current, code);
+		return detail ? [{
+			type: "placeholders",
+			locale: code,
+			file,
+			key,
+			detail
+		}] : [];
+	}));
+}
+function emptyInReference(reference, code) {
+	return reference.scopes.flatMap((scope) => Object.entries(reference.leaves(scope)).flatMap(([key, value]) => value === "" ? [{
+		type: "empty",
+		locale: code,
+		file: relativeFile(code, scope),
+		key
+	}] : []));
+}
+/** A component can render on any page, so a page's keys answer for it too. */
+var isDefined = (reference, ref) => ref.page === null ? reference.scopes.some((scope) => reference.get(ref.key, scope) !== void 0) : reference.resolve(ref.key, ref.page) !== void 0;
+function undefinedKeys(project, scan) {
+	const seen = /* @__PURE__ */ new Set();
+	return scan.refs.flatMap((ref) => {
+		if (ref.guard || ref.test || seen.has(ref.key) || isDefined(project.reference, ref)) return [];
+		seen.add(ref.key);
+		return [{
+			type: "undefined",
+			file: `${relativePath(project.config.rootDir, ref.file)}:${ref.line}`,
+			key: ref.key
+		}];
+	});
+}
+function duplicates(project) {
+	return project.codes.flatMap((code) => {
+		const locale = project.locale(code);
+		return [...groupBy(locale.scopes.flatMap((scope) => Object.entries(flattenStrings(locale.ownTree(scope))).map(([key, value]) => ({
+			scope,
+			key,
+			value
+		}))).filter((item) => item.value !== ""), (item) => item.value)].flatMap(([value, places]) => places.length < 2 ? [] : places.map(({ scope, key }) => ({
+			type: "duplicates",
+			locale: code,
+			file: relativeFile(code, scope),
+			key,
+			detail: value
+		})));
+	});
+}
+function selectedTypes(args) {
+	const only = splitList(args.only);
+	const unknown = only.filter((type) => !CHECK_TYPES.includes(type));
+	if (unknown.length > 0) throw usageError(`Unknown check: ${unknown.join(", ")}`, [`Accepted: ${CHECK_TYPES.join(", ")}`]);
+	if (only.length > 0) return new Set(only);
+	return new Set(CHECK_TYPES.filter((type) => type !== "duplicates" || args.duplicates));
+}
+var FIX_HINTS = {
+	missing: "Translate what is missing: i18n-micro translate.",
+	empty: "Translate what is missing: i18n-micro translate.",
+	extra: "Review extra keys: i18n-micro sync --dryRun lists what sync would remove.",
+	placeholders: "Correct the placeholders in the listed translations.",
+	undefined: "Add the listed keys to the default locale.",
+	unused: "Remove unused keys: i18n-micro clean.",
+	duplicates: "Give each key its own text, or use one key in both places."
+};
+function runChecks(project, scan, types, askedForUnused = false) {
+	const { reference, config } = project;
+	const doubts = usageDoubts(scan);
+	const skipUnused = types.has("unused") && doubts.length > 0;
+	const findings = [
+		...emptyInReference(reference, config.defaultLocale),
+		...project.targetCodes.flatMap((code) => missingAndEmpty(reference, project.locale(code), code)),
+		...project.targetCodes.flatMap((code) => extraKeys(reference, project.locale(code)).map(({ scope, key }) => ({
+			type: "extra",
+			locale: code,
+			file: relativeFile(code, scope),
+			key
+		}))),
+		...undefinedKeys(project, scan),
+		...types.has("duplicates") ? duplicates(project) : [],
+		...types.has("unused") && !skipUnused ? findUnused(project, scan).map(({ code, scope, key }) => ({
+			type: "unused",
+			locale: code,
+			file: relativeFile(code, scope),
+			key
+		})) : []
+	].filter((finding) => types.has(finding.type));
+	const summary = Object.fromEntries([...types].map((type) => [type, findings.filter((finding) => finding.type === type).length]));
+	return {
+		ok: findings.length === 0 && !(askedForUnused && skipUnused),
+		summary,
+		findings,
+		...skipUnused ? { unusedSkipped: doubts } : {}
+	};
+}
+function print(report) {
+	for (const [type, items] of groupBy(report.findings, (finding) => finding.type)) log.list(type, items.map(({ locale, file, key, detail }) => [
+		locale,
+		key,
+		file,
+		detail
+	].filter((cell) => Boolean(cell))));
+	if (report.unusedSkipped) log.warn(`Unused keys not checked:\n  ${report.unusedSkipped.join("\n  ")}`);
+}
+async function run(args) {
+	const types = selectedTypes(args);
+	const project = await Project.load(args);
+	const report = runChecks(project, scanProject(project.config, { ignore: splitList(args.ignore) }), types, splitList(args.only).includes("unused"));
+	if (args.json) log.json(report);
+	else print(report);
+	if (report.ok) {
+		if (!args.json) log.success("All checks passed.");
+		return;
+	}
+	const counts = Object.entries(report.summary).filter(([, count]) => count > 0);
+	const summary = counts.map(([type, count]) => `${count} ${type}`).join(", ") || "unused keys could not be checked";
+	throw findingsError(`Check failed: ${summary}.`, args.json ? [] : [...new Set(counts.map(([type]) => FIX_HINTS[type]))]);
+}
+export { run as default, runChecks };

package/dist/chunks/clean-Do9z6D5j.mjs

@@ -0,0 +1,68 @@
+import { A as log, M as plural, S as validationError, _ as findingsError, g as commandFailed, o as getPath } from "./json-BV_apCMu.mjs";
+import { d as splitList, m as walkFiles, r as isUnder } from "./nuxt-dKxG087V.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { f as usageDoubts, p as usageIndex, u as scanProject } from "./source-Bx2lHSW7.mjs";
+import { realpathSync } from "node:fs";
+// src/commands/clean.ts
+function regexFrom(pattern, flag) {
+	if (!pattern) return null;
+	try {
+		return new RegExp(pattern);
+	} catch {
+		throw validationError(`Invalid regular expression for --${flag}: ${pattern}`);
+	}
+}
+/**
+* Keys of this project's own files that nothing in the project can read. A key used anywhere
+* stays in every scope: a page's route name is not always knowable from its file.
+*/
+function findUnused(project, scan) {
+	const isUsed = usageIndex(scan);
+	return project.codes.flatMap((code) => {
+		const locale = project.locale(code);
+		return locale.scopes.flatMap((scope) => Object.keys(locale.leaves(scope)).filter((key) => !isUsed(key) && getPath(locale.inheritedTree(scope), key) === void 0).map((key) => ({
+			code,
+			scope,
+			key
+		})));
+	});
+}
+/** Why removing keys cannot be trusted here. Empty when it can. */
+function deletionDoubts(project, scan) {
+	const shared = sharedLocaleFiles(project.config).map((file) => `Locale file outside the project: ${file}`);
+	return [...usageDoubts(scan), ...shared];
+}
+/** A locale file that lives outside the project may feed another app too, whose code was not scanned. */
+function sharedLocaleFiles(config) {
+	const root = realpathSync(config.rootDir);
+	return walkFiles(config.translationDir, (path) => path.endsWith(".json")).filter((file) => !isUnder(root, realpathSync(file)));
+}
+/** Nothing scanned proves nothing: no flag changes that. */
+function assertScanned(scan) {
+	if (scan.files === 0) throw commandFailed("No source files found: nothing proves a key unused or extra, so none is removed.", ["Run from the app root, or pass --cwd."]);
+}
+var describe = ({ code, scope, key }) => [
+	code,
+	key,
+	...scope === "" ? [] : [scope]
+];
+async function run(args) {
+	const project = await Project.load(args);
+	const include = regexFrom(args.include, "include");
+	const exclude = regexFrom(args.exclude, "exclude");
+	const scan = scanProject(project.config, { ignore: splitList(args.ignore) });
+	assertScanned(scan);
+	const doubts = deletionDoubts(project, scan);
+	for (const doubt of doubts) log.warn(doubt);
+	if (doubts.length > 0 && !args.force && !args.dryRun) throw findingsError("Cannot prove which keys are unused, so nothing was removed.", ["Review the list with --dryRun, protect keys with --exclude, then rerun with --force."]);
+	const unused = findUnused(project, scan).filter(({ key }) => (!include || include.test(key)) && !exclude?.test(key));
+	if (args.dryRun) {
+		log.list("Would remove", unused.map(describe));
+		log.note(`Dry run: ${plural(unused.length, "key")} would be removed.${doubts.length > 0 ? " Without --force, none would be." : ""}`);
+		return;
+	}
+	for (const { code, scope, key } of unused) project.locale(code).delete(key, scope);
+	project.save();
+	log.success(`Removed ${plural(unused.length, "unused key")}.`);
+}
+export { run as i, deletionDoubts as n, findUnused as r, assertScanned as t };

package/dist/chunks/clean-bQVjG_2M.mjs

@@ -0,0 +1 @@
+export { t as assertScanned, i as default, n as deletionDoubts, r as findUnused } from "./clean-Do9z6D5j.mjs";

package/dist/chunks/export-C2J-pagB.mjs

@@ -0,0 +1,219 @@
+import { A as log, S as validationError, _ as findingsError, j as pick } from "./json-BV_apCMu.mjs";
+import { a as readJsonIfExists, f as stringifyJson, g as writeFilesAtomic, s as readLoose, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { n as relativeFile, t as Project } from "./project-DgWgr7pF.mjs";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+// src/csv.ts
+/** RFC 4180: enough for the files the CLI reads and writes. */
+var quote = (cell) => /[",\r\n]/.test(cell) ? `"${cell.replace(/"/g, "\"\"")}"` : cell;
+var stringifyCsv = (rows) => rows.map((row) => `${row.map(quote).join(",")}\n`).join("");
+/** A quote out of place makes the rest of the file mean something else, so it stops the read. */
+function parseCsv(content, name = "the CSV") {
+	const rows = [];
+	let row = [];
+	let cell = "";
+	let quoted = false;
+	let openedAt = 0;
+	const malformed = (index) => validationError(`Quote out of place in ${name}, line ${content.slice(0, index).split("\n").length}.`, ["A quote inside a field is written \"a \"\"b\"\" c\"."]);
+	const endCell = () => {
+		row.push(cell);
+		cell = "";
+	};
+	const endRow = () => {
+		endCell();
+		if (row.length > 1 || row[0] !== "") rows.push(row);
+		row = [];
+	};
+	for (let index = 0; index < content.length; index += 1) {
+		const char = content[index];
+		if (quoted) {
+			if (char !== "\"") cell += char;
+			else if (content[index + 1] === "\"") {
+				cell += "\"";
+				index += 1;
+			} else {
+				quoted = false;
+				const next = content[index + 1];
+				if (next !== void 0 && next !== "," && next !== "\r" && next !== "\n") throw malformed(index);
+			}
+			continue;
+		}
+		if (char === "\"") {
+			if (cell !== "") throw malformed(index);
+			quoted = true;
+			openedAt = index;
+		} else if (char === ",") endCell();
+		else if (char === "\n") endRow();
+		else if (char !== "\r") cell += char;
+	}
+	if (quoted) throw validationError(`Unclosed quote in ${name}, line ${content.slice(0, openedAt).split("\n").length}.`, ["Every quoted field needs a closing quote."]);
+	if (cell !== "" || row.length > 0) endRow();
+	return rows;
+}
+// src/po.ts
+/** The small part of gettext the CLI exchanges: a flat catalog of msgid -> msgstr, with msgctxt as a key prefix. */
+var ESCAPES = {
+	n: "\n",
+	t: "	",
+	r: "\r",
+	"\"": "\"",
+	"\\": "\\"
+};
+var escapePo = (text) => text.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\t/g, "\\t").replace(/\r/g, "\\r");
+var unescapePo = (text) => text.replace(/\\(.)/g, (_match, char) => ESCAPES[char] ?? char);
+var sourceComment = (source) => source ? `#. ${source.split("\n").join("\n#. ")}\n` : "";
+function compilePo(messages) {
+	return ["msgid \"\"\nmsgstr \"Content-Type: text/plain; charset=utf-8\\n\"\n", ...messages.map(({ key, value, source }) => `${sourceComment(source)}msgid "${escapePo(key)}"\nmsgstr "${escapePo(value)}"\n`)].join("\n");
+}
+var QUOTED = /^"((?:[^"\\]|\\.)*)"$/;
+var FIELD = /^(msgctxt|msgid_plural|msgid|msgstr)(?:\[(\d+)\])?\s+(".*")$/;
+var emptyEntry = (fuzzy = false) => ({
+	msgctxt: "",
+	msgid: "",
+	forms: [],
+	fuzzy
+});
+function finish(entry, catalog) {
+	if (entry.msgid === "") return;
+	const key = entry.msgctxt ? `${entry.msgctxt}.${entry.msgid}` : entry.msgid;
+	const value = entry.forms.every((form) => form === "") ? "" : entry.forms.join("|");
+	(entry.fuzzy ? catalog.fuzzy : catalog.messages)[key] = value;
+}
+function parsePo(content) {
+	const catalog = {
+		messages: {},
+		fuzzy: {}
+	};
+	let entry = emptyEntry();
+	let write = null;
+	let inTranslation = false;
+	let nextFuzzy = false;
+	const assign = (name, form, first) => {
+		const current = entry;
+		const apply = {
+			msgctxt: (text) => current.msgctxt += text,
+			msgid: (text) => current.msgid += text,
+			msgstr: (text) => current.forms[form] = (current.forms[form] ?? "") + text,
+			msgid_plural: () => ""
+		}[name];
+		write = apply;
+		apply(first);
+	};
+	for (const raw of content.split(/\r?\n/)) {
+		const line = raw.trim();
+		if (line.startsWith("#,") && line.includes("fuzzy")) nextFuzzy = true;
+		if (line === "" || line.startsWith("#")) continue;
+		const match = line.match(FIELD);
+		if (match) {
+			const name = match[1];
+			if (name !== "msgstr" && name !== "msgid_plural" && inTranslation) {
+				finish(entry, catalog);
+				entry = emptyEntry();
+				inTranslation = false;
+			}
+			if (nextFuzzy) entry.fuzzy = true;
+			nextFuzzy = false;
+			if (name === "msgstr") inTranslation = true;
+			assign(name, Number(match[2] ?? 0), unescapePo(match[3].slice(1, -1)));
+			continue;
+		}
+		const continuation = line.match(QUOTED);
+		if (continuation) write?.(unescapePo(continuation[1]));
+	}
+	finish(entry, catalog);
+	return catalog;
+}
+// src/commands/export.ts
+var defaultExchangeDir = (format) => format === "csv" ? "csv_exports" : "pots";
+/** Every key of the scope in either locale, untranslated ones too: they are what a translator is here for. */
+function messagesOf(project, code, scope) {
+	const strings = project.locale(code).strings(scope);
+	const source = project.reference.strings(scope);
+	return [.../* @__PURE__ */ new Set([...Object.keys(source), ...Object.keys(strings)])].map((key) => ({
+		key,
+		value: strings[key] ?? "",
+		source: source[key]
+	}));
+}
+var scopesOf = (project, code) => [.../* @__PURE__ */ new Set([...project.reference.scopes, ...project.locale(code).scopes])];
+function poFiles(project, dir) {
+	return project.codes.flatMap((code) => scopesOf(project, code).map((scope) => [join(dir, ...relativeFile(code, scope, "po").split("/")), compilePo(messagesOf(project, code, scope))]));
+}
+function csvRows(project, code) {
+	return [[
+		"File",
+		"Key",
+		"Source",
+		"Translation"
+	], ...scopesOf(project, code).flatMap((scope) => messagesOf(project, code, scope).map(({ key, value, source }) => [
+		relativeFile(code, scope),
+		key,
+		source ?? "",
+		value
+	]))];
+}
+var csvFiles = (project, dir) => project.codes.map((code) => [join(dir, `${code}.csv`), stringifyCsv(csvRows(project, code))]);
+/** What the last export wrote, by file: the one way to tell a translator's edit from a changed locale file. */
+var MANIFEST = ".i18n-export.json";
+var digest = (text) => createHash("sha256").update(text).digest("hex");
+function readManifest(dir) {
+	try {
+		return readJsonIfExists(join(dir, MANIFEST));
+	} catch {
+		return {};
+	}
+}
+/** Translations in a catalog by key, unconfirmed ones too. `null`: not a file this command wrote. */
+function catalogOf(text, format) {
+	if (format === "po") {
+		const { messages, fuzzy } = parsePo(text);
+		return new Map(Object.entries({
+			...messages,
+			...fuzzy
+		}));
+	}
+	let parsed;
+	try {
+		parsed = parseCsv(text);
+	} catch {
+		return null;
+	}
+	const [header, ...rows] = parsed;
+	const [file, key, translation] = [
+		"File",
+		"Key",
+		"Translation"
+	].map((name) => header?.indexOf(name) ?? -1);
+	if (file === -1 || key === -1 || translation === -1) return null;
+	return new Map(rows.map((row) => [`${row[file]} ${row[key]}`, row[translation] ?? ""]));
+}
+/** A translator's work this run would write over: the file changed since the last export, and not by an import. */
+function holdsUnimportedWork(path, next, format, recorded) {
+	if (!existsSync(path)) return false;
+	const text = readLoose(path);
+	if (digest(text) === recorded) return false;
+	const before = catalogOf(text, format);
+	const after = catalogOf(next, format);
+	return !before || [...before].some(([key, value]) => value !== "" && value !== after?.get(key));
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const dir = resolve(project.config.rootDir, args.dir ?? defaultExchangeDir(args.format));
+	const files = args.format === "csv" ? csvFiles(project, dir) : poFiles(project, dir);
+	const manifest = readManifest(dir);
+	const nameOf = (path) => relativePath(dir, path);
+	const edited = files.filter(([path, text]) => holdsUnimportedWork(path, text, args.format, manifest[nameOf(path)]));
+	if (edited.length > 0 && !args.force) {
+		log.list("Changed since the last export, and not imported", edited.map(([path]) => relativePath(project.config.rootDir, path)));
+		throw findingsError("Nothing was exported.", ["Import them first, or overwrite with --force."]);
+	}
+	const written = Object.fromEntries(files.map(([path, text]) => [nameOf(path), digest(text)]));
+	const others = Object.fromEntries(Object.entries(manifest).filter(([name]) => !name.endsWith(`.${args.format}`)));
+	writeFilesAtomic([...files, [join(dir, MANIFEST), stringifyJson({
+		...others,
+		...written
+	})]], { overwrite: true });
+	log.success(`Exported ${files.length} ${args.format.toUpperCase()} ${pick(files.length, "file", "files")} to ${dir}`);
+}
+export { parseCsv as a, parsePo as i, readManifest as n, run as r, defaultExchangeDir as t };

package/dist/chunks/export-usBaNIpp.mjs

@@ -0,0 +1 @@
+export { r as default, t as defaultExchangeDir, n as readManifest } from "./export-C2J-pagB.mjs";

package/dist/chunks/extract-CJ8UfrVJ.mjs

@@ -0,0 +1,30 @@
+import { d as splitList, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { A as log, M as plural } from "./json-BV_apCMu.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { i as isOwnSource, u as scanProject } from "./source-Bx2lHSW7.mjs";
+// src/commands/extract.ts
+var wanted = (ref) => !ref.guard && !ref.test;
+/**
+* Keys with a text of their own go to the default locale. A key without one stays absent:
+* `''` is a defined value, it would show a blank instead of the fallback locale.
+*/
+function addDefaultText(project, ref) {
+	const scope = ref.page && !project.config.disablePageLocales ? ref.page : "";
+	const conflict = project.reference.set(ref.key, ref.defaultText, scope);
+	if (conflict) log.warn(`Skipping ${ref.key}: ${conflict} already holds a value.`);
+	return !conflict;
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const { reference, config } = project;
+	const scan = scanProject(config, { ignore: splitList(args.ignore) });
+	for (const { file, line, expression, group } of scan.dynamic) if (!group) log.warn(`Dynamic i18n key in ${file}:${line}: ${expression}`);
+	const absent = (ref) => reference.resolve(ref.key, ref.page ?? "") === void 0;
+	const writable = (ref) => Boolean(ref.defaultText) && isOwnSource(config, ref.file);
+	const added = scan.refs.filter((ref) => wanted(ref) && writable(ref) && absent(ref) && addDefaultText(project, ref));
+	const untexted = scan.refs.filter((ref) => wanted(ref) && !writable(ref) && absent(ref));
+	const written = project.save();
+	log.list(`Need a text in ${config.defaultLocale}`, untexted.map((ref) => [ref.key, `${relativePath(config.rootDir, ref.file)}:${ref.line}`]));
+	log.success(`Scanned ${plural(scan.files, "file")}: ${plural(added.length, "key")} added, ${untexted.length} without text, ${plural(written.length, "file")} updated.`);
+}
+export { run as default };

package/dist/chunks/format-6CtMgO-M.mjs

@@ -0,0 +1,26 @@
+import { A as log, M as plural, _ as findingsError, j as pick } from "./json-BV_apCMu.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { u as relativePath } from "./nuxt-dKxG087V.mjs";
+// src/commands/format.ts
+async function run(args) {
+	const project = await Project.load(args);
+	for (const code of project.codes) project.locale(code).modified = true;
+	const options = {
+		indent: args.indent,
+		sort: args.sortKeys,
+		rewrite: true
+	};
+	if (args.check) {
+		const files = project.pendingFiles(options).map(([path]) => relativePath(project.config.rootDir, path));
+		if (files.length === 0) {
+			log.success("All translation files are formatted.");
+			return;
+		}
+		log.list("Not formatted", files);
+		const flags = `${args.indent === 2 ? "" : ` --indent ${args.indent}`}${args.sortKeys === false ? " --no-sortKeys" : ""}`;
+		throw findingsError(`${plural(files.length, "file")} ${pick(files.length, "needs", "need")} formatting.`, [`Run i18n-micro format${flags}.`]);
+	}
+	const written = project.save(options);
+	log.success(`Formatted translation files: ${written.length} changed.`);
+}
+export { run as default };