typescript-bedrock 0.1.2 → 0.1.4

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.4",
 	"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,7 +1,8 @@
 import { realpath } from "node:fs/promises";
 import { basename, join } from "node:path";
 
-import { asRecord, exists, type Json, readJsonc, toJson } from "./json.ts";
+import { copies, existing, planBunfig } from "./copies.ts";
+import { asRecord, type Json, readJsonc, toJson } from "./json.ts";
 import { migrateManifest } from "./manifest.ts";
 import { sharedSteps } from "./shared.ts";
 import { pending, type Step } from "./steps.ts";
@@ -99,7 +100,8 @@ export const BASE_FILES = [
 	".markdownlint.jsonc",
 	"justfile",
 ];
-/** Thin files that point at typescript-bedrock. A changed copy is backed up, then replaced. */
+/** Thin files that point at typescript-bedrock. A changed copy is backed up, then replaced,
+ * except the entries a repo adds to the ignore list of `.oxlintrc.json` or `.markdownlint-cli2.jsonc`, which stay. */
 const TOOL_FILES = [
 	".bun-version",
 	".github/workflows/typescript.yml",
@@ -113,46 +115,6 @@ const STARTER_FILES = [".vscode/extensions.json", ".vscode/settings.json"];
 const OLD_CI = ".github/workflows/ci.yml";
 const OLD_CI_COMMAND = /\b(?:npm|npx|pnpm|yarn)\b|bun run verify/u;
 
-const existing = async (
-	root: string,
-	paths: readonly string[],
-): Promise<string[]> => {
-	const found = await Promise.all(
-		paths.map((path) => exists(join(root, path))),
-	);
-	return paths.filter((_, index) => found[index] === true);
-};
-
-/** npm packs drop `bunfig.toml`, and linters read nested configs, so these keep a suffix. */
-const STORED_WITH_SUFFIX = new Set([
-	".markdownlint-cli2.jsonc",
-	".oxlintrc.json",
-	"bunfig.toml",
-]);
-const storedPath = (path: string): string =>
-	STORED_WITH_SUFFIX.has(path) ? `${path}.template` : path;
-
-const copyFile = async (dir: string, path: string): Promise<Step> => ({
-	kind: "write",
-	path,
-	content: await Bun.file(join(dir, storedPath(path))).text(),
-	executable: path.startsWith(".githooks/"),
-});
-
-const copies = async (
-	dir: string,
-	target: string,
-	paths: readonly string[],
-	overwrite: boolean,
-): Promise<Step[]> => {
-	const present = new Set(overwrite ? [] : await existing(target, paths));
-	return Promise.all(
-		paths
-			.filter((path) => !present.has(path))
-			.map((path) => copyFile(dir, path)),
-	);
-};
-
 const planManifest = async (
 	packageRoot: string,
 	target: string,
@@ -218,6 +180,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 +190,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 +201,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/copies.ts

@@ -0,0 +1,92 @@
+import { join } from "node:path";
+
+import { mergeBunfig } from "./bunfig.ts";
+import { IGNORE_KEYS, mergeIgnoreList } from "./ignore-lists.ts";
+import { exists, readJsonc } from "./json.ts";
+import type { Step } from "./steps.ts";
+
+/** The paths under `root` that exist. */
+export const existing = async (
+	root: string,
+	paths: readonly string[],
+): Promise<string[]> => {
+	const found = await Promise.all(
+		paths.map((path) => exists(join(root, path))),
+	);
+	return paths.filter((_, index) => found[index] === true);
+};
+
+/** npm packs drop `bunfig.toml`, and linters read nested configs, so these keep a suffix. */
+const STORED_WITH_SUFFIX = new Set([
+	".markdownlint-cli2.jsonc",
+	".oxlintrc.json",
+	"bunfig.toml",
+]);
+export const storedPath = (path: string): string =>
+	STORED_WITH_SUFFIX.has(path) ? `${path}.template` : path;
+
+/** The template's text, plus the ignore entries the repo's copy adds to it. */
+const contentOf = async (
+	dir: string,
+	target: string,
+	path: string,
+): Promise<string> => {
+	const template = await Bun.file(join(dir, storedPath(path))).text();
+	const key = IGNORE_KEYS[path];
+	return key === undefined
+		? template
+		: mergeIgnoreList(template, await readJsonc(join(target, path)), key);
+};
+
+const copyFile = async (
+	dir: string,
+	target: string,
+	path: string,
+): Promise<Step[]> => {
+	const content = await contentOf(dir, target, path);
+	// A repo's own layout of its ignore list stays when the data matches.
+	if (
+		path in IGNORE_KEYS &&
+		Bun.deepEquals(
+			Bun.JSONC.parse(content),
+			await readJsonc(join(target, path)),
+		)
+	) {
+		return [];
+	}
+	return [
+		{ kind: "write", path, content, executable: path.startsWith(".githooks/") },
+	];
+};
+
+/** Writes each of `paths` from `dir`; with `overwrite` off, only the ones `target` lacks. */
+export const copies = async (
+	dir: string,
+	target: string,
+	paths: readonly string[],
+	overwrite: boolean,
+): Promise<Step[]> => {
+	const present = new Set(overwrite ? [] : await existing(target, paths));
+	const steps = await Promise.all(
+		paths
+			.filter((path) => !present.has(path))
+			.map((path) => copyFile(dir, target, path)),
+	);
+	return steps.flat();
+};
+
+/** The template's `bunfig.toml` plus the settings the repo's copy adds. */
+export 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,
+	};
+};

