@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/lsp-RMMMc88P.js

@@ -0,0 +1,31 @@
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { t as protocolConsole } from "./stdio-CVaJfxA7.js";
+//#region src/cli/commands/lsp.ts
+/**
+* `vi18n lsp [--stdio]` (INTERNALS §2.17): runs the language server on the
+* process's stdin and stdout until the editor exits it. The server and
+* `vscode-languageserver` load only here, so other commands never pay for
+* them (and `vp pack` gives them a chunk of their own).
+*/
+async function lsp(ctx, _flags) {
+	const streams = ctx.io.streams;
+	if (streams === void 0) throw new Error("vi18n lsp needs the process's stdin and stdout");
+	const { startLanguageServer } = await import("./server-deBOq2vq.js");
+	const restore = protocolConsole(streams.output);
+	try {
+		return {
+			exitCode: await startLanguageServer({
+				input: streams.input,
+				output: streams.output,
+				cwd: ctx.global.cwd,
+				configFile: ctx.global.config,
+				...ctx.io.signal === void 0 ? {} : { signal: ctx.io.signal }
+			}) === 0 ? EXIT.ok : EXIT.failure,
+			data: null
+		};
+	} finally {
+		restore();
+	}
+}
+//#endregion
+export { lsp };

package/dist/match-BGr8EXB3.js

