@i18n-micro/cli 0.0.0-stage → 2.0.1

package/dist/chunks/sync-C0NVDabK.mjs

@@ -0,0 +1,56 @@
+import { A as log, M as plural, _ as findingsError, o as getPath } from "./json-BV_apCMu.mjs";
+import { d as splitList } from "./nuxt-dKxG087V.mjs";
+import { n as relativeFile, t as Project } from "./project-DgWgr7pF.mjs";
+import { p as usageIndex, u as scanProject } from "./source-Bx2lHSW7.mjs";
+import { n as deletionDoubts, t as assertScanned } from "./clean-Do9z6D5j.mjs";
+// src/commands/sync.ts
+/** Keys of `locale` the default locale cannot answer, compared by path: `"a.b"` and `a: { b }` are the same key. */
+function extraKeys(reference, locale) {
+	return locale.scopes.flatMap((scope) => Object.keys(locale.leaves(scope)).filter((key) => reference.resolve(key, scope) === void 0).map((key) => ({
+		scope,
+		key
+	})));
+}
+/** A scope with nothing to compare against says nothing about the keys of its translations. */
+function missingReferences(project, extras) {
+	const empty = extras.filter(({ scope }) => Object.keys(project.reference.leaves(scope)).length === 0);
+	return [...new Set(empty.map(({ code, scope }) => relativeFile(code, scope)))].map((file) => `No keys in ${project.config.defaultLocale} to compare ${file} with.`);
+}
+var overridden = (project) => project.config.defaultLocaleOverridden ? [`DEFAULT_LOCALE made ${project.config.defaultLocale} the reference, not the default locale of nuxt.config.`] : [];
+/**
+* Removes what the default locale does not have. Missing keys stay missing: `''` would hide
+* them from `fallbackLocale` and from `check`. A delete-only command, so it has the brakes of
+* `clean`, and one more: a reference that is empty proves nothing.
+*/
+async function run(args) {
+	const project = await Project.load(args);
+	const { reference } = project;
+	const scan = scanProject(project.config, { ignore: splitList(args.ignore) });
+	const isUsed = usageIndex(scan);
+	const extras = project.targetCodes.flatMap((code) => extraKeys(reference, project.locale(code)).map(({ scope, key }) => ({
+		code,
+		scope,
+		key
+	})));
+	for (const { code, scope, key } of extras.filter((extra) => isUsed(extra.key))) log.warn(`Keeping ${key} in ${relativeFile(code, scope)}: the code uses it, but ${project.config.defaultLocale} has no text for it.`);
+	const inLayer = ({ code, scope, key }) => getPath(project.locale(code).inheritedTree(scope), key) !== void 0;
+	const removable = extras.filter((extra) => !isUsed(extra.key) && !inLayer(extra));
+	if (removable.length > 0) assertScanned(scan);
+	const doubts = removable.length === 0 ? [] : [
+		...overridden(project),
+		...missingReferences(project, removable),
+		...deletionDoubts(project, scan)
+	];
+	for (const doubt of doubts) log.warn(doubt);
+	if (doubts.length > 0 && !args.force && !args.dryRun) throw findingsError("Cannot prove these keys are extra, so nothing was removed.", ["Review the list with --dryRun, then rerun with --force."]);
+	const removed = removable.map(({ code, scope, key }) => [relativeFile(code, scope), key]);
+	log.list(args.dryRun ? "Would remove" : "Removed", removed);
+	if (args.dryRun) {
+		log.note(`Dry run: ${plural(removed.length, "key")} would be removed.${doubts.length > 0 ? " Without --force, none would be." : ""}`);
+		return;
+	}
+	for (const { code, scope, key } of removable) project.locale(code).delete(key, scope);
+	project.save();
+	log.success(`Translations have been synchronized: ${plural(removed.length, "extra key")} removed.`);
+}
+export { run as n, extraKeys as t };

package/dist/chunks/sync-remote-y3ZATbF2.mjs

