typescript-bedrock 0.1.2 → 0.1.3

package/files/bunfig.toml.template

@@ -24,7 +24,7 @@ coverage = true
 coverageSkipTestFiles = true
 # The threshold is enforced only while the `text` reporter is on.
 coverageReporter = ["text", "lcov"]
-coverageThreshold = { lines = 0.9, functions = 0.9 }
+coverageThreshold = { lines = 0, functions = 0 }
 
 [fmt]
 useTabs = true

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typescript-bedrock",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "Strictest Bun + TypeScript 7 tooling: shared configs, git hooks, a guard, and an adopt command.",
 	"license": "MIT",
 	"author": "xsyetopz",

package/src/adopt/adopt.ts

@@ -1,6 +1,7 @@
 import { realpath } from "node:fs/promises";
 import { basename, join } from "node:path";
 
+import { mergeBunfig } from "./bunfig.ts";
 import { asRecord, exists, type Json, readJsonc, toJson } from "./json.ts";
 import { migrateManifest } from "./manifest.ts";
 import { sharedSteps } from "./shared.ts";
@@ -175,6 +176,21 @@ const planManifest = async (
 	);
 };
 
+const planBunfig = async (
+	filesRoot: string,
+	target: string,
+): Promise<{ steps: Step[]; notes: string[] }> => {
+	const file = Bun.file(join(target, "bunfig.toml"));
+	const merged = mergeBunfig(
+		await Bun.file(join(filesRoot, storedPath("bunfig.toml"))).text(),
+		(await file.exists()) ? await file.text() : undefined,
+	);
+	return {
+		steps: [{ kind: "write", path: "bunfig.toml", content: merged.content }],
+		notes: merged.notes,
+	};
+};
+
 const planTsconfig = async (
 	packageRoot: string,
 	target: string,
@@ -218,6 +234,7 @@ export const planAdoption = async (
 	const filesRoot = join(packageRoot, "files");
 	const migrated = await planManifest(packageRoot, target, options);
 	const ts = await planTsconfig(packageRoot, target);
+	const bunfig = await planBunfig(filesRoot, target);
 	const ci = Bun.file(join(target, OLD_CI));
 	const oldCi = (await ci.exists()) && OLD_CI_COMMAND.test(await ci.text());
 	const replaced = [
@@ -227,7 +244,7 @@ export const planAdoption = async (
 	const steps: Step[] = [
 		...(await jsonWrite(target, "package.json", migrated.manifest)),
 		...(await jsonWrite(target, "tsconfig.json", ts.tsconfig)),
-		...(await copies(filesRoot, target, ["bunfig.toml"], true)),
+		...bunfig.steps,
 		...(await copies(join(filesRoot, "base"), target, BASE_FILES, true)),
 		...(await copies(filesRoot, target, TOOL_FILES, true)),
 		...(await copies(filesRoot, target, STARTER_FILES, false)),
@@ -238,6 +255,6 @@ export const planAdoption = async (
 	return {
 		steps: await pending(target, steps),
 		lockfiles: await existing(target, LOCKFILES),
-		notes: [...migrated.notes, ...ts.notes],
+		notes: [...migrated.notes, ...ts.notes, ...bunfig.notes],
 	};
 };

package/src/adopt/bunfig.ts

@@ -0,0 +1,202 @@
+import { isArray, isRecord } from "./json.ts";
+import {
+	COMMENT,
+	type Entry,
+	type Path,
+	scan,
+	type Section,
+} from "./toml-scan.ts";
+
+interface Merge {
+	readonly lines: string[];
+	readonly own: readonly string[];
+	readonly base: unknown;
+	readonly repo: unknown;
+	readonly after: Map<number, string[]>;
+	readonly appended: string[];
+	readonly notes: string[];
+}
+
+const get = (value: unknown, path: Path): unknown => {
+	let node = value;
+	for (const part of path) {
+		if (typeof part === "number") {
+			node = isArray(node) ? node[part] : undefined;
+		} else {
+			node = isRecord(node) ? node[part] : undefined;
+		}
+	}
+	return node;
+};
+
+const asList = (value: unknown): readonly unknown[] =>
+	isArray(value) ? value : [];
+
+const has = (list: readonly unknown[], value: unknown): boolean =>
+	list.some((item) => Bun.deepEquals(item, value));
+
+const toml = (value: unknown): string => JSON.stringify(value);
+
+const valuesOn = (line: string): readonly unknown[] => {
+	try {
+		// The newline keeps a trailing comment from swallowing the `]`.
+		return asList(get(Bun.TOML.parse(`v = [${line}\n]`), ["v"]));
+	} catch {
+		return [];
+	}
+};
+
+const insert = (merge: Merge, line: number, text: readonly string[]): void => {
+	if (text.length > 0) {
+		merge.after.set(line, [...(merge.after.get(line) ?? []), ...text]);
+	}
+};
+
+const raw = (merge: Merge, from: number, end: number): string =>
+	merge.own.slice(from, end + 1).join("\n");
+
+/** The repo's lines that hold an entry the template array lacks, with their comments. */
+const carriedLines = (
+	merge: Merge,
+	entry: Entry,
+	mine: readonly unknown[],
+): { lines: string[]; values: unknown[] } => {
+	const lines: string[] = [];
+	const values: unknown[] = [];
+	let comments: string[] = [];
+	for (const line of merge.own.slice(entry.start + 1, entry.end)) {
+		if (COMMENT.test(line)) {
+			comments.push(line);
+			continue;
+		}
+		const fresh = valuesOn(line).filter((value) => !has(mine, value));
+		if (fresh.length > 0) {
+			lines.push(...comments, line);
+			values.push(...fresh);
+		}
+		comments = [];
+	}
+	return { lines, values };
+};
+
+const mergeArray = (
+	merge: Merge,
+	entry: Entry,
+	at: Entry,
+	mine: readonly unknown[],
+): void => {
+	const theirs = asList(get(merge.repo, entry.path));
+	const extra = theirs.filter((value) => !has(mine, value));
+	if (extra.length === 0) {
+		return;
+	}
+	if (at.start === at.end) {
+		const values = [...mine, ...extra].map((value) => toml(value));
+		merge.lines[at.start] = `${at.key} = [${values.join(", ")}]`;
+		return;
+	}
+	const indent = /^\s*/u.exec(merge.lines[at.end - 1] ?? "")?.[0] ?? "";
+	const carried = carriedLines(merge, entry, mine);
+	const rest = extra.filter((value) => !has(carried.values, value));
+	insert(merge, at.end - 1, [
+		...carried.lines,
+		...rest.map((value) => `${indent}${toml(value)},`),
+	]);
+};
+
+const mergeTable = (merge: Merge, section: Section, table: Section): void => {
+	const keys = new Map(
+		table.entries.map((entry) => [JSON.stringify(entry.path), entry]),
+	);
+	const added: string[] = [];
+	for (const entry of section.entries) {
+		const mine = get(merge.base, entry.path);
+		const theirs = get(merge.repo, entry.path);
+		const at = keys.get(JSON.stringify(entry.path));
+		if (mine === undefined) {
+			added.push(raw(merge, entry.from, entry.end));
+		} else if (at !== undefined && isArray(mine) && isArray(theirs)) {
+			mergeArray(merge, entry, at, mine);
+		} else if (!Bun.deepEquals(mine, theirs)) {
+			const name = entry.path.join(".");
+			merge.notes.push(
+				`bunfig.toml: kept the template's \`${name} = ${toml(mine)}\`; the repo had \`${name} = ${toml(theirs)}\`.`,
+			);
+		}
+	}
+	insert(merge, table.end, added);
+};
+
+const mergeSection = (
+	merge: Merge,
+	section: Section,
+	tables: Map<string, Section>,
+): void => {
+	const table = tables.get(JSON.stringify(section.path));
+	const isNew = section.array
+		? !has(
+				asList(get(merge.base, section.path.slice(0, -1))),
+				get(merge.repo, section.path),
+			)
+		: table === undefined;
+	if (isNew) {
+		merge.appended.push(raw(merge, section.from, section.end));
+	} else if (!section.array && table !== undefined) {
+		mergeTable(merge, section, table);
+	}
+};
+
+const render = (merge: Merge): string => {
+	const out = [...(merge.after.get(-1) ?? [])];
+	for (const [index, line] of merge.lines.entries()) {
+		out.push(line, ...(merge.after.get(index) ?? []));
+	}
+	let text = out.join("\n").replace(/\n*$/u, "\n");
+	for (const block of merge.appended) {
+		text += `\n${block}\n`;
+	}
+	return text;
+};
+
+/**
+ * Writes the template's bunfig.toml, then adds what the repo's copy adds to it:
+ * each key a table lacks, each entry a template array lacks, and each table or
+ * `[[…]]` element the template lacks, with the comments right above them.
+ * Where both set a value, the template's wins, since bunfig.toml cannot
+ * extend a shared file; each such value gets a note.
+ */
+export const mergeBunfig = (
+	template: string,
+	current?: string,
+): { content: string; notes: string[] } => {
+	if (current === undefined) {
+		return { content: template, notes: [] };
+	}
+	let repo: unknown;
+	try {
+		repo = Bun.TOML.parse(current);
+	} catch {
+		return {
+			content: template,
+			notes: [
+				"bunfig.toml: the repo's copy is not valid TOML, so adopt wrote the template. Move its settings over from bunfig.toml.bak.",
+			],
+		};
+	}
+	const merge: Merge = {
+		lines: template.split("\n"),
+		own: current.split("\n"),
+		base: Bun.TOML.parse(template),
+		repo,
+		after: new Map(),
+		appended: [],
+		notes: [],
+	};
+	const tables = new Map(
+		scan(merge.lines).map((section) => [JSON.stringify(section.path), section]),
+	);
+	for (const section of scan(merge.own)) {
+		mergeSection(merge, section, tables);
+	}
+	return { content: render(merge), notes: merge.notes };
+};

package/src/adopt/toml-scan.ts

@@ -0,0 +1,117 @@
+export type Path = readonly (string | number)[];
+
+export interface Entry {
+	readonly path: Path;
+	readonly key: string;
+	/** The first line of the comments right above the key. */
+	readonly from: number;
+	readonly start: number;
+	readonly end: number;
+}
+
+export interface Section {
+	readonly path: Path;
+	readonly array: boolean;
+	readonly from: number;
+	readonly entries: Entry[];
+	end: number;
+}
+
+const HEADER = /^\s*(\[\[?)\s*([^\]]+?)\s*\]\]?\s*(?:#.*)?$/u;
+const KEY = /^\s*([^\s#=[][^=]*?)\s*=/u;
+export const COMMENT = /^\s*#/u;
+
+const keyPath = (text: string): string[] =>
+	text.split(".").map((part) => part.trim().replace(/^(["'])(.*)\1$/u, "$2"));
+
+/** How many arrays the line opens minus how many it closes, outside strings and comments. */
+const brackets = (line: string): number => {
+	let depth = 0;
+	let quote = "";
+	for (const char of line) {
+		if (quote !== "") {
+			quote = char === quote ? "" : quote;
+		} else if (char === '"' || char === "'") {
+			quote = char;
+		} else if (char === "#") {
+			break;
+		} else {
+			depth += Number(char === "[") - Number(char === "]");
+		}
+	}
+	return depth;
+};
+
+/** The last line of the value that starts on `start`. */
+const valueEnd = (
+	lines: readonly string[],
+	start: number,
+	key: string,
+): number => {
+	let end = start;
+	let depth = brackets((lines[start] ?? "").slice(key.length));
+	while (depth > 0 && end + 1 < lines.length) {
+		end += 1;
+		depth += brackets(lines[end] ?? "");
+	}
+	return end;
+};
+
+const startSection = (
+	header: RegExpExecArray,
+	from: number,
+	start: number,
+	counts: Map<string, number>,
+): Section => {
+	const name = header[2] ?? "";
+	const array = header[1] === "[[";
+	const count = counts.get(name) ?? 0;
+	counts.set(name, count + 1);
+	return {
+		path: array ? [...keyPath(name), count] : keyPath(name),
+		array,
+		from,
+		entries: [],
+		end: start,
+	};
+};
+
+/** Splits a TOML file into its root and its tables, each with the line range of every key. */
+export const scan = (lines: readonly string[]): Section[] => {
+	let section: Section = {
+		path: [],
+		array: false,
+		from: 0,
+		entries: [],
+		end: -1,
+	};
+	const sections = [section];
+	const counts = new Map<string, number>();
+	let from = -1;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		if (COMMENT.test(line)) {
+			from = from < 0 ? index : from;
+			continue;
+		}
+		const header = HEADER.exec(line);
+		const key = KEY.exec(line);
+		if (header !== null) {
+			section = startSection(header, from < 0 ? index : from, index, counts);
+			sections.push(section);
+		} else if (key !== null) {
+			const end = valueEnd(lines, index, key[0]);
+			section.entries.push({
+				path: [...section.path, ...keyPath(key[1] ?? "")],
+				key: key[1] ?? "",
+				from: from < 0 ? index : from,
+				start: index,
+				end,
+			});
+			section.end = end;
+			index = end;
+		}
+		from = -1;
+	}
+	return sections;
+};