@mmstack/translate-tools 1.0.0

package/commands-yoWN-Tne.mjs

@@ -0,0 +1,722 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Node, Project, SyntaxKind } from "ts-morph";
+import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
+//#region src/lib/identifier.ts
+/** A bare (unquoted) JavaScript identifier — used by both codegen and registry insertion to decide
+* whether an object key / locale must be string-quoted. Kept in one place so the two emit paths
+* can't disagree on quoting. */
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function isIdentifier(value) {
+	return IDENTIFIER.test(value);
+}
+/** Best-effort valid identifier derived from an arbitrary name (e.g. a namespace). */
+function toIdentifier(name) {
+	const cleaned = name.replace(/[^A-Za-z0-9_$]/g, "");
+	if (!cleaned) return "source";
+	return isIdentifier(cleaned) ? cleaned : `ns${cleaned}`;
+}
+//#endregion
+//#region src/lib/nested.ts
+/** Serialize a nested translation tree to a JSON file body (one namespace, one locale). */
+function toJson(nested) {
+	return JSON.stringify(nested, null, 2) + "\n";
+}
+/** Parse + validate a nested translation JSON file back into a {@link NestedTranslation}. */
+function fromJson(json) {
+	const parsed = JSON.parse(json);
+	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Translation JSON must be a plain object.");
+	return validate(parsed, "");
+}
+/** Walk a tree's string leaves, yielding `[dottedPath, message]` for each (used for validation). */
+function leafEntries(nested, prefix = "") {
+	const out = [];
+	for (const [key, value] of Object.entries(nested)) {
+		const at = prefix ? `${prefix}.${key}` : key;
+		if (typeof value === "string") out.push([at, value]);
+		else out.push(...leafEntries(value, at));
+	}
+	return out;
+}
+/** A flat `Map<dottedPath, message>` view of a tree, for key-by-key comparison. */
+function leafMap(nested) {
+	return new Map(leafEntries(nested));
+}
+function validate(value, path) {
+	for (const [key, child] of Object.entries(value)) {
+		const at = path ? `${path}.${key}` : key;
+		if (typeof child === "string") continue;
+		if (child !== null && typeof child === "object" && !Array.isArray(child)) {
+			validate(child, at);
+			continue;
+		}
+		throw new Error(`Invalid translation value at "${at}": expected a string or a nested object.`);
+	}
+	return value;
+}
+//#endregion
+//#region src/lib/codegen.ts
+function key(k) {
+	return isIdentifier(k) ? k : JSON.stringify(k);
+}
+/**
+* Serialize a nested translation tree to a TypeScript object-literal string. Double-quoted via
+* `JSON.stringify`: correct escaping for ICU (which uses `'` for its own escaping, so single-quoting
+* would be unsafe). A consumer's formatter normalizes quote style/indentation on save.
+*/
+function objectLiteralText(obj, depth = 1) {
+	const entries = Object.entries(obj);
+	if (entries.length === 0) return "{}";
+	const inner = "  ".repeat(depth + 1);
+	const pad = "  ".repeat(depth);
+	return `{\n${entries.map(([k, value]) => {
+		const v = typeof value === "string" ? JSON.stringify(value) : objectLiteralText(value, depth + 1);
+		return `${inner}${key(k)}: ${v},`;
+	}).join("\n")}\n${pad}}`;
+}
+/**
+* Emit a target-locale TypeScript module that calls `createTranslation` on the source namespace —
+* the TS-first import format. The output is valid TS that round-trips through {@link liftObjectLiteral}.
+*/
+function codegenTranslationFile(input) {
+	return `import ${input.defaultImport ? input.namespaceVar : `{ ${input.namespaceVar} }`} from ${JSON.stringify(input.importPath)};\n\nexport const ${input.exportName} = ${input.namespaceVar}.createTranslation(\n  ${JSON.stringify(input.locale)},\n  ${objectLiteralText(input.translation, 1)},\n);\n`;
+}
+//#endregion
+//#region src/lib/lift.ts
+/**
+* Statically lift a `createNamespace`/`createTranslation` translation object literal into a plain
+* {@link NestedTranslation} — no code execution. String leaves and nested objects pass through;
+* `withParams<…>('msg')` is unwrapped to its message string (the type arg is compile-time only and
+* irrelevant to the round-trip). Anything dynamic (a variable, a concatenation, a spread) throws —
+* the author must inline a literal for the tool to round-trip it.
+*/
+function liftObjectLiteral(obj) {
+	const out = {};
+	for (const prop of obj.getProperties()) {
+		if (!Node.isPropertyAssignment(prop)) throw new Error(`Unsupported entry in translation object (only "key: value" is supported): ${prop.getText()}`);
+		out[propKey(prop.getNameNode())] = liftValue(prop.getInitializerOrThrow());
+	}
+	return out;
+}
+function propKey(name) {
+	if (Node.isStringLiteral(name) || Node.isNoSubstitutionTemplateLiteral(name)) return name.getLiteralText();
+	if (Node.isIdentifier(name)) return name.getText();
+	throw new Error(`Unsupported translation key: ${name.getText()}`);
+}
+function liftValue(node) {
+	if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) return node.getLiteralText();
+	if (Node.isObjectLiteralExpression(node)) return liftObjectLiteral(node);
+	if (Node.isCallExpression(node)) {
+		if (node.getExpression().getText() === "withParams") {
+			const arg = node.getArguments()[0];
+			if (arg && (Node.isStringLiteral(arg) || Node.isNoSubstitutionTemplateLiteral(arg))) return arg.getLiteralText();
+		}
+		throw new Error(`Unsupported call in a translation value (only withParams('literal') is supported): ${node.getText()}`);
+	}
+	throw new Error(`Unsupported translation value (expected a string literal, withParams('literal'), or a nested object): ${node.getText()}`);
+}
+//#endregion
+//#region src/lib/loader.ts
+/**
+* Parse a namespace loader into its import path + accessor chain, matching every shape
+* `@mmstack/translate` accepts at runtime:
+*   - `() => import('path').then((m) => m.a.b)` → `['a', 'b']`
+*   - `() => import('path').then((m) => m.default)` → `['default']`
+*   - `() => import('path')` (shorthand) → `[]` (default / translation auto-resolve)
+* Returns `null` for any other shape (async/await, computed access) — the caller warns and skips.
+*/
+function parseLoader(fn) {
+	const body = Node.isArrowFunction(fn) ? fn.getBody() : void 0;
+	if (!body || !Node.isCallExpression(body)) return null;
+	if (body.getExpression().getKind() === SyntaxKind.ImportKeyword) {
+		const pathArg = body.getArguments()[0];
+		if (!isPathLiteral(pathArg)) return null;
+		return {
+			importPath: pathArg.getLiteralText(),
+			accessor: []
+		};
+	}
+	const thenAccess = body.getExpression();
+	if (!Node.isPropertyAccessExpression(thenAccess) || thenAccess.getName() !== "then") return null;
+	const importCall = thenAccess.getExpression();
+	if (!Node.isCallExpression(importCall) || importCall.getExpression().getKind() !== SyntaxKind.ImportKeyword) return null;
+	const pathArg = importCall.getArguments()[0];
+	if (!isPathLiteral(pathArg)) return null;
+	const cb = body.getArguments()[0];
+	if (!cb || !Node.isArrowFunction(cb)) return null;
+	const accessor = accessorChain(cb.getBody());
+	if (!accessor) return null;
+	return {
+		importPath: pathArg.getLiteralText(),
+		accessor
+	};
+}
+function isPathLiteral(node) {
+	return !!node && (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node));
+}
+function accessorChain(node) {
+	const parts = [];
+	let cur = node;
+	while (Node.isPropertyAccessExpression(cur)) {
+		parts.unshift(cur.getName());
+		cur = cur.getExpression();
+	}
+	return Node.isIdentifier(cur) && parts.length > 0 ? parts : null;
+}
+//#endregion
+//#region src/lib/registry.ts
+/**
+* Find every `registerNamespace(...)` call in a source file. `registerRemoteNamespace` is
+* deliberately ignored — its translations are served, not authored in files, so there's nothing to
+* export or round-trip.
+*/
+function findRegisterNamespaceCalls(sf) {
+	return sf.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => call.getExpression().getText() === "registerNamespace");
+}
+function localeProperty(obj, locale) {
+	return obj.getProperties().find((p) => {
+		if (!Node.isPropertyAssignment(p)) return false;
+		const name = p.getNameNode();
+		return (Node.isStringLiteral(name) ? name.getLiteralText() : name.getText()) === locale;
+	});
+}
+/**
+* Insert (or replace) a locale's loader in a `registerNamespace(default, other)` call's `other`
+* map, so a freshly-imported locale is actually registered. Mutates the call in place — the caller
+* saves the source file afterwards.
+*/
+function addLocaleLoader(call, locale, importPath, exportName) {
+	if (call.getArguments().length < 2) call.addArgument("{}");
+	const other = call.getArguments()[1];
+	if (!other || !Node.isObjectLiteralExpression(other)) throw new Error("registerNamespace's second argument must be an object literal of locale loaders.");
+	localeProperty(other, locale)?.remove();
+	other.addPropertyAssignment({
+		name: isIdentifier(locale) ? locale : JSON.stringify(locale),
+		initializer: `() => import(${JSON.stringify(importPath)}).then((m) => m.${exportName})`
+	});
+}
+//#endregion
+//#region src/lib/discover.ts
+/** Discover every `registerNamespace` registry in a ts-morph project and lift its translations. */
+function discoverFromProject(project, options = {}) {
+	const sourceLocale = options.sourceLocale ?? "en";
+	const warn = options.onWarn ?? (() => void 0);
+	const out = [];
+	for (const sf of project.getSourceFiles()) findRegisterNamespaceCalls(sf).forEach((call, index) => {
+		const found = discoverCall(project, sf, call, index, sourceLocale, warn);
+		if (found) out.push(found);
+	});
+	return out;
+}
+function discoverCall(project, registryFile, call, registryCallIndex, sourceLocale, warn) {
+	const defaultArg = call.getArguments()[0];
+	if (!defaultArg || !Node.isArrowFunction(defaultArg)) {
+		warn(`registerNamespace default loader is not an arrow function in ${registryFile.getFilePath()}`);
+		return null;
+	}
+	const parsedDefault = parseLoader(defaultArg);
+	if (!parsedDefault) {
+		warn(`Unsupported default loader shape in ${registryFile.getFilePath()}`);
+		return null;
+	}
+	const resolvedDefault = resolveExport(project, registryFile, parsedDefault, warn);
+	if (!resolvedDefault || resolvedDefault.kind !== "namespace" || !resolvedDefault.namespace) {
+		warn(`Could not resolve namespace from default loader in ${registryFile.getFilePath()}`);
+		return null;
+	}
+	const locales = [];
+	const other = call.getArguments()[1];
+	if (other && Node.isObjectLiteralExpression(other)) for (const prop of other.getProperties()) {
+		if (!Node.isPropertyAssignment(prop)) continue;
+		const locale = nameText(prop.getNameNode());
+		const init = prop.getInitializer();
+		if (!init || !Node.isArrowFunction(init)) {
+			warn(`Locale "${locale}" loader is not an arrow function`);
+			continue;
+		}
+		const parsed = parseLoader(init);
+		if (!parsed) {
+			warn(`Unsupported loader shape for locale "${locale}"`);
+			continue;
+		}
+		const resolved = resolveExport(project, registryFile, parsed, warn);
+		if (!resolved) continue;
+		locales.push({
+			locale,
+			moduleFilePath: resolved.moduleFilePath,
+			exportName: resolved.exportName,
+			isDefaultExport: resolved.isDefaultExport,
+			translation: resolved.translation
+		});
+	}
+	return {
+		namespace: resolvedDefault.namespace,
+		registryFilePath: registryFile.getFilePath(),
+		registryCallIndex,
+		source: {
+			locale: sourceLocale,
+			moduleFilePath: resolvedDefault.moduleFilePath,
+			exportName: resolvedDefault.exportName,
+			isDefaultExport: resolvedDefault.isDefaultExport,
+			translation: resolvedDefault.translation
+		},
+		locales
+	};
+}
+function resolveExport(project, fromFile, parsed, warn) {
+	const moduleFile = resolveModule(project, fromFile.getFilePath(), parsed.importPath);
+	if (!moduleFile) {
+		warn(`Cannot resolve module "${parsed.importPath}" from ${fromFile.getFilePath()}`);
+		return null;
+	}
+	const target = resolveLoaderTarget(moduleFile, parsed.accessor);
+	if (!target) {
+		warn(`Could not resolve a ${parsed.accessor[0] ? `export "${parsed.accessor[0]}"` : "default/translation export"} in ${moduleFile.getFilePath()}`);
+		return null;
+	}
+	const { call: init, isDefaultExport } = target;
+	const callee = init.getExpression();
+	const base = {
+		moduleFilePath: moduleFile.getFilePath(),
+		isDefaultExport
+	};
+	const isCreateNamespace = Node.isIdentifier(callee) && callee.getText() === "createNamespace";
+	const isMergedNamespace = Node.isPropertyAccessExpression(callee) && callee.getName() === "createMergedNamespace";
+	if (isCreateNamespace || isMergedNamespace) {
+		const ns = stringArg(init, 0);
+		const lit = objArg(init, 1);
+		if (ns === null || !lit) return null;
+		return {
+			kind: "namespace",
+			namespace: ns,
+			translation: liftObjectLiteral(lit),
+			exportName: target.bindingName || toIdentifier(ns),
+			...base
+		};
+	}
+	if (Node.isPropertyAccessExpression(callee) && callee.getName() === "createTranslation") {
+		const lit = objArg(init, 1);
+		if (!lit) return null;
+		return {
+			kind: "translation",
+			translation: liftObjectLiteral(lit),
+			exportName: target.bindingName || "translation",
+			...base
+		};
+	}
+	warn(`Export in ${moduleFile.getFilePath()} is not a createNamespace/createMergedNamespace/createTranslation call`);
+	return null;
+}
+/** Map a parsed loader accessor to the `create*` call it resolves to, matching the same
+* default / translation auto-resolution `@mmstack/translate` does at runtime. */
+function resolveLoaderTarget(moduleFile, accessor) {
+	if (accessor.length > 0 && accessor[0] !== "default") {
+		const call = variableCall(moduleFile, accessor[0]);
+		return call ? {
+			call,
+			bindingName: accessor[0],
+			isDefaultExport: false
+		} : null;
+	}
+	const fromDefault = defaultExportCall(moduleFile);
+	if (fromDefault) return fromDefault;
+	if (accessor.length === 0) {
+		const call = variableCall(moduleFile, "translation");
+		if (call) return {
+			call,
+			bindingName: "translation",
+			isDefaultExport: false
+		};
+	}
+	return null;
+}
+function variableCall(moduleFile, name) {
+	const init = moduleFile.getVariableDeclaration(name)?.getInitializer();
+	return init && Node.isCallExpression(init) ? init : null;
+}
+function defaultExportCall(moduleFile) {
+	const assignment = moduleFile.getExportAssignment((a) => !a.isExportEquals());
+	if (!assignment) return null;
+	const expr = assignment.getExpression();
+	if (Node.isIdentifier(expr)) {
+		const call = variableCall(moduleFile, expr.getText());
+		return call ? {
+			call,
+			bindingName: expr.getText(),
+			isDefaultExport: true
+		} : null;
+	}
+	if (Node.isCallExpression(expr)) return {
+		call: expr,
+		bindingName: "",
+		isDefaultExport: true
+	};
+	return null;
+}
+function resolveModule(project, fromFilePath, importPath) {
+	const base = path.resolve(path.dirname(fromFilePath), importPath);
+	for (const candidate of [
+		base,
+		`${base}.ts`,
+		path.join(base, "index.ts")
+	]) {
+		const sf = project.getSourceFile(candidate);
+		if (sf) return sf;
+	}
+}
+function stringArg(call, index) {
+	const arg = call.getArguments()[index];
+	return arg && (Node.isStringLiteral(arg) || Node.isNoSubstitutionTemplateLiteral(arg)) ? arg.getLiteralText() : null;
+}
+function objArg(call, index) {
+	const arg = call.getArguments()[index];
+	return arg && Node.isObjectLiteralExpression(arg) ? arg : void 0;
+}
+function nameText(node) {
+	return Node.isStringLiteral(node) ? node.getLiteralText() : node.getText();
+}
+//#endregion
+//#region src/lib/icu.ts
+/** Validate an ICU message string; returns the parser's error message when invalid. */
+function validateMessage(message) {
+	try {
+		parse(message);
+		return { ok: true };
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+/**
+* Collect every argument/placeholder name an ICU message references, including names nested inside
+* plural/select options and tag children (e.g. `{count, plural, one {# by {author}} ...}` → count,
+* author). Throws if the message is not valid ICU — call {@link validateMessage} first.
+*/
+function extractPlaceholders(message) {
+	const names = /* @__PURE__ */ new Set();
+	const walk = (elements) => {
+		for (const el of elements) switch (el.type) {
+			case TYPE.argument:
+			case TYPE.number:
+			case TYPE.date:
+			case TYPE.time:
+				names.add(el.value);
+				break;
+			case TYPE.select:
+			case TYPE.plural:
+				names.add(el.value);
+				for (const opt of Object.values(el.options)) walk(opt.value);
+				break;
+			case TYPE.tag:
+				names.add(el.value);
+				walk(el.children);
+				break;
+			default: break;
+		}
+	};
+	walk(parse(message));
+	return names;
+}
+/**
+* Check a translated message references exactly the same placeholders as its source — the common
+* way a translation silently breaks (a dropped `{name}`, or a renamed one). `missing` are present in
+* the source but not the target; `extra` are in the target but not the source.
+*/
+function placeholderParity(source, target) {
+	const s = extractPlaceholders(source);
+	const t = extractPlaceholders(target);
+	const missing = [...s].filter((name) => !t.has(name));
+	const extra = [...t].filter((name) => !s.has(name));
+	if (missing.length === 0 && extra.length === 0) return { ok: true };
+	return {
+		ok: false,
+		missing,
+		extra
+	};
+}
+//#endregion
+//#region src/lib/update.ts
+/**
+* Replace the translation object of an existing `createTranslation(...)` call in place (used when
+* re-importing a locale that already exists), preserving the rest of the file. Returns `false` if
+* the export/call can't be found. The file is re-formatted so the replacement indents cleanly.
+*/
+function replaceTranslationLiteral(project, filePath, exportName, translation) {
+	const sf = project.getSourceFile(filePath);
+	const init = sf?.getVariableDeclaration(exportName)?.getInitializer();
+	if (!init || !Node.isCallExpression(init)) return false;
+	const arg = init.getArguments()[1];
+	if (!arg) return false;
+	arg.replaceWithText(objectLiteralText(translation, 1));
+	sf?.formatText();
+	return true;
+}
+//#endregion
+//#region src/lib/commands.ts
+/** Plan the per-namespace, per-locale JSON files to write (source locale + every target locale). */
+function planExport(namespaces) {
+	const files = [];
+	for (const ns of namespaces) {
+		files.push({
+			fileName: `${ns.namespace}.${ns.source.locale}.json`,
+			content: toJson(ns.source.translation)
+		});
+		for (const loc of ns.locales) files.push({
+			fileName: `${ns.namespace}.${loc.locale}.json`,
+			content: toJson(loc.translation)
+		});
+	}
+	return files;
+}
+/** Validate an incoming translation: every leaf is valid ICU, and placeholders match the source. */
+function validateImport(translation, source) {
+	const issues = [];
+	const src = leafMap(source);
+	const present = /* @__PURE__ */ new Set();
+	for (const [key, message] of leafEntries(translation)) {
+		present.add(key);
+		const valid = validateMessage(message);
+		if (!valid.ok) {
+			issues.push({
+				key,
+				message: `invalid ICU — ${valid.error}`
+			});
+			continue;
+		}
+		const sourceMessage = src.get(key);
+		if (sourceMessage === void 0) {
+			issues.push({
+				key,
+				message: "unknown key (not in the source) — remove it"
+			});
+			continue;
+		}
+		const sourceValid = validateMessage(sourceMessage);
+		if (!sourceValid.ok) {
+			issues.push({
+				key,
+				message: `source message is invalid ICU — ${sourceValid.error}`
+			});
+			continue;
+		}
+		const parity = placeholderParity(sourceMessage, message);
+		if (!parity.ok) {
+			const parts = [];
+			if (parity.missing.length) parts.push(`missing ${parity.missing.join(", ")}`);
+			if (parity.extra.length) parts.push(`unexpected ${parity.extra.join(", ")}`);
+			issues.push({
+				key,
+				message: `placeholder mismatch (${parts.join("; ")})`
+			});
+		}
+	}
+	for (const key of src.keys()) if (!present.has(key)) issues.push({
+		key,
+		message: "missing key"
+	});
+	return issues;
+}
+/**
+* Apply one imported locale to the project: update the existing locale module in place, or — for a
+* new locale — codegen a `createTranslation` module next to the source namespace and register its
+* loader in the `registerNamespace` call. Mutates the project; the caller saves.
+*/
+function applyImport(project, ns, locale, translation, force = false) {
+	const existing = ns.locales.find((l) => l.locale === locale);
+	if (existing) {
+		if (!replaceTranslationLiteral(project, existing.moduleFilePath, existing.exportName, translation)) throw new Error(`Could not update locale "${locale}": expected an export "${existing.exportName}" initialized by a createTranslation(...) call in ${existing.moduleFilePath}.`);
+		return {
+			created: false,
+			filePath: existing.moduleFilePath
+		};
+	}
+	const localeId = localeIdentifier(locale);
+	if (!localeId) throw new Error(`Locale "${locale}" has no alphanumeric characters to form a valid identifier.`);
+	const exportName = `${toIdentifier(ns.namespace)}${localeId}`;
+	const collision = ns.locales.find((l) => l.locale !== locale && localeIdentifier(l.locale) === localeId);
+	if (collision) throw new Error(`Locale "${locale}" collides with already-registered locale "${collision.locale}" (both generate identifier "${exportName}").`);
+	const sourceBase = path.basename(ns.source.moduleFilePath, ".ts");
+	const newFilePath = path.join(path.dirname(ns.source.moduleFilePath), `${ns.namespace}.${locale}.ts`);
+	if (!force && fs.existsSync(newFilePath)) throw new Error(`${newFilePath} already exists but locale "${locale}" isn't a registered locale. Remove it or pass --force to overwrite.`);
+	const registryCall = registryCallFor(project.getSourceFileOrThrow(ns.registryFilePath), ns);
+	const otherArg = registryCall.getArguments()[1];
+	if (otherArg && !Node.isObjectLiteralExpression(otherArg)) throw new Error("registerNamespace's second argument must be an object literal of locale loaders.");
+	project.createSourceFile(newFilePath, codegenTranslationFile({
+		namespaceVar: ns.source.exportName,
+		exportName,
+		locale,
+		importPath: `./${sourceBase}`,
+		defaultImport: ns.source.isDefaultExport,
+		translation
+	}), { overwrite: true });
+	addLocaleLoader(registryCall, locale, relativeImport(ns.registryFilePath, newFilePath), exportName);
+	return {
+		created: true,
+		filePath: newFilePath
+	};
+}
+/** Parse an export file name `namespace.locale.json`. Neither segment may contain a dot, so a
+* stray-dot name (`quote.sl.si.json`) is rejected rather than folded into a bogus locale. */
+function parseImportFileName(fileName) {
+	const m = /^([^.]+)\.([^.]+)\.json$/.exec(fileName);
+	return m ? {
+		namespace: m[1],
+		locale: m[2]
+	} : null;
+}
+/** Sidecar written into the export dir so a later `import` knows which locale was the source,
+* even if `--source-locale` is omitted (it would otherwise default to `en` and mis-treat the
+* source dump as a target locale). */
+const META_FILE = ".mmtranslate-meta.json";
+const warnToStderr = (message) => console.warn(`⚠ ${message}`);
+/** A namespace name must map to exactly one source; duplicates would clobber files on export and
+* drop all-but-one entry on import, both silently. Fail fast so the user resolves it first. */
+function assertUniqueNamespaces(namespaces) {
+	const seen = /* @__PURE__ */ new Set();
+	const dupes = /* @__PURE__ */ new Set();
+	for (const n of namespaces) {
+		if (seen.has(n.namespace)) dupes.add(n.namespace);
+		seen.add(n.namespace);
+	}
+	if (dupes.size) throw new Error(`Duplicate namespace name(s): ${[...dupes].join(", ")}. Each namespace must be registered once — rename or remove the duplicate before export/import.`);
+}
+function readMetaSourceLocale(inDir) {
+	const metaPath = path.join(inDir, META_FILE);
+	if (!fs.existsSync(metaPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(metaPath, "utf8"))?.sourceLocale;
+		return typeof value === "string" ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function buildProject(opts) {
+	const project = new Project({
+		skipAddingFilesFromTsConfig: true,
+		compilerOptions: { allowJs: false }
+	});
+	for (const glob of opts.srcGlobs) project.addSourceFilesAtPaths(path.isAbsolute(glob) ? glob : path.join(opts.cwd, glob));
+	return project;
+}
+function runExport(opts) {
+	const sourceLocale = opts.sourceLocale ?? "en";
+	const namespaces = discoverFromProject(buildProject(opts), {
+		sourceLocale,
+		onWarn: warnToStderr
+	});
+	assertUniqueNamespaces(namespaces);
+	for (const ns of namespaces) for (const [what, value] of [["Namespace", ns.namespace], ...ns.locales.map((l) => ["Locale", l.locale])]) if (value.includes(".")) warnToStderr(`${what} "${value}" contains a "." — its exported JSON cannot be re-imported (import expects <namespace>.<locale>.json with no dots in either segment).`);
+	const files = planExport(namespaces);
+	fs.mkdirSync(opts.outDir, { recursive: true });
+	for (const file of files) fs.writeFileSync(path.join(opts.outDir, file.fileName), file.content);
+	fs.writeFileSync(path.join(opts.outDir, META_FILE), JSON.stringify({ sourceLocale }, null, 2) + "\n");
+	return files;
+}
+function runImport(opts) {
+	const sourceLocale = opts.sourceLocale ?? readMetaSourceLocale(opts.inDir);
+	const project = buildProject(opts);
+	const namespaces = discoverFromProject(project, {
+		sourceLocale,
+		onWarn: warnToStderr
+	});
+	assertUniqueNamespaces(namespaces);
+	const byName = new Map(namespaces.map((n) => [n.namespace, n]));
+	const rejected = [];
+	const skipped = [];
+	let applied = 0;
+	for (const fileName of fs.readdirSync(opts.inDir)) {
+		if (fileName === META_FILE) continue;
+		const parsed = parseImportFileName(fileName);
+		if (!parsed) {
+			if (fileName.endsWith(".json")) skipped.push({
+				file: fileName,
+				reason: "not a <namespace>.<locale>.json name (neither segment may contain a dot)"
+			});
+			continue;
+		}
+		const ns = byName.get(parsed.namespace);
+		if (!ns) {
+			skipped.push({
+				file: fileName,
+				reason: `no namespace "${parsed.namespace}" found in the scanned sources`
+			});
+			continue;
+		}
+		if (parsed.locale === ns.source.locale) continue;
+		let translation;
+		try {
+			translation = fromJson(fs.readFileSync(path.join(opts.inDir, fileName), "utf8"));
+		} catch (e) {
+			rejected.push({
+				file: fileName,
+				issues: [{
+					key: "(parse)",
+					message: e instanceof Error ? e.message : String(e)
+				}]
+			});
+			continue;
+		}
+		const issues = validateImport(translation, ns.source.translation);
+		if (issues.length) {
+			rejected.push({
+				file: fileName,
+				issues
+			});
+			continue;
+		}
+		try {
+			applyImport(project, ns, parsed.locale, translation, opts.force);
+			applied++;
+		} catch (e) {
+			rejected.push({
+				file: fileName,
+				issues: [{
+					key: "(apply)",
+					message: e instanceof Error ? e.message : String(e)
+				}]
+			});
+		}
+	}
+	project.saveSync();
+	return {
+		applied,
+		rejected,
+		skipped
+	};
+}
+function runGenerateManifest(opts) {
+	const sourceLocale = opts.sourceLocale ?? "en";
+	const namespaces = discoverFromProject(buildProject(opts), {
+		sourceLocale,
+		onWarn: warnToStderr
+	});
+	assertUniqueNamespaces(namespaces);
+	const entries = namespaces.map((n) => ({
+		namespace: n.namespace,
+		sourceLocale,
+		registry: path.relative(opts.cwd, n.registryFilePath),
+		source: path.relative(opts.cwd, n.source.moduleFilePath),
+		locales: n.locales.map((l) => l.locale)
+	}));
+	const content = `// Generated by \`mmtranslate generate-manifest\`. Edit the globs / entries as needed.\nexport default ${JSON.stringify(entries, null, 2)};\n`;
+	fs.writeFileSync(opts.outFile, content);
+	return content;
+}
+function localeIdentifier(locale) {
+	return locale.split(/[^A-Za-z0-9]/).filter(Boolean).map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1).toLowerCase()).join("");
+}
+function relativeImport(fromFile, toFile) {
+	const rel = path.relative(path.dirname(fromFile), toFile).replace(/\.ts$/, "").split(path.sep).join("/");
+	return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function registryCallFor(sf, ns) {
+	const call = findRegisterNamespaceCalls(sf)[ns.registryCallIndex];
+	if (!call) throw new Error(`Could not locate the registerNamespace call for "${ns.namespace}" in ${sf.getFilePath()}.`);
+	return call;
+}
+//#endregion
+export { toJson as S, codegenTranslationFile as _, runGenerateManifest as a, leafEntries as b, replaceTranslationLiteral as c, validateMessage as d, discoverFromProject as f, liftObjectLiteral as g, parseLoader as h, runExport as i, extractPlaceholders as l, findRegisterNamespaceCalls as m, parseImportFileName as n, runImport as o, addLocaleLoader as p, planExport as r, validateImport as s, applyImport as t, placeholderParity as u, objectLiteralText as v, leafMap as x, fromJson as y };
+
+//# sourceMappingURL=commands-yoWN-Tne.mjs.map