package/src/adopt/ignore-lists.ts

@@ -0,0 +1,41 @@
+import { asRecord, asStrings } from "./json.ts";
+
+/** The ignore list each tool config keeps, which a repo may extend. */
+export const IGNORE_KEYS: Readonly<Record<string, string>> = {
+	".markdownlint-cli2.jsonc": "ignores",
+	".oxlintrc.json": "ignorePatterns",
+};
+
+const arrayOf = (key: string): RegExp =>
+	new RegExp(`("${key}"\\s*:\\s*)\\[([^\\]]*)\\]`, "u");
+
+/**
+ * Writes the template's config with the entries `current` lists under `key`
+ * and the template lacks added after the template's own, in the template's
+ * layout and with its comments.
+ */
+export const mergeIgnoreList = (
+	template: string,
+	current: unknown,
+	key: string,
+): string => {
+	const found = arrayOf(key).exec(template);
+	if (found === null) {
+		return template;
+	}
+	const have = new Set(asStrings(Bun.JSONC.parse(`[${found[2] ?? ""}]`)));
+	const extra = [
+		...new Set(asStrings(asRecord(current)[key]).filter((e) => !have.has(e))),
+	];
+	if (extra.length === 0) {
+		return template;
+	}
+	const items = [...have, ...extra].map((entry) => JSON.stringify(entry));
+	const body = (found[2] ?? "").includes("\n")
+		? `\n${items.map((item) => `\t\t${item}`).join(",\n")}\n\t`
+		: items.join(", ");
+	return template.replace(
+		arrayOf(key),
+		(_, head: string) => `${head}[${body}]`,
+	);
+};

package/src/adopt/tests.ts

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 
 import { listFiles } from "../files.ts";
