typescript-bedrock 0.1.0 → 0.1.3

package/files/base/justfile

@@ -8,10 +8,11 @@ mod? typescript ".just/typescript.just"
 mod? rust ".just/rust.just"
 mod? swift ".just/swift.just"
 mod? cpp ".just/cpp.just"
+mod? jvm ".just/jvm.just"
 
 import? "project.just"
 
-languages := "typescript rust swift cpp"
+languages := "typescript rust swift cpp jvm"
 
 # List the recipes.
 default:

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/files/tsconfig.json

@@ -4,5 +4,5 @@
 	"compilerOptions": {
 		"rootDir": "."
 	},
-	"exclude": ["**/.build", "**/coverage", "**/dist", "**/target"]
+	"exclude": ["**/.build", "**/build", "**/coverage", "**/dist", "**/target"]
 }

package/oxlintrc.json

@@ -339,6 +339,12 @@
 				"import/no-default-export": "off"
 			}
 		},
+		{
+			"files": ["**/src/theme/**"],
+			"rules": {
+				"import/no-default-export": "off"
+			}
+		},
 		{
 			"files": ["**/*.d.{ts,mts,cts}"],
 			"rules": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typescript-bedrock",
-	"version": "0.1.0",
+	"version": "0.1.3",
 	"description": "Strictest Bun + TypeScript 7 tooling: shared configs, git hooks, a guard, and an adopt command.",
 	"license": "MIT",
 	"author": "xsyetopz",
@@ -28,7 +28,7 @@
 		"eslint-plugin-jsdoc": "65.4.5",
 		"markdownlint-cli2": "0.24.0",
 		"markdownlint-rule-title-case-style": "0.4.3",
-		"oxlint": "1.91.0",
+		"oxlint": "1.93.0",
 		"oxlint-tsgolint": "7.0.2006",
 		"typescript": "7.0.2"
 	},

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/blocks.ts

@@ -17,6 +17,7 @@ const ORDER = [
 	"rust-bedrock",
 	"swift-bedrock",
 	"swift-bedrock-cxx",
+	"jvm-bedrock",
 ];
 
 /** Where the first line starting with `marker` begins in `text`, or -1. */

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/tests.ts

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 
+import { listFiles } from "../files.ts";
 import type { Step } from "./steps.ts";
 
 const TEST_FILES = new Bun.Glob(
@@ -39,18 +40,15 @@ export const migrateTestFile = (text: string): string => {
 		: text;
 };
 
-/** Rewrites each test file outside node_modules that is not on bun:test yet. */
+/** Rewrites each test file outside node_modules and git's ignored files that is not on bun:test yet. */
 export const testSteps = async (target: string): Promise<Step[]> => {
-	const steps: Step[] = [];
-	for await (const path of TEST_FILES.scan({ cwd: target, dot: false })) {
-		if (path.split("/").includes("node_modules")) {
-			continue;
-		}
-		const text = await Bun.file(join(target, path)).text();
+	const paths = await listFiles(target, TEST_FILES);
+	const texts = await Promise.all(
+		paths.map((path) => Bun.file(join(target, path)).text()),
+	);
+	return paths.flatMap((path, index): Step[] => {
+		const text = texts[index] ?? "";
 		const content = migrateTestFile(text);
-		if (content !== text) {
-			steps.push({ kind: "write", path, content });
-		}
-	}
-	return steps;
+		return content === text ? [] : [{ kind: "write", path, content }];
+	});
 };

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;
+};

package/src/adopt/tsconfig.ts

@@ -23,8 +23,17 @@ const REMOVED_OPTIONS = new Set([
 /** Project facts the base config cannot know. */
 const PROJECT_OPTIONS = new Set(["jsx", "lib", "types"]);
 const BASE_FILE = "typescript-bedrock/tsconfig.base.json";
-/** Build output a repo can hold: Bun's, Rust's (`cargo doc` writes JavaScript), and SwiftPM's. */
-const GENERATED_DIRS = ["**/.build", "**/coverage", "**/dist", "**/target"];
+/**
+ * Build output a repo can hold: Bun's, Rust's (`cargo doc` writes JavaScript), SwiftPM's, and
+ * Gradle's (its test reports are JavaScript).
+ */
+const GENERATED_DIRS = [
+	"**/.build",
+	"**/build",
+	"**/coverage",
+	"**/dist",
+	"**/target",
+];
 const EMIT_OPTIONS = [
 	"composite",
 	"declaration",

package/src/files.ts

@@ -0,0 +1,23 @@
+import { join } from "node:path";
+
+import { $, type Glob } from "bun";
+
+/** The files under `cwd` that match `glob`, without the ones git ignores and without node_modules. */
+export const listFiles = async (cwd: string, glob: Glob): Promise<string[]> => {
+	const git = await $`git ls-files --cached --others --exclude-standard`
+		.cwd(cwd)
+		.nothrow()
+		.quiet();
+	const listed = (
+		git.exitCode === 0
+			? git.stdout.toString().split("\n")
+			: await Array.fromAsync(glob.scan({ cwd }))
+	).filter(
+		(path) => glob.match(path) && !path.split("/").includes("node_modules"),
+	);
+	// The index still lists a file deleted since the last commit.
+	const present = await Promise.all(
+		listed.map((path) => Bun.file(join(cwd, path)).exists()),
+	);
+	return listed.filter((_, index) => present[index] === true);
+};

package/src/guard.ts

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 import { $, Glob } from "bun";
 
 import { planAdoption, PROJECT_FILES } from "./adopt/adopt.ts";
+import { listFiles } from "./files.ts";
 
 // Written as alternations so this file does not match itself.
 const SUPPRESSION =
@@ -40,25 +41,6 @@ const FOREIGN_FILES = [
 	"yarn.lock",
 ];
 
-const listFiles = async (cwd: string, glob: Glob): Promise<string[]> => {
-	const git = await $`git ls-files --cached --others --exclude-standard`
-		.cwd(cwd)
-		.nothrow()
-		.quiet();
-	const listed = (
-		git.exitCode === 0
-			? git.stdout.toString().split("\n")
-			: await Array.fromAsync(glob.scan({ cwd }))
-	).filter(
-		(path) => glob.match(path) && !path.split("/").includes("node_modules"),
-	);
-	// The index still lists a file deleted since the last commit.
-	const present = await Promise.all(
-		listed.map((path) => Bun.file(join(cwd, path)).exists()),
-	);
-	return listed.filter((_, index) => present[index] === true);
-};
-
 export const findSuppressions = async (
 	cwd: string,
 	paths: readonly string[],