@@ -0,0 +1,148 @@
+import { A as log, C as addSecret, M as plural, _ as findingsError, f as pathConflict, h as CliError, i as flatten, j as pick, l as isObject, o as getPath, p as setPath, w as addUrlSecrets, y as remoteConfigError } from "./json-BV_apCMu.mjs";
+import { o as readJsonObject } from "./nuxt-dKxG087V.mjs";
+import { n as requestJson, t as jsonBody } from "./http-whB7a5ye.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { trimLeadingSlashes, trimTrailingSlashes } from "@i18n-micro/utils/app-path";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+// src/commands/sync-remote.ts
+function loadConfig(rootDir) {
+	const path = join(rootDir, ".i18n-remote.json");
+	if (!existsSync(path)) throw remoteConfigError("Remote configuration file not found.", ["Create .i18n-remote.json with the url of your endpoint."], { Path: path });
+	const config = readJsonObject(path, { private: true });
+	if (config.type && config.type !== "custom") throw remoteConfigError(`Remote type "${config.type}" was removed: only an HTTP endpoint of your own is supported.`, ["For a translation platform, use its own CLI: see https://s00d.github.io/nuxt-i18n-micro/guide/crowdin"]);
+	if (!config.url) throw remoteConfigError(".i18n-remote.json needs \"url\".");
+	const token = config.token ?? process.env.I18N_REMOTE_TOKEN;
+	addSecret(token);
+	addSecret(config.auth?.password);
+	addUrlSecrets(config.url);
+	return {
+		...config,
+		token
+	};
+}
+function requestOptions(config) {
+	const { username, password } = config.auth ?? {};
+	const encoded = username ? Buffer.from(`${username}:${password ?? ""}`).toString("base64") : void 0;
+	addSecret(encoded);
+	const authorization = encoded ? `Basic ${encoded}` : config.token ? `Bearer ${config.token}` : void 0;
+	addSecret(authorization);
+	return { headers: authorization ? { Authorization: authorization } : {} };
+}
+var remoteUrl = (config) => `${trimTrailingSlashes(config.url)}/${trimLeadingSlashes(config.path ?? "translations")}`;
+function planLocale(project, code, tree, force, plan) {
+	const local = project.locale(code);
+	const planned = structuredClone(local.global);
+	const apply = (key, value) => {
+		setPath(planned, key, value);
+		plan.apply.push([
+			code,
+			key,
+			value
+		]);
+	};
+	for (const [key, value] of Object.entries(flatten(tree))) {
+		const mine = local.get(key);
+		const label = `${code} ${key}`;
+		const blocker = pathConflict(planned, key);
+		if (value === "" || JSON.stringify(mine) === JSON.stringify(value)) continue;
+		if (key.split(".").includes("__proto__")) plan.conflicts.push(`${label}: a key that cannot be stored`);
+		else if (blocker) plan.conflicts.push(`${label}: ${blocker} already holds a value`);
+		else if (mine === void 0 || mine === "") {
+			plan.added.push(label);
+			apply(key, value);
+		} else if (force) {
+			plan.updated.push(label);
+			apply(key, value);
+		} else plan.conflicts.push(`${label}\n    local:  ${JSON.stringify(mine)}\n    remote: ${JSON.stringify(value)}`);
+	}
+}
+function planPull(project, remote, force) {
+	const plan = {
+		added: [],
+		updated: [],
+		conflicts: [],
+		apply: []
+	};
+	for (const [code, tree] of Object.entries(remote)) {
+		if (!project.codes.includes(code) || !isObject(tree)) {
+			log.warn(`Skipping remote locale ${code}: not a configured locale.`);
+			continue;
+		}
+		planLocale(project, code, tree, force, plan);
+	}
+	return plan;
+}
+async function pull(args, project, config) {
+	const remote = await requestJson(remoteUrl(config), requestOptions(config));
+	if (!isObject(remote)) throw remoteConfigError("Invalid response from the remote: expected an object of locales.");
+	const plan = planPull(project, remote, Boolean(args.force));
+	log.list("New", plan.added);
+	log.list("Replaced", plan.updated);
+	log.list("Conflicts", plan.conflicts);
+	if (args.dryRun) {
+		log.note(`Dry run: ${plan.added.length} new, ${plan.updated.length} replaced, ${plural(plan.conflicts.length, "conflict")}. Nothing was written.`);
+		return;
+	}
+	if (plan.conflicts.length > 0) throw findingsError("Conflicts found between local and remote translations. Nothing was written.", ["Resolve them. --force takes the remote value where two values differ; a blocked path needs one of the two keys removed.", "Preview without writing: i18n-micro sync-remote --dryRun"]);
+	for (const [code, key, value] of plan.apply) project.locale(code).set(key, value);
+	project.save();
+	log.success(`Pulled ${plan.added.length} new and ${plan.updated.length} replaced ${pick(plan.added.length + plan.updated.length, "value", "values")}.`);
+}
+/** A blank local value is a gap, not a text: pushed, it could clear what a translator wrote. */
+function withoutBlanks(tree) {
+	const entries = Object.entries(tree).flatMap(([key, value]) => {
+		if (value === "") return [];
+		return [[key, isObject(value) ? withoutBlanks(value) : value]];
+	});
+	return Object.fromEntries(entries);
+}
+/** What the endpoint holds. A 404 is an endpoint nothing was pushed to yet. */
+async function remoteDocument(config, options) {
+	const remote = await requestJson(remoteUrl(config), options).catch((error) => {
+		if (error instanceof CliError && error.details["HTTP status"] === "404") return void 0;
+		throw error;
+	});
+	if (remote !== void 0 && !isObject(remote)) throw remoteConfigError("Invalid response from the remote: expected an object of locales.");
+	return remote ?? {};
+}
+/** A PUT replaces the document, so this text would be gone: it is on the remote, and not in what goes up or in any layer. */
+function lostOnPush(project, remote, body) {
+	return Object.entries(remote).flatMap(([code, tree]) => {
+		if (!isObject(tree)) return [];
+		const local = project.codes.includes(code) ? project.locale(code).global : {};
+		return Object.entries(flatten(tree)).filter(([key, value]) => value !== "" && getPath(body[code] ?? {}, key) === void 0 && JSON.stringify(value) !== JSON.stringify(getPath(local, key))).map(([key]) => `${code} ${key}`);
+	});
+}
+async function push(args, project, config) {
+	if (args.dryRun) {
+		log.note(`Dry run: would push ${project.codes.join(", ")}. Nothing was sent.`);
+		return;
+	}
+	const body = Object.fromEntries(project.codes.map((code) => [code, withoutBlanks(project.locale(code).fileTree(""))]));
+	const options = requestOptions(config);
+	if (!args.force) {
+		const lost = lostOnPush(project, await remoteDocument(config, options), body);
+		log.list("Only on the remote", lost);
+		if (lost.length > 0) throw findingsError("A push would drop this text. Nothing was sent.", ["Pull it first, or overwrite it with --force."]);
+	}
+	await requestJson(remoteUrl(config), {
+		...options,
+		method: "PUT",
+		...jsonBody(body),
+		headers: {
+			...options.headers,
+			"Content-Type": "application/json"
+		}
+	});
+	log.success(`Pushed ${plural(project.codes.length, "locale")}.`);
+}
+async function run(args) {
+	const project = await Project.load(args);
+	const config = loadConfig(project.config.rootDir);
+	const pages = new Set(project.codes.flatMap((code) => project.locale(code).pageScopes)).size;
+	if (pages > 0) log.warn(`Global files only: ${plural(pages, "page scope")} ${pick(pages, "is", "are")} not exchanged.`);
+	if (args.pull) await pull(args, project, config);
+	if (args.push) await push(args, project, config);
+}
+export { run as default, planPull };

