@x18n/node 0.0.3 → 0.0.6

package/dist/index.d.mts

@@ -13,6 +13,19 @@ export declare function loadYamlPlugin(file: string): Promise<Plugin | Preset>;
 /** Resolves a plugin specifier relative to the config directory: a YAML file, a module path, or a package name. */
 export declare function createPluginLoader(dir: string): (specifier: string, options: JsonObject | undefined) => Promise<Plugin | Preset>;
 //#endregion
+//#region src/git-history.d.ts
+interface GitHistoryOptions {
+  /** Most commits to read, newest first. Default: every commit. */
+  readonly maxDepth?: number | undefined;
+  /** Only commits after this time: a `git log --since` value such as `1 year ago`, or a Date. */
+  readonly since?: string | Date | undefined;
+}
+declare module "@x18n/core" {
+  interface HistoryConfigs {
+    readonly git?: false | GitHistoryOptions;
+  }
+}
+//#endregion
 //#region src/host.d.ts
 interface NodeHostOptions {
   /** Directory of the persistent cache, or false to disable it. Default `node_modules/.cache/x18n` under the root. */
@@ -81,4 +94,4 @@ interface MigrateOptions {
 /** Converts i18n-ally settings, custom framework and reviews into x18n files. Never deletes i18n-ally files. */
 export declare function migrateI18nAlly(root: string, options?: MigrateOptions): Promise<MigrationResult>;
 //#endregion
-export type { LoadOptions, LoadedProject, MigrateOptions, MigrationFile, MigrationResult, NodeHost, NodeHostOptions, Workspace };
+export type { GitHistoryOptions, LoadOptions, LoadedProject, MigrateOptions, MigrationFile, MigrationResult, NodeHost, NodeHostOptions, Workspace };

package/dist/index.mjs

@@ -12,6 +12,8 @@ import process from "node:process";
 import { watch } from "chokidar";
 import ignore from "ignore";
 import { createBuiltins } from "@x18n/builtins";
+import { Buffer } from "node:buffer";
+import { execFile, spawn } from "node:child_process";
 import { applyEdits, modify, parse as parse$1 } from "jsonc-parser";
 //#region src/config.ts
 const configFileNames = [
@@ -41,17 +43,22 @@ function findConfigUpward(cwd) {
 		dir = parent;
 	}
 }
-const core = fileURLToPath(import.meta.resolve("@x18n/core"));
-const presets = fileURLToPath(import.meta.resolve("@x18n/builtins/presets"));
-const jiti = createJiti(import.meta.url, {
+function resolveOwn(specifier) {
+	try {
+		return fileURLToPath(import.meta.resolve(specifier));
+	} catch {}
+}
+const core = resolveOwn("@x18n/core");
+const presets = resolveOwn("@x18n/builtins/presets");
+const jiti = createJiti(import.meta.url ?? pathToFileURL(__filename).href, {
 	moduleCache: false,
 	interopDefault: true,
-	alias: {
+	alias: core && presets ? {
 		"@x18n/core": core,
 		"@x18n/cli/presets": presets,
 		"@x18n/cli": core,
 		"@x18n/builtins/presets": presets
-	}
+	} : {}
 });
 /** Imports a JS or TS module (config, plugin, executed resource). */
 async function importModule(file) {
@@ -284,6 +291,354 @@ function createNodeHost(root, options = {}) {
 	};
 }
 //#endregion
+//#region src/git-history.ts
+const noBlob = /^0+$/;
+function git(cwd, args) {
+	return new Promise((resolve, reject) => {
+		execFile("git", [
+			"-c",
+			"core.quotePath=false",
+			...args
+		], {
+			cwd,
+			maxBuffer: 1024 ** 3,
+			encoding: "utf8"
+		}, (error, stdout) => {
+			if (error) reject(error);
+			else resolve(stdout);
+		});
+	});
+}
+/** Blob texts by sha, through one `git cat-file --batch`. */
+function readBlobs(cwd, shas) {
+	return new Promise((resolve, reject) => {
+		const child = spawn("git", ["cat-file", "--batch"], { cwd });
+		const chunks = [];
+		child.stdout.on("data", (chunk) => chunks.push(chunk));
+		child.on("error", reject);
+		child.on("close", () => {
+			const data = Buffer.concat(chunks);
+			const out = /* @__PURE__ */ new Map();
+			let position = 0;
+			while (position < data.length) {
+				const end = data.indexOf(10, position);
+				const [sha, type, size] = data.subarray(position, end).toString("utf8").split(" ");
+				position = end + 1;
+				if (type !== "blob") continue;
+				out.set(sha, data.subarray(position, position + Number(size)).toString("utf8"));
+				position += Number(size) + 1;
+			}
+			resolve(out);
+		});
+		child.stdin.end(shas.length ? `${shas.join("\n")}\n` : "");
+	});
+}
+/** The path a file added in `commit` was renamed from, with its blob. */
+async function renamedFrom(top, commit, path) {
+	const out = await git(top, [
+		"diff-tree",
+		"-r",
+		"-M",
+		"--raw",
+		"--no-abbrev",
+		"--no-commit-id",
+		commit
+	]);
+	for (const line of out.split("\n")) {
+		const [meta, from, to] = line.split("	");
+		if (to === path && meta?.split(" ")[4]?.startsWith("R")) return {
+			path: from,
+			blob: meta.split(" ")[2]
+		};
+	}
+}
+/** Parses `git log --raw --format=%x01%H%x00%ct%x00%an`. */
+function parseLog(out) {
+	return out.split("
").slice(1).map((chunk) => {
+		const [header = "", ...lines] = chunk.split("\n");
+		const [sha = "", time, author = ""] = header.split("\0");
+		const files = lines.filter((line) => line.startsWith(":")).map((line) => {
+			const [meta = "", ...paths] = line.split("	");
+			const [, , before = "", after = "", status = ""] = meta.split(" ");
+			return {
+				path: paths.at(-1) ?? "",
+				status,
+				before: noBlob.test(before) ? void 0 : before,
+				after: noBlob.test(after) ? void 0 : after
+			};
+		});
+		return {
+			sha,
+			at: Number(time) * 1e3,
+			author,
+			files
+		};
+	});
+}
+async function collectCommits(input) {
+	const commits = /* @__PURE__ */ new Map();
+	const queue = [{
+		from: input.head,
+		paths: input.resources
+	}];
+	for (let item = queue.shift(); item; item = queue.shift()) {
+		const out = await git(input.top, [
+			"log",
+			item.from,
+			...input.base ? [`^${input.base}`] : [],
+			"--no-merges",
+			"--raw",
+			"--no-abbrev",
+			"--format=%x01%H%x00%ct%x00%an",
+			...input.window,
+			"--",
+			...[...item.paths.keys()].map((path) => `:(literal)${path}`)
+		]);
+		for (const entry of parseLog(out)) {
+			const commit = commits.get(entry.sha) ?? {
+				at: entry.at,
+				author: entry.author,
+				files: []
+			};
+			commits.set(entry.sha, commit);
+			for (const file of entry.files) {
+				const resource = item.paths.get(file.path);
+				if (!resource) continue;
+				const renamed = file.status === "A" ? await renamedFrom(input.top, entry.sha, file.path) : void 0;
+				if (renamed) queue.push({
+					from: `${entry.sha}^`,
+					paths: /* @__PURE__ */ new Map([[renamed.path, resource]])
+				});
+				commit.files.push({
+					resource,
+					before: renamed?.blob ?? file.before,
+					after: file.after
+				});
+			}
+		}
+	}
+	return commits;
+}
+/** Message changes per key and locale: in each commit, the messages of a locale's changed files before and after. */
+async function walk(input) {
+	const commits = await collectCommits(input);
+	const shas = new Set([...commits.values()].flatMap((commit) => commit.files.flatMap((file) => [file.before, file.after].filter((sha) => sha !== void 0))));
+	const blobs = await readBlobs(input.top, [...shas]);
+	const parsed = /* @__PURE__ */ new Map();
+	const messagesOf = (resource, sha) => {
+		if (sha === void 0) return /* @__PURE__ */ new Map();
+		const id = `${resource.id}\0${sha}`;
+		if (!parsed.has(id)) {
+			const text = blobs.get(sha);
+			parsed.set(id, text === void 0 ? void 0 : input.ctx.messagesIn(resource, text));
+		}
+		return parsed.get(id);
+	};
+	const changes = /* @__PURE__ */ new Map();
+	for (const [sha, commit] of commits) {
+		const byLocale = Map.groupBy(commit.files, (file) => file.resource.locale);
+		for (const [locale, files] of byLocale) {
+			const before = /* @__PURE__ */ new Map();
+			const after = /* @__PURE__ */ new Map();
+			for (const file of files) {
+				const old = messagesOf(file.resource, file.before);
+				const next = messagesOf(file.resource, file.after);
+				if (!old || !next) continue;
+				old.forEach((value, key) => before.has(key) || before.set(key, value));
+				next.forEach((value, key) => after.has(key) || after.set(key, value));
+			}
+			for (const [key, value] of after) {
+				if (before.has(key) && before.get(key) === value) continue;
+				const byKey = changes.get(key) ?? /* @__PURE__ */ new Map();
+				changes.set(key, byKey);
+				byKey.set(locale, [...byKey.get(locale) ?? [], [
+					commit.at,
+					sha,
+					commit.author,
+					value
+				]]);
+			}
+		}
+	}
+	for (const byKey of changes.values()) for (const list of byKey.values()) list.sort((a, b) => b[0] - a[0]);
+	return changes;
+}
+/** Messages at HEAD per locale, to tell uncommitted edits. */
+async function headValues(ctx, top, resources) {
+	const files = (await git(top, [
+		"ls-tree",
+		"-r",
+		"HEAD",
+		"--",
+		...resources.keys()
+	])).split("\n").flatMap((line) => {
+		const [meta = "", path = ""] = line.split("	");
+		const resource = resources.get(path);
+		return resource ? [{
+			resource,
+			sha: meta.split(" ")[2]
+		}] : [];
+	});
+	const blobs = await readBlobs(top, files.map((file) => file.sha));
+	const values = /* @__PURE__ */ new Map();
+	for (const { resource, sha } of files) {
+		const byKey = values.get(resource.locale) ?? /* @__PURE__ */ new Map();
+		values.set(resource.locale, byKey);
+		const text = blobs.get(sha);
+		if (text !== void 0) ctx.messagesIn(resource, text)?.forEach((value, key) => byKey.has(key) || byKey.set(key, value));
+	}
+	return values;
+}
+function toHistory(changes, head) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const [key, byLocale] of changes) {
+		const entries = /* @__PURE__ */ new Map();
+		latest.set(key, entries);
+		for (const [locale, [newest]] of byLocale) if (newest) {
+			const value = head.get(locale)?.get(key);
+			entries.set(locale, {
+				updatedAt: newest[0],
+				revision: newest[1],
+				author: newest[2],
+				value: value === void 0 ? newest[3] : value
+			});
+		}
+	}
+	return {
+		changes: latest,
+		valueAt: (key, locale, at) => changes.get(key)?.get(locale)?.find((change) => change[0] <= at)?.[3]
+	};
+}
+function fromWalked(walked) {
+	return new Map(walked.changes.map(([key, byLocale]) => [key, new Map(byLocale)]));
+}
+function toWalked(head, changes) {
+	return {
+		head,
+		changes: [...changes].map(([key, byLocale]) => [key, [...byLocale]])
+	};
+}
+/** Fresh changes first, so lists stay newest first. */
+function mergeChanges(fresh, older) {
+	for (const [key, byLocale] of older) {
+		const target = fresh.get(key) ?? /* @__PURE__ */ new Map();
+		fresh.set(key, target);
+		for (const [locale, list] of byLocale) target.set(locale, [...target.get(locale) ?? [], ...list]);
+	}
+	return fresh;
+}
+function isNotInstalled(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+/** Reads when each message last changed from git: parsed messages per commit, so formatting, sorting and moves do not count. */
+function gitHistory() {
+	const warned = /* @__PURE__ */ new Set();
+	const warnOnce = (ctx, message) => {
+		if (!warned.has(message)) {
+			warned.add(message);
+			ctx.host.logger?.warn(message);
+		}
+	};
+	async function load(ctx) {
+		const options = ctx.config.history === false ? false : ctx.config.history.git;
+		if (options === false) return void 0;
+		const run = (args) => git(ctx.host.root, args);
+		let top;
+		try {
+			top = (await run(["rev-parse", "--show-toplevel"])).trim();
+		} catch (error) {
+			if (isNotInstalled(error)) warnOnce(ctx, "git is not installed, so stale translations are not reported.");
+			return;
+		}
+		if ((await run(["rev-parse", "--is-shallow-repository"])).trim() === "true") {
+			warnOnce(ctx, "The git clone is shallow, so stale translations are not reported. Fetch the full history (`fetch-depth: 0` in GitHub Actions).");
+			return;
+		}
+		const head = (await run([
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			"HEAD"
+		]).catch(() => "")).trim();
+		const prefix = (await run(["rev-parse", "--show-prefix"])).trim();
+		const resources = new Map(ctx.resources.filter((resource) => !resource.block).map((resource) => [`${prefix}${resource.path}`, resource]));
+		if (!head || resources.size === 0) return void 0;
+		const window = [...options?.maxDepth === void 0 ? [] : [`--max-count=${options.maxDepth}`], ...options?.since === void 0 ? [] : [`--since=${options.since instanceof Date ? options.since.toISOString() : options.since}`]];
+		const cache = window.length === 0 ? ctx.host.cache : void 0;
+		const signature = [
+			1,
+			[...resources].map(([path, r]) => [
+				path,
+				r.locale,
+				r.namespace,
+				r.format
+			]).sort(),
+			ctx.config.namespace,
+			ctx.config.keyStyle
+		];
+		const cacheKey = `git-history:${hashText(JSON.stringify(signature))}`;
+		const cachedText = await cache?.get(cacheKey);
+		const cached = cachedText === void 0 ? void 0 : JSON.parse(cachedText);
+		let changes;
+		if (cached?.head === head) changes = fromWalked(cached);
+		else {
+			const base = cached && await run([
+				"merge-base",
+				"--is-ancestor",
+				cached.head,
+				head
+			]).then(() => cached, () => void 0);
+			const fresh = await walk({
+				ctx,
+				top,
+				resources,
+				head,
+				base: base?.head,
+				window
+			});
+			changes = base ? mergeChanges(fresh, fromWalked(base)) : fresh;
+			await cache?.set(cacheKey, JSON.stringify(toWalked(head, changes)));
+		}
+		return toHistory(changes, await headValues(ctx, top, resources));
+	}
+	function watch$1(ctx, onChange) {
+		let watcher;
+		let timer;
+		let disposed = false;
+		const run = (args) => git(ctx.host.root, args);
+		Promise.all([run(["rev-parse", "--absolute-git-dir"]), run([
+			"rev-parse",
+			"--path-format=absolute",
+			"--git-common-dir"
+		])]).then(([dir, common]) => {
+			if (disposed) return;
+			watcher = watch([
+				join(dir.trim(), "HEAD"),
+				join(common.trim(), "refs/heads"),
+				join(common.trim(), "packed-refs")
+			], { ignoreInitial: true });
+			watcher.on("all", () => {
+				clearTimeout(timer);
+				timer = setTimeout(onChange, 100);
+			});
+		}, () => void 0);
+		return { dispose() {
+			disposed = true;
+			clearTimeout(timer);
+			watcher?.close();
+		} };
+	}
+	return {
+		name: "x18n:git-history",
+		runtime: "node",
+		histories: [{
+			id: "git",
+			load,
+			watch: watch$1
+		}]
+	};
+}
+//#endregion
 //#region src/migrate.ts
 const frameworkPresets = {
 	"vue": "vue-i18n",
@@ -799,8 +1154,12 @@ async function projectSpecs(rootConfigFile, cwd, upward) {
 async function loadWorkspace(options) {
 	const configFile = options.configFile ? resolve(options.cwd, options.configFile) : options.upward === false ? findConfigFile(resolve(options.cwd)) : findConfigUpward(options.cwd);
 	const { root, specs } = await projectSpecs(configFile, options.cwd, options.upward !== false);
-	const builtins = options.builtins ?? createBuiltins();
 	const gitRoot = findGitRoot(root);
+	const defaults = options.builtins ?? createBuiltins();
+	const builtins = gitRoot ? {
+		...defaults,
+		plugins: [...defaults.plugins, gitHistory()]
+	} : defaults;
 	const loaded = [];
 	for (const spec of specs) {
 		const name = spec.config.name ?? (spec.root === root ? relative(dirname(root), root) : relative(root, spec.root)).replace(/\\/g, "/");

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@x18n/node",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Node.js host for x18n: file system access, config and plugin loading",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
-  "homepage": "https://github.com/antfu/x18n#readme",
+  "homepage": "https://github.com/x18n-dev/x18n#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/antfu/x18n.git",
+    "url": "git+https://github.com/x18n-dev/x18n.git",
     "directory": "packages/node"
   },
-  "bugs": "https://github.com/antfu/x18n/issues",
+  "bugs": "https://github.com/x18n-dev/x18n/issues",
   "sideEffects": false,
   "exports": {
     ".": "./dist/index.mjs",
@@ -25,11 +25,11 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@x18n/builtins": "0.0.3",
-    "@x18n/core": "0.0.3",
-    "chokidar": "^5.0.0",
-    "ignore": "^7.0.12",
-    "jiti": "^2.6.1",
+    "@x18n/builtins": "0.0.6",
+    "@x18n/core": "0.0.6",
+    "chokidar": "^6.0.0",
+    "ignore": "^7.0.13",
+    "jiti": "^2.7.0",
     "jsonc-parser": "^3.3.1",
     "tinyglobby": "^0.2.17",
     "yaml": "^2.9.1"