@@ -0,0 +1,89 @@
+import { d as splitLocalePath, l as matchRoute, t as ROUTES, u as routePath } from "./url-CsBkRaJy.js";
+//#region src/runtime/match.ts
+/**
+* The first candidate that reaches a configured locale: exactly, through its
+* maximized form's truncations (`zh-TW` → `zh-Hant-TW` → `zh-Hant` → `zh`),
+* through `fallbacks`, or through the first locale sharing its language.
+* Candidates are canonicalised first; anything that is not a locale is skipped.
+*/
+function matchLocale(candidates, config) {
+	const { locales, fallbacks } = config;
+	for (const candidate of candidates) {
+		let tag;
+		try {
+			tag = Intl.getCanonicalLocales(candidate)[0];
+		} catch {
+			continue;
+		}
+		if (!tag) continue;
+		if (locales.includes(tag)) return tag;
+		try {
+			let m = new Intl.Locale(tag).maximize().baseName;
+			for (let i = m.length; i > 0; i = m.lastIndexOf("-")) {
+				m = m.slice(0, i);
+				if (locales.includes(m)) return m;
+			}
+		} catch {}
+		if (Object.hasOwn(fallbacks, tag)) {
+			for (const f of fallbacks[tag]) if (locales.includes(f)) return f;
+		}
+		const lang = tag.split("-")[0];
+		for (const l of locales) if (l.split("-")[0] === lang) return l;
+	}
+	return null;
+}
+/** The strategy chain for a pathname: the first matching `routeStrategies` glob, else `strategy`. */
+function strategyFor(config, pathname) {
+	const { routeStrategies, strategy } = config.routing;
+	const p = matchRoute(Object.keys(routeStrategies), routePath(pathname, config));
+	return p === null ? strategy : routeStrategies[p];
+}
+/**
+* The `url` step: a prefixed path names its locale; an unprefixed one is the
+* source locale's canonical page under `prefix_except_default` and
+* `prefix_and_default` (on a listed host, the host's locale's), and says
+* nothing under `prefix` and `no_prefix`.
+*/
+function urlLocale(config, pathname) {
+	const url = config.routing.url;
+	if (url === "no_prefix") return null;
+	return splitLocalePath(pathname, config).locale ?? (url === "prefix" ? null : ROUTES && config.routing.home || config.sourceLocale);
+}
+/** One cookie's value from a `document.cookie` string, or null. */
+function readCookie(cookies, name) {
+	for (const part of cookies.split(";")) {
+		const i = part.indexOf("=");
+		if (i > 0 && part.slice(0, i).trim() === name) try {
+			return decodeURIComponent(part.slice(i + 1).trim());
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+/** Storage key of the `localStorage` strategy (INTERNALS §6 D29). */
+const STORAGE_KEY = "vi18n_locale";
+/** The client steps of §2.11.9: the effective chain, first result wins. */
+function clientLocale(config, input) {
+	const { locales, sourceLocale } = config;
+	for (const step of strategyFor(config, input.pathname)) {
+		let l = null;
+		if (step === "url") l = urlLocale(config, input.pathname);
+		else if (step === "cookie") l = readCookie(input.cookie, config.routing.cookie.name);
+		else if (step === "header") l = matchLocale(input.languages, config);
+		else if (step === "localStorage") try {
+			l = input.storage(STORAGE_KEY);
+		} catch {}
+		else if (step === "default") l = sourceLocale;
+		if (locales.includes(l)) return {
+			locale: l,
+			source: step
+		};
+	}
+	return {
+		locale: sourceLocale,
+		source: "default"
+	};
+}
+//#endregion
+export { strategyFor as a, readCookie as i, clientLocale as n, urlLocale as o, matchLocale as r, STORAGE_KEY as t };

package/dist/mcp-CHVwBoRP.js

@@ -0,0 +1,28 @@
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { t as protocolConsole } from "./stdio-CVaJfxA7.js";
+//#region src/cli/commands/mcp.ts
+async function mcp(ctx, _flags) {
+	const streams = ctx.io.streams;
+	if (streams === void 0) throw new Error("vi18n mcp needs the process's stdin and stdout");
+	const { serveMcp } = await import("./server-Da1Ot9IN.js");
+	const restore = protocolConsole(streams.output);
+	try {
+		await serveMcp({
+			input: streams.input,
+			output: streams.output,
+			cwd: ctx.global.cwd,
+			configFile: ctx.global.config,
+			env: ctx.io.env,
+			log: ctx.io.stderr,
+			...ctx.io.signal === void 0 ? {} : { signal: ctx.io.signal }
+		});
+		return {
+			exitCode: EXIT.ok,
+			data: null
+		};
+	} finally {
+		restore();
+	}
+}
+//#endregion
+export { mcp };

package/dist/merge-driver-BTX87aVm.js

@@ -0,0 +1,422 @@
+import { d as parseCatalogBytes, o as catalogLayout, p as serializeCatalog } from "./library-D5CWvTQs.js";
+import { n as loadConfig } from "./load-gW-oJt1Q.js";
+import { t as VERSION } from "./version-Byqi2guX.js";
+import { r as plural } from "./output-DWE3SIUA.js";
+import { t as EXIT } from "./types-wSh9fCBY.js";
+import { dirname, resolve } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+//#region src/core/catalog/merge.ts
+/** The identity git-level tools use: `msgctxt` + `msgid`, or the JSON key. */
+function mergeKey(entry, layout) {
+	if (layout === "json") return entry.manualId ?? entry.label ?? "";
+	return `${entry.manualId ?? entry.foreignContext ?? ""}\u0004${(layout === "id" ? entry.label : entry.source) ?? ""}`;
+}
+function index(catalog, layout) {
+	const side = {
+		first: /* @__PURE__ */ new Map(),
+		rest: []
+	};
+	for (const entry of catalog?.entries ?? []) {
+		const key = mergeKey(entry, layout);
+		if (side.first.has(key)) side.rest.push(entry);
+		else side.first.set(key, entry);
+	}
+	return side;
+}
+/** Everything the writer emits for an entry, so equal fingerprints mean equal output. */
+function fingerprint(entry) {
+	return JSON.stringify([
+		entry.manualId,
+		entry.foreignContext,
+		entry.label,
+		entry.source,
+		entry.translation,
+		entry.state,
+		entry.fuzzy,
+		entry.contexts,
+		entry.comments,
+		entry.refs,
+		entry.maxLength,
+		entry.flags,
+		entry.extra ?? null
+	]);
+}
+/**
+* Three-way merge of a value; `base` is absent when the entry is new on both
+* sides. Null when both sides changed it differently.
+*/
+function pick(base, ours, theirs, same) {
+	if (same(ours, theirs)) return { value: ours };
+	if (base !== void 0 && same(base.value, ours)) return { value: theirs };
+	if (base !== void 0 && same(base.value, theirs)) return { value: ours };
+	return null;
+}
+function from(entry) {
+	return (get) => entry === void 0 ? void 0 : { value: get(entry) };
+}
+const equal = (a, b) => a === b;
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** Set merge in order: the base's survivors, then each side's additions. */
+function mergeList(base, ours, theirs, id) {
+	const inBase = new Set(base.map(id));
+	const inOurs = new Set(ours.map(id));
+	const inTheirs = new Set(theirs.map(id));
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (item) => {
+		const key = id(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			out.push(item);
+		}
+	};
+	for (const item of ours) {
+		const key = id(item);
+		if (!inBase.has(key) || inTheirs.has(key)) add(item);
+	}
+	for (const item of theirs) {
+		const key = id(item);
+		if (!inBase.has(key) || inOurs.has(key)) add(item);
+	}
+	return out;
+}
+const text = (value) => value;
+const flagId = (flag) => `${flag.line}${flag.name}`;
+const RANK = {
+	translated: 2,
+	ai: 1,
+	untranslated: 0
+};
+function mergeEntry(base, ours, theirs) {
+	const sorted = (values) => values.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	const common = {
+		...ours,
+		refs: sorted(mergeList(base?.refs ?? [], ours.refs, theirs.refs, text)),
+		contexts: mergeList(base?.contexts ?? [], ours.contexts, theirs.contexts, text),
+		comments: mergeList(base?.comments ?? [], ours.comments, theirs.comments, text),
+		flags: mergeList(base?.flags ?? [], ours.flags, theirs.flags, flagId),
+		line: 0,
+		wrapped: false
+	};
+	const was = from(base);
+	const maxLength = pick(was((e) => e.maxLength), ours.maxLength, theirs.maxLength, equal);
+	common.maxLength = maxLength !== null ? maxLength.value : ours.maxLength === null ? theirs.maxLength : theirs.maxLength === null ? ours.maxLength : Math.min(ours.maxLength, theirs.maxLength);
+	const extra = pick(was((e) => e.extra), ours.extra, theirs.extra, sameJson);
+	const extraValue = extra === null ? ours.extra : extra.value;
+	if (extraValue === void 0) delete common.extra;
+	else common.extra = extraValue;
+	let conflict = false;
+	const oursView = { ...common };
+	const theirsView = { ...common };
+	const sourceOf = (entry) => ({
+		source: entry.source,
+		label: entry.label
+	});
+	const valueOf = (entry) => ({
+		translation: entry.translation,
+		state: entry.state,
+		fuzzy: entry.fuzzy
+	});
+	const source = pick(was(sourceOf), sourceOf(ours), sourceOf(theirs), sameJson);
+	let value = pick(was(valueOf), valueOf(ours), valueOf(theirs), sameJson);
+	if (value === null && ours.translation === theirs.translation && ours.fuzzy === theirs.fuzzy) value = { value: RANK[ours.state] >= RANK[theirs.state] ? valueOf(ours) : valueOf(theirs) };
+	let stale = false;
+	if (base !== void 0 && source !== null && value !== null) {
+		const moved = (entry) => !sameJson(sourceOf(base), sourceOf(entry));
+		const edited = (entry) => !sameJson(valueOf(base), valueOf(entry));
+		stale = moved(ours) && !moved(theirs) && edited(theirs) || moved(theirs) && !moved(ours) && edited(ours);
+	}
+	if (source === null || value === null || stale) {
+		conflict = true;
+		Object.assign(oursView, sourceOf(ours), valueOf(ours));
+		Object.assign(theirsView, sourceOf(theirs), valueOf(theirs));
+	} else {
+		Object.assign(oursView, source.value, value.value);
+		Object.assign(theirsView, source.value, value.value);
+	}
+	return {
+		ours: oursView,
+		theirs: theirsView,
+		conflict
+	};
+}
+function mergeHeader(base, ours, theirs) {
+	const was = from(base);
+	const soft = (get) => (pick(was(get), get(ours), get(theirs), sameJson) ?? { value: get(ours) }).value;
+	const extra = [];
+	const names = /* @__PURE__ */ new Set([...ours.extra.map(([n]) => n), ...theirs.extra.map(([n]) => n)]);
+	const field = (header, name) => header?.extra.find(([n]) => n === name)?.[1];
+	for (const name of names) {
+		const a = field(ours, name);
+		const merged = pick(was((h) => field(h, name)), a, field(theirs, name), sameJson);
+		const value = merged === null ? a : merged.value;
+		if (value !== void 0) extra.push([name, value]);
+	}
+	const common = {
+		language: soft((h) => h.language),
+		idScheme: ours.idScheme,
+		sourceLocale: soft((h) => h.sourceLocale),
+		aiModel: soft((h) => h.aiModel),
+		extra
+	};
+	const scheme = pick(was((h) => h.idScheme), ours.idScheme, theirs.idScheme, equal);
+	if (scheme === null) return {
+		ours: common,
+		theirs: {
+			...common,
+			idScheme: theirs.idScheme
+		},
+		conflict: true
+	};
+	const idScheme = scheme.value;
+	return {
+		ours: {
+			...common,
+			idScheme
+		},
+		theirs: {
+			...common,
+			idScheme
+		},
+		conflict: false
+	};
+}
+/** The writer's output cut into entries: PO blocks between blank lines, JSON message members. */
+function blocks(output, layout) {
+	const body = output.endsWith("\n") ? output.slice(0, -1) : output;
+	if (layout !== "json") return body.split("\n\n").map((block) => block.split("\n"));
+	const out = [];
+	let member = null;
+	for (const line of body.split("\n")) if (member !== null) {
+		member.push(line);
+		if (/^ {4}\},?$/.test(line)) {
+			out.push(member);
+			member = null;
+		}
+	} else if (/^ {4}"/.test(line) && line.endsWith("{")) member = [line];
+	else out.push([line]);
+	if (member !== null) out.push(member);
+	return out;
+}
+/** Git's markers around the differing middle of a block whose two versions differ. */
+function conflictLines(ours, theirs) {
+	let start = 0;
+	while (start < ours.length && start < theirs.length && ours[start] === theirs[start]) start++;
+	let end = 0;
+	while (end < ours.length - start && end < theirs.length - start && ours[ours.length - 1 - end] === theirs[theirs.length - 1 - end]) end++;
+	return [
+		...ours.slice(0, start),
+		"<<<<<<< ours",
+		...ours.slice(start, ours.length - end),
+		"=======",
+		...theirs.slice(start, theirs.length - end),
+		">>>>>>> theirs",
+		...ours.slice(ours.length - end)
+	];
+}
+function mergeCatalogs(input) {
+	const { base, ours, theirs } = input;
+	const layout = ours.layout;
+	const o = index(base, layout);
+	const a = index(ours, layout);
+	const b = index(theirs, layout);
+	const oursEntries = [];
+	const theirsEntries = [];
+	const conflicting = [];
+	const both = (entry) => {
+		oursEntries.push(entry);
+		theirsEntries.push(entry);
+	};
+	const keys = [...a.first.keys(), ...[...b.first.keys()].filter((key) => !a.first.has(key))];
+	for (const key of keys) {
+		const was = o.first.get(key);
+		const mine = a.first.get(key);
+		const other = b.first.get(key);
+		if (mine === void 0 || other === void 0) {
+			const kept = mine ?? other;
+			if (was !== void 0 && fingerprint(was) === fingerprint(kept)) continue;
+			both(kept);
+			continue;
+		}
+		if (fingerprint(mine) === fingerprint(other)) {
+			both(mine);
+			continue;
+		}
+		const merged = mergeEntry(was, mine, other);
+		oursEntries.push(merged.ours);
+		theirsEntries.push(merged.theirs);
+		if (merged.conflict) conflicting.push(mine.manualId ?? mine.label ?? mine.source ?? key);
+	}
+	const restSeen = /* @__PURE__ */ new Set();
+	for (const entry of [...a.rest, ...b.rest]) {
+		const print = fingerprint(entry);
+		if (restSeen.has(print)) continue;
+		restSeen.add(print);
+		both(entry);
+	}
+	const header = mergeHeader(base?.header, ours.header, theirs.header);
+	const obsolete = mergeList(base?.obsolete ?? [], ours.obsolete, theirs.obsolete, text);
+	const view = (h, entries) => ({
+		...ours,
+		header: h,
+		entries,
+		obsolete,
+		droppedObsolete: obsolete.length
+	});
+	const options = {
+		isSourceLocale: input.isSourceLocale,
+		version: input.version
+	};
+	const oursText = serializeCatalog(view(header.ours, oursEntries), options);
+	const conflicts = conflicting.length + (header.conflict ? 1 : 0);
+	if (conflicts === 0) return {
+		text: oursText,
+		conflicts,
+		conflicting
+	};
+	const theirsText = serializeCatalog(view(header.theirs, theirsEntries), options);
+	const left = blocks(oursText, layout);
+	const right = blocks(theirsText, layout);
+	let lines;
+	if (left.length !== right.length) {
+		lines = conflictLines(oursText.split("\n"), theirsText.split("\n"));
+		return {
+			text: `${lines.join("\n")}\n`,
+			conflicts,
+			conflicting
+		};
+	}
+	const separator = layout === "json" ? "\n" : "\n\n";
+	return {
+		text: `${left.map((block, i) => {
+			const other = right[i];
+			return (block.length === other.length && block.every((line, k) => line === other[k]) ? block : conflictLines(block, other)).join("\n");
+		}).join(separator)}\n`,
+		conflicts,
+		conflicting
+	};
+}
+//#endregion
+//#region src/cli/commands/merge-driver.ts
+/**
+* `vi18n merge-driver <base> <ours> <theirs> [<path>]` (PLAN §4.4 P2,
+* INTERNALS §2.6.10): the catalog merge driver git runs as
+* `vi18n merge-driver %O %A %B %P`. It merges entry by entry
+* (`core/catalog/merge.ts`), writes the result over `<ours>` as git
+* requires, and exits 1 when a true conflict is left in it. Files it cannot
+* read as catalogs (no config found, a parse error, conflict markers from an
+* earlier merge) get git's own line merge (`git merge-file`), so a driver
+* failure never loses either side.
+*/
+const run = promisify(execFile);
+async function findConfig(ctx, start) {
+	try {
+		const config = await loadConfig({
+			cwd: start,
+			configFile: ctx.global.config
+		});
+		return config.configFile === null ? null : config;
+	} catch {
+		return null;
+	}
+}
+/** Parses one side; null when it is not a catalog vi18n reads without errors. */
+function read(bytes, layout, locale, isSourceLocale) {
+	const parsed = parseCatalogBytes(bytes, {
+		locale,
+		layout,
+		isSourceLocale
+	});
+	return parsed.diagnostics.some((diagnostic) => diagnostic.severity === "error") ? null : parsed.catalog;
+}
+async function mergeDriver(ctx, flags) {
+	const cwd = ctx.global.cwd;
+	const base = resolve(cwd, flags.base);
+	const ours = resolve(cwd, flags.ours);
+	const theirs = resolve(cwd, flags.theirs);
+	const data = {
+		path: flags.path,
+		conflicts: 0,
+		conflicting: [],
+		fallback: false
+	};
+	const shown = flags.path ?? flags.ours;
+	const fallback = async (reason) => {
+		data.fallback = true;
+		ctx.out.note(`vi18n merge-driver: ${shown}: ${reason}; merging lines with git merge-file`);
+		try {
+			await run("git", [
+				"merge-file",
+				"-L",
+				"ours",
+				"-L",
+				"base",
+				"-L",
+				"theirs",
+				ours,
+				base,
+				theirs
+			]);
+			return {
+				exitCode: EXIT.ok,
+				data
+			};
+		} catch (error) {
+			const status = error.code;
+			if (typeof status === "number" && status > 0) {
+				data.conflicts = status;
+				return {
+					exitCode: EXIT.failure,
+					data
+				};
+			}
+			throw error;
+		}
+	};
+	const config = await findConfig(ctx, flags.path === null ? cwd : dirname(resolve(cwd, flags.path)));
+	if (config === null) return fallback("no vi18n.config.ts found");
+	const layout = catalogLayout(config);
+	const [baseBytes, oursBytes, theirsBytes] = await Promise.all([
+		base,
+		ours,
+		theirs
+	].map((file) => readFile(file)));
+	const probe = read(oursBytes, layout, "", false) ?? read(theirsBytes, layout, "", false);
+	if (probe === null) return fallback("a side is not a catalog vi18n can read");
+	const locale = probe.header.language;
+	const isSourceLocale = locale === config.sourceLocale;
+	const mine = read(oursBytes, layout, locale, isSourceLocale);
+	const other = read(theirsBytes, layout, locale, isSourceLocale);
+	const empty = baseBytes.toString("utf8").trim() === "";
+	const was = empty ? null : read(baseBytes, layout, locale, isSourceLocale);
+	if (mine === null || other === null || !empty && was === null) return fallback("a side is not a catalog vi18n can read");
+	const outcome = mergeCatalogs({
+		base: was,
+		ours: mine,
+		theirs: other,
+		isSourceLocale,
+		version: VERSION
+	});
+	await writeFile(ours, outcome.text);
+	data.conflicts = outcome.conflicts;
+	data.conflicting = outcome.conflicting;
+	if (outcome.conflicts === 0) return {
+		exitCode: EXIT.ok,
+		data
+	};
+	const names = outcome.conflicting.slice(0, 5).join(", ");
+	ctx.out.report([{
+		code: "merge-conflict",
+		severity: "warning",
+		message: `${plural(outcome.conflicts, "entry changed", "entries changed")} differently on both sides${names === "" ? " (the id scheme)" : ` (${names}${outcome.conflicting.length > 5 ? ", …" : ""})`}; resolve the markers, then run vi18n extract`,
+		file: shown
+	}]);
+	return {
+		exitCode: EXIT.failure,
+		data
+	};
+}
+//#endregion
+export { mergeDriver };