package/dist/chunks/text-to-i18n-DweavFLm.mjs

@@ -0,0 +1,404 @@
+import { A as log, E as choose, M as plural, S as validationError, T as ask, a as flattenStrings, f as pathConflict, p as setPath, u as isWritableKey, v as notFoundError, x as usageError } from "./json-BV_apCMu.mjs";
+import { a as readJsonIfExists, d as splitList, g as writeFilesAtomic, l as readUtf8, p as stringifyLike, r as isUnder, t as loadProjectConfig, u as relativePath } from "./nuxt-dKxG087V.mjs";
+import { a as isTestFile, c as projectFiles, d as staticString, i as isOwnSource, l as scanFile, o as lineOf, r as isCodeFile, s as parseCode, t as NODE_TYPES } from "./source-Bx2lHSW7.mjs";
+import { forwardSlashes } from "@i18n-micro/utils/app-path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join, parse, resolve } from "node:path";
+import { MagicString, parse as parse$1, walk } from "@vue/compiler-sfc";
+// src/text-to-i18n.ts
+var TEXT_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"title",
+	"label",
+	"placeholder",
+	"alt",
+	"aria-label"
+]);
+var NON_TEXT_CALLS = /* @__PURE__ */ new Set([
+	"emit",
+	"$emit",
+	"useFetch",
+	"$fetch",
+	"useAsyncData",
+	"definePageMeta",
+	"defineProps",
+	"defineEmits",
+	"navigateTo",
+	"useRoute",
+	"import",
+	"require"
+]);
+var SKIPPED_PARENTS = /* @__PURE__ */ new Set([
+	"ImportDeclaration",
+	"ExportNamedDeclaration",
+	"ExportAllDeclaration",
+	"TSLiteralType",
+	"TSEnumMember",
+	"TSExternalModuleReference"
+]);
+var NON_DISPLAY_TAGS = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"code",
+	"pre"
+]);
+var KEY_ROOTS = [
+	"pages",
+	"components",
+	"plugins",
+	"layouts"
+];
+var CYRILLIC = {
+	а: "a",
+	б: "b",
+	в: "v",
+	г: "g",
+	д: "d",
+	е: "e",
+	ё: "e",
+	ж: "zh",
+	з: "z",
+	и: "i",
+	й: "y",
+	к: "k",
+	л: "l",
+	м: "m",
+	н: "n",
+	о: "o",
+	п: "p",
+	р: "r",
+	с: "s",
+	т: "t",
+	у: "u",
+	ф: "f",
+	х: "h",
+	ц: "ts",
+	ч: "ch",
+	ш: "sh",
+	щ: "sch",
+	ъ: "",
+	ы: "y",
+	ь: "",
+	э: "e",
+	ю: "yu",
+	я: "ya"
+};
+function toSlug(text) {
+	return text.replace(/\p{Script=Cyrillic}/gu, (letter) => CYRILLIC[letter.toLowerCase()] ?? letter).replaceAll("&", " and ").replaceAll("$", " dollar ").replaceAll("%", " percent ").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var keywordsOf = (text) => text.replace(/[.,/#!$%^&*;:{}=\-_`~()]/g, " ").split(/\s+/).filter((word) => word.length >= 2).slice(0, 3);
+/** `pages/blog/index.vue` -> `pages.blog.index`: keys say where their text came from. */
+function filePrefix(file) {
+	const { dir, name } = parse(file);
+	const segments = forwardSlashes(dir).split("/");
+	const rootIndex = segments.findIndex((segment) => KEY_ROOTS.includes(segment));
+	if (rootIndex === -1) return "common";
+	return [...segments.slice(rootIndex), name].map(toSlug).join(".");
+}
+/** Shared across files: known text reuses its key, generated keys stay unique. */
+var KeyRegistry = class {
+	options;
+	created = /* @__PURE__ */ new Map();
+	/** Text left alone because its key would overwrite a value of the translation file. */
+	blocked = [];
+	byText = /* @__PURE__ */ new Map();
+	used;
+	/** The file with this run's keys in it: `pages.user` and `pages.user.save` cannot both be text. */
+	planned;
+	constructor(existing, tree = {}, options = {}) {
+		this.options = options;
+		this.planned = structuredClone(tree);
+		this.used = new Set(Object.keys(existing));
+		for (const [key, value] of Object.entries(existing)) this.byText.set(value, key);
+	}
+	generate(text, file) {
+		const slug = toSlug(keywordsOf(text).join(" ")) || toSlug(text.slice(0, 40)) || `key-${this.used.size + 1}`;
+		const base = [
+			filePrefix(file),
+			this.options.context,
+			slug
+		].filter(Boolean).join(".");
+		let key = base;
+		for (let counter = 1; this.used.has(key); counter += 1) key = `${base}_${counter}`;
+		this.used.add(key);
+		return key;
+	}
+	block(text, file, line) {
+		this.byText.set(text, "");
+		this.blocked.push({
+			file,
+			line,
+			text
+		});
+		return null;
+	}
+	/** Key for `text`, or `null` when it stays as it is. */
+	keyFor(text, file, line) {
+		const known = this.byText.get(text);
+		if (known === "") return null;
+		if (known !== void 0) return isWritableKey(known) ? known : this.block(text, file, line);
+		const generated = this.generate(text, file);
+		if (this.options.skippedKeys?.includes(generated)) {
+			this.byText.set(text, "");
+			return null;
+		}
+		const key = this.options.keyOverrides?.[generated] ?? generated;
+		if (pathConflict(this.planned, key)) return this.block(text, file, line);
+		setPath(this.planned, key, text);
+		this.created.set(key, {
+			key,
+			value: text,
+			file,
+			line
+		});
+		this.byText.set(text, key);
+		return key;
+	}
+	/** Take back keys of a conversion that was thrown away. */
+	forget(keep) {
+		for (const [key, { value }] of this.created) {
+			if (keep.has(key)) continue;
+			this.created.delete(key);
+			this.byText.delete(value);
+		}
+	}
+};
+var hasInterpolation = (text) => /\{\{[^}]*\}\}|\$\{/.test(text);
+var isTranslatable = (text) => /\p{L}/u.test(text) && !hasInterpolation(text);
+/** Identifiers, paths, URLs: data that happens to be a string. */
+function isTechnical(value) {
+	const text = value.trim();
+	if (text.includes("://")) return true;
+	if (/\s/.test(text)) return false;
+	return /^[./]/.test(text) || /^[a-z0-9_.:-]+$/.test(text) || /^[A-Z0-9_.-]+$/.test(text);
+}
+/** The compiler's text: entities decoded, so `&` does not reach the locale file as five characters. */
+var displayText = (node) => (node.content ?? "").replace(/\s+/g, " ").trim();
+function convertTextNode(node, run) {
+	const text = displayText(node);
+	if (!isTranslatable(text)) return;
+	const source = node.loc.source;
+	const start = node.loc.start.offset + (source.length - source.trimStart().length);
+	const key = run.keys.keyFor(text, run.file, lineOf(run.content, start));
+	if (key) run.magic.overwrite(start, start + source.trim().length, `{{ $t('${key}') }}`);
+}
+/** `title="x" :title="y"`: binding the first would make the attribute a duplicate. */
+var isBound = (element, name) => Boolean(element.props?.some((prop) => prop.type === NODE_TYPES.DIRECTIVE && prop.arg?.content === name));
+function convertAttribute(prop, element, run) {
+	const text = prop.value?.content;
+	if (prop.type !== NODE_TYPES.ATTRIBUTE || !text || !TEXT_ATTRIBUTES.has(prop.name ?? "") || !isTranslatable(text)) return;
+	if (isBound(element, prop.name)) return;
+	const key = run.keys.keyFor(text, run.file, lineOf(run.content, prop.loc.start.offset));
+	if (key) run.magic.overwrite(prop.loc.start.offset, prop.loc.end.offset, `:${prop.name}="$t('${key}')"`);
+}
+var isBlank = (node) => node.type === NODE_TYPES.COMMENT || node.type === NODE_TYPES.TEXT && displayText(node) === "";
+/** Text next to markup or an interpolation: `<p>Hello <b>world</b> today</p>`. */
+var isMixed = (children) => {
+	const present = children.filter((child) => !isBlank(child));
+	return present.some((child) => child.type === NODE_TYPES.TEXT) && present.some((child) => child.type !== NODE_TYPES.TEXT);
+};
+var isSkippedElement = (node) => NON_DISPLAY_TAGS.has(node.tag ?? "") || /^i18n-?t$/i.test(node.tag ?? "") || /^<[^>]*\sv-pre[\s/>]/.test(node.loc.source);
+function reportMixed(node, run) {
+	const text = displayText({
+		...node,
+		content: node.loc.source.replace(/<[^>]*>/g, " ")
+	});
+	if (isTranslatable(text.replace(/\{\{[^}]*\}\}/g, ""))) run.out.mixed.push({
+		file: run.file,
+		line: lineOf(run.content, node.loc.start.offset),
+		text
+	});
+}
+function convertTemplate(node, run, textAllowed = true) {
+	if (node.type === NODE_TYPES.ELEMENT) {
+		if (isSkippedElement(node)) return;
+		for (const prop of node.props ?? []) convertAttribute(prop, node, run);
+	}
+	const children = node.children ?? [];
+	const mixed = isMixed(children);
+	if (mixed && textAllowed) reportMixed(node, run);
+	for (const child of children) if (child.type !== NODE_TYPES.TEXT) convertTemplate(child, run, textAllowed && !mixed);
+	else if (textAllowed && !mixed) convertTextNode(child, run);
+}
+function calleeName(call) {
+	const callee = call.callee;
+	return String(callee.name ?? callee.property?.name ?? callee.type);
+}
+function isDataLiteral(node, parent, key) {
+	if (!parent) return false;
+	if (SKIPPED_PARENTS.has(parent.type)) return true;
+	if (parent.type === "ObjectProperty" && key === "key" && !parent.computed) return true;
+	if (parent.type === "MemberExpression" && key === "property") return true;
+	if (parent.type === "BinaryExpression" || parent.type === "TaggedTemplateExpression") return true;
+	if (parent.type === "JSXAttribute") return true;
+	if (parent.type !== "CallExpression" && parent.type !== "OptionalCallExpression" && parent.type !== "NewExpression") return false;
+	return NON_TEXT_CALLS.has(calleeName(parent)) || node === parent.callee;
+}
+/** Text a person would read, in code. The strings the scanner took for keys or arguments of `$t` are not. */
+function reportCode(content, file, lang = extname(file).slice(1), firstLine = 1) {
+	const ast = parseCode(content, lang);
+	if (!ast) return [];
+	const found = [];
+	const keyArguments = new Set(scanFile(content, `${file}.${lang}`).refs.map((ref) => ref.start - 1));
+	walk(ast, { enter(raw, parent, key) {
+		const node = raw;
+		const text = node.type === "JSXText" ? node.value.trim() : staticString(node);
+		if (!text || !isTranslatable(text) || isTechnical(text) || keyArguments.has(node.start)) return;
+		if (!isDataLiteral(node, parent, key)) found.push({
+			file,
+			line: lineOf(content, node.start) + firstLine - 1,
+			text
+		});
+	} });
+	return found;
+}
+function convertVue(content, file, keys) {
+	const out = {
+		content,
+		mixed: [],
+		code: []
+	};
+	if (content.trim() === "") return out;
+	const { descriptor, errors } = parse$1(content, { filename: file });
+	if (errors.length > 0) throw new Error(`it does not parse: ${String(errors[0].message)}`);
+	out.code = [descriptor.script, descriptor.scriptSetup].flatMap((block) => block ? reportCode(block.content, file, block.lang ?? "js", block.loc.start.line) : []);
+	const ast = descriptor.template?.ast;
+	if (!ast) return out;
+	const before = new Set(keys.created.keys());
+	const run = {
+		magic: new MagicString(content),
+		keys,
+		file,
+		content,
+		out
+	};
+	convertTemplate({
+		...ast,
+		loc: descriptor.template.loc
+	}, run);
+	const converted = run.magic.toString();
+	if (parse$1(converted, { filename: file }).errors.length > 0) {
+		keys.forget(before);
+		throw new Error("the rewritten file would not parse");
+	}
+	out.content = converted;
+	return out;
+}
+/** One source file: `.vue` templates are rewritten, anything else is only read. */
+function convertSource(content, file, keys) {
+	if (extname(file).toLowerCase() === ".vue") return convertVue(content, file, keys);
+	return {
+		content,
+		mixed: [],
+		code: reportCode(content, file)
+	};
+}
+// src/commands/text-to-i18n.ts
+var VALID_KEY = /^[\p{L}\p{N}_.-]+$/u;
+/** A layer or an alias target serves other apps too, and the new keys would land in this one only. */
+function ownFiles(config, files) {
+	const own = files.filter((file) => isOwnSource(config, file));
+	if (own.length < files.length) log.warn(`Left ${plural(files.length - own.length, "file")} of layers and folders outside the project alone.`);
+	return own;
+}
+function filesToProcess(config, args) {
+	const sources = projectFiles(config, { ignore: splitList(args.ignore) }).filter((file) => isCodeFile(file) && !isTestFile(config, file) && !/\bnuxt\.config\.\w+$/.test(file));
+	if (!args.path) return sources;
+	const target = resolve(config.rootDir, args.path);
+	if (!existsSync(target)) throw notFoundError(`Path does not exist: ${target}`);
+	if (statSync(target).isDirectory()) return sources.filter((file) => isUnder(target, file));
+	if (!isCodeFile(target)) throw validationError(`Unsupported file type: ${target}`, ["Supported: .vue, .js, .ts, .jsx, .tsx"]);
+	return [target];
+}
+function convertAll(files, args, tree, decisions) {
+	const keys = new KeyRegistry(flattenStrings(tree), tree, {
+		context: args.context,
+		...decisions
+	});
+	const changes = [];
+	const conversions = [];
+	for (const file of files) try {
+		const content = readUtf8(file);
+		const conversion = convertSource(content, file, keys);
+		conversions.push(conversion);
+		if (conversion.content !== content) changes.push([file, conversion.content]);
+	} catch (error) {
+		log.warn(`Skipping ${file}: ${error.message}`);
+	}
+	return {
+		changes,
+		created: keys.created,
+		mixed: conversions.flatMap((item) => item.mixed),
+		code: conversions.flatMap((item) => item.code),
+		blocked: keys.blocked
+	};
+}
+async function askDecision(entry, decisions, reserved) {
+	log.info(`\n[${entry.file}:${entry.line}] "${entry.value}" -> ${entry.key}`);
+	const action = await choose("Action", [
+		"accept",
+		"edit",
+		"skip"
+	]);
+	if (!action) throw usageError("No answer: stopping without changing anything.");
+	if (action === "skip") {
+		decisions.skippedKeys.push(entry.key);
+		reserved.delete(entry.key);
+		return;
+	}
+	if (action !== "edit") return;
+	const edited = await ask(`New key for "${entry.value}":`);
+	if (!edited || edited === entry.key) return;
+	if (reserved.has(edited) || !VALID_KEY.test(edited) || !isWritableKey(edited)) {
+		log.warn(`Key "${edited}" is taken or not a valid key; keeping ${entry.key}.`);
+		return;
+	}
+	decisions.keyOverrides[entry.key] = edited;
+	reserved.delete(entry.key);
+	reserved.add(edited);
+}
+async function collectDecisions(created, existing) {
+	const decisions = {
+		keyOverrides: {},
+		skippedKeys: []
+	};
+	const reserved = /* @__PURE__ */ new Set([...created.keys(), ...Object.keys(existing)]);
+	for (const entry of created.values()) await askDecision(entry, decisions, reserved);
+	return decisions;
+}
+function report(title, items, rootDir) {
+	log.list(title, items.map(({ file, line, text }) => [`${relativePath(rootDir, file)}:${line}`, text]));
+}
+async function run(args) {
+	const config = await loadProjectConfig(args.cwd ?? ".");
+	const translationFile = args.translationFile ? resolve(config.rootDir, args.translationFile) : join(config.translationDir, `${config.defaultLocale}.json`);
+	const translations = readJsonIfExists(translationFile);
+	const files = ownFiles(config, filesToProcess(config, args));
+	let result = convertAll(files, args, translations, {
+		keyOverrides: {},
+		skippedKeys: []
+	});
+	if (args.interactive && result.created.size > 0) result = convertAll(files, args, translations, await collectDecisions(result.created, flattenStrings(translations)));
+	log.note(`Found ${plural(files.length, "file")} to process.`);
+	report("Mixed text, not rewritten: wrap the sentence in one key by hand", result.mixed, config.rootDir);
+	report("Text in code, not rewritten: `$t` may not be in scope there", result.code, config.rootDir);
+	report("Skipped: the key would overwrite a value, or cannot be written in a template", result.blocked, config.rootDir);
+	if (result.created.size === 0 && result.changes.length === 0) {
+		log.note("No new translations found.");
+		return;
+	}
+	log.note(`Found ${plural(result.created.size, "new translation")}.`);
+	if (args.dryRun) {
+		log.list("Would add", [...result.created.values()].map(({ key, value, file, line }) => [
+			key,
+			`"${value}"`,
+			`${relativePath(config.rootDir, file)}:${line}`
+		]));
+		log.note("Dry run: no files were modified.");
+		return;
+	}
+	for (const { key, value } of result.created.values()) setPath(translations, key, value);
+	const previous = existsSync(translationFile) ? readFileSync(translationFile, "utf8") : void 0;
+	writeFilesAtomic([...result.changes, [translationFile, stringifyLike(previous, translations)]]);
+	log.success(`Updated ${plural(result.changes.length, "file")} and ${relativePath(config.rootDir, translationFile)}.`);
+}
+export { run as default };