+import { readBunfigTestIgnores } from "../ignores.ts";
 import type { Step } from "./steps.ts";
 
 const TEST_FILES = new Bun.Glob(
@@ -40,9 +41,16 @@ export const migrateTestFile = (text: string): string => {
 		: text;
 };
 
-/** Rewrites each test file outside node_modules and git's ignored files that is not on bun:test yet. */
+/**
+ * Rewrites each test file that is not on bun:test yet, except those in node_modules,
+ * those git ignores, and those bunfig.toml keeps `bun test` from running.
+ */
 export const testSteps = async (target: string): Promise<Step[]> => {
-	const paths = await listFiles(target, TEST_FILES);
+	const paths = await listFiles(
+		target,
+		TEST_FILES,
+		await readBunfigTestIgnores(target),
+	);
 	const texts = await Promise.all(
 		paths.map((path) => Bun.file(join(target, path)).text()),
 	);

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

@@ -2,8 +2,17 @@ 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[]> => {
+import { isIgnored } from "./ignores.ts";
+
+/**
+ * The files under `cwd` that match `glob`, without the ones git ignores, the
+ * ones `ignore` matches, and node_modules.
+ */
+export const listFiles = async (
+	cwd: string,
+	glob: Glob,
+	ignore: readonly string[] = [],
+): Promise<string[]> => {
 	const git = await $`git ls-files --cached --others --exclude-standard`
 		.cwd(cwd)
 		.nothrow()
@@ -13,7 +22,10 @@ export const listFiles = async (cwd: string, glob: Glob): Promise<string[]> => {
 			? git.stdout.toString().split("\n")
 			: await Array.fromAsync(glob.scan({ cwd }))
 	).filter(
-		(path) => glob.match(path) && !path.split("/").includes("node_modules"),
+		(path) =>
+			glob.match(path) &&
+			!path.split("/").includes("node_modules") &&
+			!isIgnored(path, ignore),
 	);
 	// The index still lists a file deleted since the last commit.
 	const present = await Promise.all(

package/src/guard.ts

@@ -5,6 +5,7 @@ import { $, Glob } from "bun";
 
 import { planAdoption, PROJECT_FILES } from "./adopt/adopt.ts";
 import { listFiles } from "./files.ts";
+import { readOxlintIgnores } from "./ignores.ts";
 
 // Written as alternations so this file does not match itself.
 const SUPPRESSION =
@@ -181,9 +182,12 @@ const reExported = (
  * The tracked source files each package exposes: its entry points and, through
  * relative re-exports, the files they re-export from.
  */
-const listApiFiles = async (cwd: string): Promise<string[]> => {
-	const sources = new Set(await listFiles(cwd, SOURCE));
-	const manifests = await listFiles(cwd, MANIFEST);
+const listApiFiles = async (
+	cwd: string,
+	ignore: readonly string[],
+): Promise<string[]> => {
+	const sources = new Set(await listFiles(cwd, SOURCE, ignore));
+	const manifests = await listFiles(cwd, MANIFEST, ignore);
 	const entries = await Promise.all(
 		manifests.map(async (path) => {
 			const manifest: unknown = await Bun.file(join(cwd, path)).json();
@@ -215,8 +219,11 @@ const listApiFiles = async (cwd: string): Promise<string[]> => {
 };
 
 /** Exported declarations in the package API that lack a JSDoc comment. */
-const findUndocumentedApi = async (cwd: string): Promise<string[]> => {
-	const files = await listApiFiles(cwd);
+const findUndocumentedApi = async (
+	cwd: string,
+	ignore: readonly string[],
+): Promise<string[]> => {
+	const files = await listApiFiles(cwd, ignore);
 	if (files.length === 0) {
 		return [];
 	}
@@ -255,15 +262,18 @@ const findDrift = async (cwd: string): Promise<string[]> => {
 		);
 };
 
-export const findProblems = async (cwd: string): Promise<string[]> => [
-	...(await findSuppressions(cwd, await listFiles(cwd, SOURCE))),
-	...(await findUndocumentedApi(cwd)),
-	...(await findForeignFiles(cwd)),
-	...(await findForeignScripts(cwd)),
-	...(await findTypescriptDrift(cwd)),
-	...findUnsortedCatalogs(await Bun.file(join(cwd, "package.json")).json()),
-	...(await findDrift(cwd)),
-];
+export const findProblems = async (cwd: string): Promise<string[]> => {
+	const ignore = await readOxlintIgnores(cwd);
+	return [
+		...(await findSuppressions(cwd, await listFiles(cwd, SOURCE, ignore))),
+		...(await findUndocumentedApi(cwd, ignore)),
+		...(await findForeignFiles(cwd)),
+		...(await findForeignScripts(cwd)),
+		...(await findTypescriptDrift(cwd)),
+		...findUnsortedCatalogs(await Bun.file(join(cwd, "package.json")).json()),
+		...(await findDrift(cwd)),
+	];
+};
 
 export const guard = async (cwd: string): Promise<number> => {
 	const problems = await findProblems(cwd);

package/src/ignores.ts

@@ -0,0 +1,55 @@
+import { join } from "node:path";
+
+import { Glob } from "bun";
+
+import { asRecord, asStrings, readJsonc } from "./adopt/json.ts";
+
+/** The globs a gitignore-style `pattern` stands for: the path itself and what is under it. */
+const globsOf = (pattern: string): string[] => {
+	const dir = pattern.replace(/\/+$/u, "");
+	const anchored = dir.startsWith("/") || dir.includes("/", 1);
+	const base = dir.replace(/^\//u, "");
+	const glob = anchored ? base : `**/${base}`;
+	return [glob, `${glob}/**`];
+};
+
+/**
+ * Whether `path`, relative to the repo root, matches `patterns`: gitignore-style
+ * entries (a bare name matches at any depth, `dir/` matches a directory, a
+ * later `!entry` re-includes) that Bun's glob syntax can read.
+ */
+export const isIgnored = (
+	path: string,
+	patterns: readonly string[],
+): boolean => {
+	let ignored = false;
+	for (const entry of patterns) {
+		const negated = entry.startsWith("!");
+		const pattern = negated ? entry.slice(1) : entry;
+		if (
+			pattern !== "" &&
+			globsOf(pattern).some((glob) => new Glob(glob).match(path))
+		) {
+			ignored = !negated;
+		}
+	}
+	return ignored;
+};
+
+/** The `ignorePatterns` of the repo's `.oxlintrc.json`, which the repo may extend. */
+export const readOxlintIgnores = async (cwd: string): Promise<string[]> =>
+	asStrings(
+		asRecord(await readJsonc(join(cwd, ".oxlintrc.json")))["ignorePatterns"],
+	);
+
+/** The `[test] pathIgnorePatterns` of the repo's `bunfig.toml`: the paths `bun test` skips. */
+export const readBunfigTestIgnores = async (cwd: string): Promise<string[]> => {
+	const file = Bun.file(join(cwd, "bunfig.toml"));
+	if (!(await file.exists())) {
+		return [];
+	}
+	const patterns = asRecord(
+		asRecord(Bun.TOML.parse(await file.text()))["test"],
+	)["pathIgnorePatterns"];
+	return typeof patterns === "string" ? [patterns] : asStrings(patterns);
+};