@i18n-micro/cli 0.0.0-stage → 2.0.1

package/dist/chunks/project-DgWgr7pF.mjs

@@ -0,0 +1,206 @@
+import { S as validationError, a as flattenStrings, d as ownValue, f as pathConflict, i as flatten, l as isObject, m as sortKeys, o as getPath, p as setPath, t as deletePath, v as notFoundError, x as usageError } from "./json-BV_apCMu.mjs";
+import { a as readJsonIfExists, f as stringifyJson, g as writeFilesAtomic, i as matchLineEnding, m as walkFiles, p as stringifyLike, t as loadProjectConfig, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { deepMergeTranslationsRecursive } from "@i18n-micro/utils/deep-merge";
+var merge = (target, source) => deepMergeTranslationsRecursive(target, source);
+/** Scopes arrive from imported files and folder names, and become directories and object keys. */
+function assertSafeScope(scope) {
+	const parts = scope.split("\\").join("/").split("/");
+	if (scope.startsWith("/") || parts.includes("..") || parts.includes("__proto__")) throw validationError(`Unsafe page scope: ${scope}`);
+}
+function readLayer(dir, code, withPages) {
+	const pagesDir = join(dir, "pages");
+	const fileName = `${code}.json`;
+	const pages = {};
+	const files = withPages ? walkFiles(pagesDir, (path) => path.endsWith(`${sep}${fileName}`)) : [];
+	for (const file of files) {
+		const scope = relativePath(pagesDir, dirname(file));
+		assertSafeScope(scope);
+		pages[scope] = readJsonIfExists(file);
+	}
+	return {
+		global: readJsonIfExists(join(dir, fileName)),
+		pages
+	};
+}
+function mergeLayers(layers) {
+	const out = {
+		global: {},
+		pages: {}
+	};
+	for (const layer of layers) {
+		out.global = merge(out.global, layer.global);
+		for (const [scope, tree] of Object.entries(layer.pages)) out.pages[scope] = merge(ownValue(out.pages, scope) ?? {}, tree);
+	}
+	return out;
+}
+/** The file's own order first: a save must not shuffle a file because a layer lists keys differently. */
+var orderedLike = (tree, own) => [.../* @__PURE__ */ new Set([...Object.keys(own), ...Object.keys(tree)])].filter((key) => Object.hasOwn(tree, key));
+/**
+* What the project file has to contain so the merged view stays the same.
+*
+* Commands see every layer merged, the way the app does, but a layer's key does not belong in
+* the app's file: copied there it would silently shadow the layer forever.
+*/
+function ownPart(tree, inherited, own) {
+	const out = {};
+	for (const key of orderedLike(tree, own)) {
+		const value = tree[key];
+		const base = Object.hasOwn(inherited, key) ? inherited[key] : void 0;
+		const mine = Object.hasOwn(own, key) ? own[key] : void 0;
+		if (isObject(value) && isObject(base)) {
+			const nested = ownPart(value, base, isObject(mine) ? mine : {});
+			if (Object.keys(nested).length > 0 || mine !== void 0) out[key] = nested;
+			continue;
+		}
+		if (mine !== void 0 || JSON.stringify(value) !== JSON.stringify(base)) out[key] = value;
+	}
+	return out;
+}
+/** `de.json` or `pages/about/de.json`: the one place a scope turns into a path. */
+var relativeFile = (code, scope, extension = "json") => scope === "" ? `${code}.${extension}` : `pages/${scope}/${code}.${extension}`;
+var LocaleSet = class {
+	inherited;
+	own;
+	global;
+	pages;
+	modified = false;
+	constructor(merged, inherited, own) {
+		this.inherited = inherited;
+		this.own = own;
+		this.global = structuredClone(merged.global);
+		this.pages = structuredClone(merged.pages);
+	}
+	get pageScopes() {
+		return Object.keys(this.pages);
+	}
+	/** The global scope first, then every page. */
+	get scopes() {
+		return ["", ...this.pageScopes];
+	}
+	tree(scope) {
+		return scope === "" ? this.global : ownValue(this.pages, scope) ?? {};
+	}
+	/** The project's file as it was read. */
+	ownTree(scope) {
+		return scope === "" ? this.own.global : ownValue(this.own.pages, scope) ?? {};
+	}
+	inheritedTree(scope) {
+		return scope === "" ? this.inherited.global : ownValue(this.inherited.pages, scope) ?? {};
+	}
+	/** The project's file as it stands now: edits in, layers out. */
+	fileTree(scope) {
+		return ownPart(this.tree(scope), this.inheritedTree(scope), this.ownTree(scope));
+	}
+	replaceTree(scope, tree) {
+		if (scope === "") this.global = tree;
+		else this.pages[scope] = tree;
+		this.modified = true;
+	}
+	strings(scope = "") {
+		return flattenStrings(this.tree(scope));
+	}
+	leaves(scope = "") {
+		return flatten(this.tree(scope));
+	}
+	get(key, scope = "") {
+		return getPath(this.tree(scope), key);
+	}
+	/** What the app reads on `scope`: the page's value, then the global one. */
+	resolve(key, scope) {
+		return this.get(key, scope) ?? this.get(key);
+	}
+	/** Writes `value`, or returns the key that blocks it: a write never destroys another value. */
+	set(key, value, scope = "") {
+		assertSafeScope(scope);
+		if (key.split(".").includes("__proto__")) return key;
+		const conflict = pathConflict(this.tree(scope), key);
+		if (conflict) return conflict;
+		if (scope !== "" && !Object.hasOwn(this.pages, scope)) this.pages[scope] = {};
+		setPath(this.tree(scope), key, value);
+		this.modified = true;
+		return null;
+	}
+	delete(key, scope = "") {
+		if (deletePath(this.tree(scope), key)) this.modified = true;
+	}
+};
+var Project = class Project {
+	config;
+	locales;
+	constructor(config, locales) {
+		this.config = config;
+		this.locales = locales;
+	}
+	static async load(options) {
+		const config = await loadProjectConfig(resolve(options.cwd ?? "."));
+		const requested = options.translationDir ? resolve(config.rootDir, options.translationDir) : config.translationDir;
+		const own = requested === config.translationDir;
+		const resolved = {
+			...config,
+			translationDir: requested,
+			translationDirs: own ? config.translationDirs : [requested],
+			additionalDirs: own ? config.additionalDirs : []
+		};
+		const locales = /* @__PURE__ */ new Map();
+		for (const { code } of resolved.locales) {
+			const layers = resolved.translationDirs.map((dir) => readLayer(dir, code, !resolved.disablePageLocales && !resolved.additionalDirs.includes(dir)));
+			locales.set(code, new LocaleSet(mergeLayers(layers), mergeLayers(layers.slice(0, -1)), layers.at(-1)));
+		}
+		return new Project(resolved, locales);
+	}
+	get codes() {
+		return this.config.locales.map((locale) => locale.code);
+	}
+	/** Locales to fill in from the default one. */
+	get targetCodes() {
+		return this.codes.filter((code) => code !== this.config.defaultLocale);
+	}
+	/** The comma list of a `--locale` flag, or every target locale. */
+	selectLocales(list) {
+		if (list.length === 0) return this.targetCodes;
+		const unknown = list.filter((code) => !this.targetCodes.includes(code));
+		if (unknown.length > 0) throw usageError(`Not a target locale: ${unknown.join(", ")}`, [`Target locales: ${this.targetCodes.join(", ")}`]);
+		return list;
+	}
+	locale(code) {
+		const set = this.locales.get(code);
+		if (!set) throw notFoundError(`Locale ${code} not found`, ["Check configured locales in nuxt.config i18n.locales."], { Locale: code });
+		return set;
+	}
+	get reference() {
+		return this.locale(this.config.defaultLocale);
+	}
+	filesOf(code, set, options) {
+		const scopes = [.../* @__PURE__ */ new Set([...set.scopes, ...Object.keys(set.own.pages)])];
+		const files = [];
+		for (const scope of scopes) {
+			const path = join(this.config.translationDir, ...relativeFile(code, scope).split("/"));
+			const own = set.ownTree(scope);
+			const part = set.fileTree(scope);
+			const content = options.sort ? sortKeys(part) : part;
+			const previous = existsSync(path) ? readFileSync(path, "utf8") : void 0;
+			if (previous === void 0 && Object.keys(content).length === 0) continue;
+			if (!options.rewrite && previous !== void 0 && JSON.stringify(content) === JSON.stringify(own)) continue;
+			const text = options.indent ? matchLineEnding(previous, stringifyJson(content, options.indent)) : stringifyLike(previous, content);
+			if (text !== previous) files.push([path, text]);
+		}
+		return files;
+	}
+	/** The writes a save would make, for a caller that has other files to change in the same step. */
+	pendingFiles(options = {}) {
+		return this.codes.flatMap((code) => {
+			const set = this.locale(code);
+			return set.modified ? this.filesOf(code, set, options) : [];
+		});
+	}
+	/** Write modified locales in one step, see `writeFilesAtomic`. Returns the paths written. */
+	save(options = {}) {
+		const files = this.pendingFiles(options);
+		writeFilesAtomic(files);
+		for (const code of this.codes) this.locale(code).modified = false;
+		return files.map(([path]) => path);
+	}
+};
+export { relativeFile as n, Project as t };

package/dist/chunks/protect-D1HIuxmJ.mjs

@@ -0,0 +1,36 @@
+// src/translate/protect.ts
+var PLACEHOLDER = /%?\{[^{}]+\}|\{\{[^{}]+\}\}/g;
+/** Replaces placeholders with XML tags, the one thing every service with markup support leaves alone. */
+function protect(text) {
+	const tokens = [];
+	return {
+		masked: text.replace(PLACEHOLDER, (match) => {
+			tokens.push(match);
+			return `<v${tokens.length - 1}/>`;
+		}),
+		tokens
+	};
+}
+function restore(masked, tokens) {
+	let out = masked;
+	for (const [index, token] of tokens.entries()) {
+		const selfClosed = new RegExp(`<\\s*v${index}\\s*/\\s*>`, "gi");
+		const paired = new RegExp(`<\\s*v${index}\\s*>\\s*</\\s*v${index}\\s*>`, "gi");
+		out = out.replace(selfClosed, () => token).replace(paired, () => token);
+	}
+	return out;
+}
+var bag = (items) => [...items].sort().join("\0");
+/** A placeholder lost, repeated, added or still masked after translation: such a value must not reach a locale file. */
+var isIntact = (translated, tokens) => !/<\s*\/?\s*v\d+\s*\/?\s*>/i.test(translated) && bag(translated.match(PLACEHOLDER) ?? []) === bag(tokens);
+var ENTITIES = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": `'`,
+	"&#x27;": `'`
+};
+/** Services in HTML mode return `&#39;` for an apostrophe. */
+var decodeEntities = (text) => text.replace(/&(?:amp|lt|gt|quot|#39|#x27);/g, (entity) => ENTITIES[entity] ?? entity);
+export { restore as i, isIntact as n, protect as r, decodeEntities as t };

package/dist/chunks/pseudo-oXBaONgF.mjs

@@ -0,0 +1,32 @@
+import { A as log, S as validationError, v as notFoundError } from "./json-BV_apCMu.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { i as restore, r as protect } from "./protect-D1HIuxmJ.mjs";
+// src/commands/pseudo.ts
+/** Tags, masked placeholders among them, and entities are markup: split on them, the odd chunks are theirs. */
+var elongate = (text) => text.split(/(<\/?[a-z][^<>]*>|&#?\w+;)/i).map((chunk, index) => index % 2 === 1 ? chunk : chunk.replace(/[a-z]/gi, "$&$&")).join("");
+function pseudoLocalize(text) {
+	const { masked, tokens } = protect(text);
+	return restore(`[${elongate(masked)}]`, tokens);
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const sourceCode = args.sourceLocale ?? project.config.defaultLocale;
+	if (sourceCode === args.targetLocale) throw validationError("Source and target locale must be different");
+	if (!project.codes.includes(args.targetLocale)) throw notFoundError(`Locale ${args.targetLocale} not found`, ["Add it to i18n.locales in nuxt.config first."]);
+	const source = project.locale(sourceCode);
+	const target = project.locale(args.targetLocale);
+	let updated = 0;
+	let skipped = 0;
+	for (const scope of source.scopes) for (const [key, value] of Object.entries(source.strings(scope))) {
+		const current = target.get(key, scope);
+		const kept = !args.replace && current !== void 0 && (typeof current !== "string" || current.trim() !== "");
+		const conflict = kept ? null : target.set(key, pseudoLocalize(value), scope);
+		if (conflict) log.warn(`Skipping ${key}: ${conflict} already holds a value.`);
+		if (kept || conflict) skipped += 1;
+		else updated += 1;
+	}
+	project.save();
+	log.success(`Pseudo locale generated: ${sourceCode} -> ${args.targetLocale}`);
+	log.note(`Updated keys: ${updated}, skipped keys: ${skipped}`);
+}
+export { run as default, pseudoLocalize };

package/dist/chunks/rename-uJnBX86A.mjs

@@ -0,0 +1,117 @@
+import { A as log, S as validationError, f as pathConflict, i as flatten, o as getPath, p as setPath, s as groupBy, t as deletePath, u as isWritableKey, v as notFoundError } from "./json-BV_apCMu.mjs";
+import { d as splitList, g as writeFilesAtomic } from "./nuxt-dKxG087V.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { i as isOwnSource, n as dataTokensOf, u as scanProject } from "./source-Bx2lHSW7.mjs";
+import { readFileSync } from "node:fs";
+import { MagicString } from "@vue/compiler-sfc";
+// src/commands/rename.ts
+function renameFor(from, to) {
+	return {
+		from,
+		to,
+		renamed: (key) => key === from ? to : key.startsWith(`${from}.`) ? `${to}${key.slice(from.length)}` : null
+	};
+}
+/** One path at a time, on a copy: a clash halfway leaves the tree as it was, and every other key as written. */
+function moved(tree, rename) {
+	const moves = Object.keys(flatten(tree)).flatMap((key) => {
+		const target = rename.renamed(key);
+		return target ? [{
+			key,
+			target,
+			value: getPath(tree, key),
+			flat: Object.hasOwn(tree, key)
+		}] : [];
+	});
+	if (moves.length === 0) return null;
+	const next = structuredClone(tree);
+	for (const { key, value } of moves) {
+		deletePath(next, key);
+		const second = getPath(next, key);
+		if (second !== void 0 && JSON.stringify(second) !== JSON.stringify(value)) throw validationError(`${key} is written twice in one file, with different values.`, ["Keep one of them, then rename."], { Key: key });
+		deletePath(next, key);
+	}
+	for (const { target, value, flat } of moves) {
+		const clash = getPath(next, target) === void 0 ? pathConflict(next, target) : target;
+		if (clash) throw validationError(`Target key already exists: ${clash}`, [], { Key: clash });
+		if (flat) next[target] = value;
+		else setPath(next, target, value);
+	}
+	return next;
+}
+function applyToLocales(project, rename) {
+	let changed = 0;
+	for (const code of project.codes) {
+		const locale = project.locale(code);
+		if (locale.scopes.filter((scope) => {
+			const next = moved(locale.tree(scope), rename);
+			if (next) locale.replaceTree(scope, next);
+			if (next && getPath(locale.inheritedTree(scope), rename.from) !== void 0) log.warn(`${rename.from} is also defined in a layer of ${code}: it stays there.`);
+			return Boolean(next);
+		}).length > 0) changed += 1;
+	}
+	return changed;
+}
+/** Only what the parser placed. A position that does not hold the key means the expression was decoded: leave it. */
+function rewritable(ref, content) {
+	const written = ref.keyPrefix ? ref.key.slice(ref.keyPrefix.length) : ref.key;
+	return ref.start >= 0 && content.slice(ref.start, ref.end) === written;
+}
+function rewriteFile(file, refs, rename, skipped, config) {
+	if (!isOwnSource(config, file)) {
+		skipped.push(...refs);
+		return null;
+	}
+	const content = readFileSync(file, "utf8");
+	const magic = new MagicString(content);
+	let count = 0;
+	for (const ref of refs) {
+		const target = rename.renamed(ref.key);
+		const fits = !ref.keyPrefix || target.startsWith(ref.keyPrefix);
+		if (!rewritable(ref, content) || !fits) {
+			skipped.push(ref);
+			continue;
+		}
+		magic.overwrite(ref.start, ref.end, target.slice(ref.keyPrefix?.length ?? 0));
+		count += 1;
+	}
+	return count > 0 ? [file, magic.toString()] : null;
+}
+function rewriteSources(scan, rename, skipped, config) {
+	return [...groupBy(scan.refs.filter((ref) => rename.renamed(ref.key)), (ref) => ref.file)].flatMap(([file, refs]) => {
+		const change = rewriteFile(file, refs, rename, skipped, config);
+		return change ? [change] : [];
+	});
+}
+/** What a rename cannot do by itself. Silence here is how `$t(name)` ends up pointing at nothing. */
+function warnLeftovers(scan, rename, skipped) {
+	for (const ref of skipped) log.warn(`Not rewritten, change by hand: ${ref.file}:${ref.line}`);
+	for (const entry of scan.dynamic) if (entry.prefix && (rename.renamed(entry.prefix.endsWith(".") ? entry.prefix.slice(0, -1) : entry.prefix) || rename.from.startsWith(entry.prefix))) log.warn(`Computed key may need the new name: ${entry.file}:${entry.line}: ${entry.expression}`);
+	for (const [text, locations] of scan.literals) {
+		if (!rename.renamed(text)) continue;
+		for (const location of locations) log.warn(`The key also appears as a plain string: ${location}`);
+	}
+	for (const file of scan.dataFiles) if (dataTokensOf(file).some((token) => rename.renamed(token))) log.warn(`A data file mentions the key, check it by hand: ${file}`);
+}
+async function run(args) {
+	const { from, to, dryRun } = args;
+	if (!from || !to) throw validationError("--from and --to cannot be empty");
+	if (from === to) throw validationError("Source and target keys must be different");
+	if (!isWritableKey(to)) throw validationError(`--to cannot be a key: ${to}`, ["No quotes, backslashes, empty segments or __proto__."]);
+	const project = await Project.load(args);
+	const rename = renameFor(from, to);
+	const localesUpdated = applyToLocales(project, rename);
+	const scan = scanProject(project.config, { ignore: splitList(args.ignore) });
+	const skipped = [];
+	const sourceChanges = rewriteSources(scan, rename, skipped, project.config);
+	const replaced = scan.refs.filter((ref) => rename.renamed(ref.key)).length - skipped.length;
+	if (localesUpdated === 0 && sourceChanges.length === 0) throw notFoundError(`Key not found: ${from}`, ["Search for the key first: i18n-micro search \"<fragment>\""], { Key: from });
+	warnLeftovers(scan, rename, skipped);
+	if (dryRun) log.note("Dry run: no files were modified.");
+	else {
+		writeFilesAtomic([...project.pendingFiles(), ...sourceChanges]);
+		log.success(`Key renamed: ${from} -> ${to}`);
+	}
+	log.note(`Locales: ${localesUpdated}, source files: ${sourceChanges.length}, source replacements: ${replaced}`);
+}
+export { run as default };

package/dist/chunks/runner-CsPPffV1.mjs

@@ -0,0 +1,200 @@
+import { t as version$1 } from "./package-BejjFS6s.mjs";
+import { A as log, D as closePrompts, N as spinner, O as formatDuration, P as style, S as validationError, b as reportError, d as ownValue, k as isInteractive, x as usageError } from "./json-BV_apCMu.mjs";
+import { a as commands, i as REMOVED_COMMANDS, n as COMMAND_GROUPS } from "./spec-DwveYr8X.mjs";
+import { defineCommand, runCommand } from "citty";
+// src/help.ts
+/** The layout of citty's `renderUsage`, as nuxi prints it, with commands grouped and examples added. */
+var BIN = "i18n-micro";
+var title = (text) => style(["underline", "bold"], text);
+/** Two columns, the first padded to the widest: `pad` first, colors after, or the escapes count as width. */
+function table(rows) {
+	const width = Math.max(0, ...rows.map(([left]) => left.length));
+	return rows.map(([left, right]) => `  ${style("cyan", left.padEnd(width))}    ${right}`);
+}
+/** Flags every command has: listed after the ones of the command. */
+var COMMON = /* @__PURE__ */ new Set([
+	"cwd",
+	"logLevel",
+	"debug"
+]);
+function flag(name, arg) {
+	const names = [...arg.alias ? [`-${arg.alias}`] : [], `--${name}`].join(", ");
+	if (arg.type === "boolean") return names;
+	return `${names} <${arg.values ? arg.values.join("|") : arg.numeric ? "n" : "value"}>`;
+}
+function describe(arg) {
+	const fallback = arg.defaultHint?.replaceAll("`", "") ?? (arg.default === void 0 || arg.default === false ? void 0 : String(arg.default));
+	const notes = [arg.required ? "(Required)" : "", fallback === void 0 ? "" : `(Default: ${fallback})`].filter(Boolean).join(" ");
+	return notes ? `${arg.description} ${style("gray", notes)}` : arg.description;
+}
+function rootUsage(version) {
+	const width = Math.max(...Object.keys(commands).map((name) => name.length));
+	const groups = COMMAND_GROUPS.flatMap((group) => {
+		const rows = Object.entries(commands).filter(([, spec]) => spec.group === group);
+		return ["", `  ${style("bold", group)}`].concat(rows.map(([name, spec]) => `    ${style("cyan", name.padEnd(width))}    ${spec.description}`));
+	});
+	return [
+		style("gray", `Command-line tools for nuxt-i18n-micro (${BIN} v${version})`),
+		"",
+		`${title("USAGE")} ${style("cyan", `${BIN} <command> [OPTIONS]`)}`,
+		"",
+		title("COMMANDS"),
+		...groups,
+		"",
+		`Use ${style("cyan", `${BIN} <command> --help`)} for more information about a command.`
+	].join("\n");
+}
+function commandUsage(name, spec, version) {
+	const entries = Object.entries(spec.args);
+	const positionals = entries.filter(([, arg]) => arg.type === "positional");
+	const options = entries.filter(([, arg]) => arg.type !== "positional").sort(([a], [b]) => Number(COMMON.has(a)) - Number(COMMON.has(b)));
+	const usage = [`${BIN} ${name}`, options.length > 0 ? "[OPTIONS]" : ""];
+	for (const [arg, { required }] of positionals) usage.push(required ? `<${arg.toUpperCase()}>` : `[${arg.toUpperCase()}]`);
+	for (const [arg, option] of options) if (option.required) usage.push(flag(arg, option));
+	const optionRows = options.flatMap(([arg, option]) => {
+		const row = [flag(arg, option), describe(option)];
+		return option.type === "boolean" && option.default === true ? [row, [`--no-${arg}`, `Turn --${arg} off`]] : [row];
+	});
+	const section = (heading, lines) => lines.length > 0 ? [
+		title(heading),
+		"",
+		...lines,
+		""
+	] : [];
+	return [
+		style("gray", `${spec.description} (${BIN} ${name} v${version})`),
+		"",
+		`${title("USAGE")} ${style("cyan", usage.filter(Boolean).join(" "))}`,
+		"",
+		...section("ARGUMENTS", table(positionals.map(([arg, option]) => [arg.toUpperCase(), describe(option)]))),
+		...section("OPTIONS", table(optionRows)),
+		...section("EXAMPLES", (spec.examples ?? []).map((example) => `  ${style("gray", "$")} ${example}`))
+	].join("\n").trimEnd();
+}
+// src/runner.ts
+var version = version$1;
+function citty(spec) {
+	const { type, description, default: fallback, required, alias } = spec;
+	return {
+		type,
+		description,
+		default: fallback,
+		required,
+		alias
+	};
+}
+function convert(name, spec, value) {
+	if (value === void 0 || value === "" && !spec.numeric) return value;
+	if (spec.values && !spec.values.includes(String(value))) throw usageError(`Invalid value "${String(value)}" for --${name}`, [`Accepted: ${spec.values.join(", ")}`]);
+	if (!spec.numeric) return value;
+	const number = Number(value);
+	if (!(Number.isFinite(number) && number > 0 && (spec.numeric === "number" || Number.isInteger(number)))) throw validationError(`--${name} must be a positive ${spec.numeric === "int" ? "integer" : "number"}`, [`Example: --${name} 10`]);
+	return number;
+}
+var toCamel = (name) => name.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+var flagName = (raw) => raw.split("=")[0];
+function assertKnownFlag(name, spec, raw) {
+	const flag = toCamel(flagName(raw).slice(2));
+	const positive = flag.replace(/^no([A-Z])/, (_match, letter) => letter.toLowerCase());
+	if (flag !== "help" && !spec.args[flag] && !spec.args[positive]) throw usageError(`Unknown flag ${flagName(raw)} for ${name}`, [`See i18n-micro ${name} --help`]);
+	return {
+		arg: spec.args[flag] ?? spec.args[positive],
+		negated: !spec.args[flag]
+	};
+}
+/** The parser reads anything but `false` as true, so `--force=no` would mean the opposite. */
+function assertBooleanValue(raw) {
+	const separator = raw.indexOf("=");
+	if (separator !== -1 && !["true", "false"].includes(raw.slice(separator + 1))) throw usageError(`${flagName(raw)} takes true or false`, [`Or write ${flagName(raw)} alone.`]);
+}
+/** The parser hands the next word to a string flag, dashes or not: `--exclude --dryRun` would lose the `--dryRun`. */
+function assertHasValue(raw, next) {
+	if (next === void 0 || next.startsWith("-") && next !== "-") throw usageError(`${raw} needs a value`, [`For a value that starts with a dash: ${raw}=<value>`]);
+}
+/**
+* A mistyped `--dryrun`, `-dryRun` or `dryRun` on `clean` must not run the real thing: whatever
+* the parser would drop or misread is an error here. Messages name the flag, never a value:
+* a mistyped `--token` would otherwise end up in a CI log.
+*/
+function assertKnownArgs(name, spec, rawArgs) {
+	let positionals = 0;
+	const end = rawArgs.includes("--") ? rawArgs.indexOf("--") : rawArgs.length;
+	for (let index = 0; index < end; index += 1) {
+		const raw = rawArgs[index];
+		if (raw.startsWith("--")) {
+			const { arg, negated } = assertKnownFlag(name, spec, raw);
+			if (arg?.type === "boolean" || negated) assertBooleanValue(raw);
+			else if (arg?.type === "string" && !raw.includes("=")) {
+				assertHasValue(raw, index + 1 < end ? rawArgs[index + 1] : void 0);
+				index += 1;
+			}
+		} else if (raw.startsWith("-") && raw !== "-") throw usageError(`Not a flag of ${name}`, ["Long flags take two dashes.", `See i18n-micro ${name} --help`]);
+		else positionals += 1;
+	}
+	positionals += Math.max(0, rawArgs.length - end - 1);
+	if (positionals > Object.values(spec.args).filter((arg) => arg.type === "positional").length) throw usageError(`Too many arguments for ${name}`, [`See i18n-micro ${name} --help`]);
+}
+function validated(spec, args) {
+	const out = { ...args };
+	for (const [name, arg] of Object.entries(spec.args)) out[name] = convert(name, arg, args[name]);
+	return out;
+}
+function toCommand(name, spec) {
+	const args = Object.fromEntries(Object.entries(spec.args).map(([key, arg]) => [key, citty(arg)]));
+	return defineCommand({
+		meta: {
+			name,
+			description: spec.description
+		},
+		args,
+		async run({ args: parsed, rawArgs }) {
+			assertKnownArgs(name, spec, rawArgs);
+			log.setSilent(parsed.logLevel === "silent");
+			if (isInteractive() && !parsed.json) log.info(`${style("green", `i18n-micro ${style("bold", `v${version}`)}`)} ${style("gray", `· ${name}`)}`);
+			spinner.start(`Running ${name}`);
+			await (await spec.load()).default(validated(spec, parsed));
+		}
+	});
+}
+var main = defineCommand({
+	meta: {
+		name: "i18n-micro",
+		version,
+		description: "Command-line tools for nuxt-i18n-micro"
+	},
+	subCommands: Object.fromEntries(Object.entries(commands).map(([name, spec]) => [name, toCommand(name, spec)]))
+});
+/** How long the command took, as nuxi ends a build: on a terminal only, where it cannot unsettle a diff of the output. */
+function footer(started, rawArgs) {
+	if (isInteractive() && !rawArgs.some((arg) => arg === "--json" || arg.startsWith("--json="))) log.info(style("gray", `\nDone in ${formatDuration(performance.now() - started)}`));
+}
+/** Run the CLI. Failures set `process.exitCode`; nothing here throws. */
+async function runCli(rawArgs) {
+	process.exitCode = 0;
+	const first = rawArgs[0] ?? "";
+	try {
+		if (rawArgs.length === 1 && ["--version", "-v"].includes(rawArgs[0])) {
+			console.log(version);
+			return;
+		}
+		const replacement = ownValue(REMOVED_COMMANDS, first);
+		if (replacement) throw usageError(`The ${first} command was removed. Use ${replacement}.`);
+		if (rawArgs.length === 0 || rawArgs.includes("--help") || rawArgs.includes("-h")) {
+			const spec = ownValue(commands, first);
+			log.info(spec ? commandUsage(first, spec, version) : rootUsage(version));
+			return;
+		}
+		if (first.startsWith("-")) throw usageError("Flags go after the command.");
+		if (!ownValue(commands, first)) throw usageError(`Unknown command ${first}`, ["See i18n-micro --help"]);
+		const started = performance.now();
+		await runCommand(main, { rawArgs });
+		spinner.stop();
+		footer(started, rawArgs);
+	} catch (error) {
+		spinner.stop();
+		reportError(error, rawArgs.includes("--debug"));
+	} finally {
+		closePrompts();
+	}
+}
+export { runCli as t };

package/dist/chunks/search-Dj_Ynq_x.mjs

@@ -0,0 +1,67 @@
+import { A as log, P as style, S as validationError, a as flattenStrings, o as getPath } from "./json-BV_apCMu.mjs";
+import { d as splitList, u as relativePath } 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";
+// src/commands/search.ts
+function scopesOf(project, wanted) {
+	const all = [...new Set(project.codes.flatMap((code) => project.locale(code).scopes))];
+	if (wanted === "global") return [""];
+	return wanted === "pages" ? all.filter((scope) => scope !== "") : all;
+}
+function matchesOf(project, scan, args) {
+	const isUsed = usageIndex(scan);
+	const fold = (text) => args.caseSensitive ? text : text.toLowerCase();
+	const query = fold((args.query ?? "").trim());
+	const usagesOf = (key) => scan.refs.filter((ref) => ref.key === key).map((ref) => `${relativePath(project.config.rootDir, ref.file)}:${ref.line}`);
+	return scopesOf(project, args.scope).flatMap((scope) => {
+		const byLocale = project.codes.map((code) => [code, flattenStrings(project.locale(code).tree(scope))]);
+		return [...new Set(byLocale.flatMap(([, strings]) => Object.keys(strings)))].flatMap((key) => {
+			const values = byLocale.map(([, strings]) => strings[key] ?? "");
+			const used = isUsed(key);
+			const removable = project.codes.some((code) => {
+				const locale = project.locale(code);
+				return locale.get(key, scope) !== void 0 && getPath(locale.inheritedTree(scope), key) === void 0;
+			});
+			if (args.onlyUnused && (used || !removable)) return [];
+			if (query && ![key, ...values].some((text) => fold(text).includes(query))) return [];
+			return [{
+				scope: scope === "" ? "global" : `pages/${scope}`,
+				key,
+				translations: Object.fromEntries(byLocale.map(([code, strings]) => [code, strings[key] ?? null])),
+				missingLocales: byLocale.filter(([, strings]) => strings[key] === void 0).map(([code]) => code),
+				isUsed: used,
+				usages: usagesOf(key)
+			}];
+		});
+	});
+}
+function printMatch(match) {
+	log.section(`${match.scope}: ${match.key}`);
+	log.rows(Object.entries(match.translations).map(([code, value]) => [code, value ?? "[missing]"]));
+	log.info(style("gray", `  ${match.isUsed ? `Used in: ${match.usages.join(", ") || "a string or a computed key"}` : "Not used"}`));
+}
+async function run(args) {
+	const query = (args.query ?? "").trim();
+	if (!query && !args.onlyUnused) throw validationError("Search query cannot be empty unless --onlyUnused is set", ["Example: i18n-micro search \"welcome\""]);
+	const project = await Project.load(args);
+	const scan = scanProject(project.config, { ignore: splitList(args.ignore) });
+	const found = matchesOf(project, scan, args);
+	const matches = args.limit ? found.slice(0, args.limit) : found;
+	const doubts = args.onlyUnused ? usageDoubts(scan) : [];
+	for (const doubt of doubts) log.warn(doubt);
+	if (args.json) {
+		log.json({
+			query,
+			totalMatches: found.length,
+			matches,
+			...args.onlyUnused ? { doubts } : {}
+		});
+		return;
+	}
+	if (matches.length === 0) {
+		log.note(query ? `No matches found for "${query}"` : "No matches found");
+		return;
+	}
+	for (const match of matches) printMatch(match);
+}
+export { run as default };