svn-visualizer 0.1.0

package/dist/index.js

@@ -0,0 +1,474 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { spawn } from "node:child_process";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { XMLParser } from "fast-xml-parser";
+import { SyntaxValidator } from "fast-xml-validator";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/model.ts
+var commitSchema = z.object({
+	revision: z.number().int().positive(),
+	author: z.string().nullable(),
+	date: z.iso.datetime({ offset: true }),
+	message: z.string()
+}).strict();
+var sourceSchema = z.object({
+	requestedUrl: z.url(),
+	root: z.url(),
+	uuid: z.string().min(1)
+}).strict();
+var dataSchema = z.object({
+	schemaVersion: z.literal(1),
+	source: sourceSchema,
+	lastRevision: z.number().int().nonnegative(),
+	gatheredAt: z.iso.datetime({ offset: true }),
+	commits: z.array(commitSchema)
+}).strict();
+//#endregion
+//#region src/svn-parser.ts
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseTagValue: false,
+	trimValues: false,
+	isArray: (_name, path) => path === "log.logentry"
+});
+var infoXmlSchema = z.object({ info: z.object({ entry: z.object({
+	"@_revision": z.coerce.number().int().nonnegative(),
+	repository: z.object({
+		root: z.string().min(1),
+		uuid: z.string().min(1)
+	})
+}) }) });
+var logContentsSchema = z.object({ logentry: z.array(z.object({
+	"@_revision": z.coerce.number().int().positive(),
+	author: z.union([z.string(), z.record(z.string(), z.never())]).optional(),
+	date: z.string(),
+	msg: z.union([z.string(), z.record(z.string(), z.never())]).optional()
+})).default([]) });
+var logXmlSchema = z.object({ log: z.union([logContentsSchema, z.literal("")]) });
+function parseXml(xml) {
+	try {
+		SyntaxValidator.validate(xml);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid SVN XML: ${message}`, { cause: error });
+	}
+	return parser.parse(xml);
+}
+function text(value) {
+	return typeof value === "string" ? value : "";
+}
+function parseInfoXml(xml, requestedUrl) {
+	const parsed = infoXmlSchema.parse(parseXml(xml));
+	return sourceSchema.parse({
+		requestedUrl,
+		root: parsed.info.entry.repository.root,
+		uuid: parsed.info.entry.repository.uuid
+	});
+}
+function parseInfoRevision(xml) {
+	return infoXmlSchema.parse(parseXml(xml)).info.entry["@_revision"];
+}
+function parseLogXml(xml) {
+	const parsed = logXmlSchema.parse(parseXml(xml));
+	if (parsed.log === "") return [];
+	return parsed.log.logentry.map((entry) => commitSchema.parse({
+		revision: entry["@_revision"],
+		author: entry.author === void 0 ? null : text(entry.author),
+		date: entry.date,
+		message: text(entry.msg)
+	}));
+}
+//#endregion
+//#region src/store.ts
+async function readData(filePath) {
+	let content;
+	try {
+		content = await readFile(filePath, "utf8");
+	} catch (error) {
+		throw new Error(`Unable to read data file ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	try {
+		return dataSchema.parse(JSON.parse(content));
+	} catch (error) {
+		throw new Error(`Invalid data file ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}
+function assertSameSource(existing, current) {
+	if (existing.requestedUrl !== current.requestedUrl || existing.root !== current.root || existing.uuid !== current.uuid) throw new Error("Data file source does not match the requested SVN repository");
+}
+function mergeCommits(existing, incoming) {
+	const byRevision = /* @__PURE__ */ new Map();
+	for (const commit of [...existing, ...incoming]) byRevision.set(commit.revision, commit);
+	return [...byRevision.values()].sort((left, right) => left.revision - right.revision);
+}
+function revisionCheckpoint(previous, repositoryHead) {
+	return Math.max(previous, repositoryHead);
+}
+async function writeData(filePath, data) {
+	const validated = dataSchema.parse(data);
+	const directory = path.dirname(path.resolve(filePath));
+	await mkdir(directory, { recursive: true });
+	const temporary = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+	try {
+		await writeFile(temporary, `${JSON.stringify(validated, null, "	")}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+		await rename(temporary, path.resolve(filePath));
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+//#endregion
+//#region src/gather.ts
+var gatherOptionsSchema = z.object({
+	url: z.url(),
+	username: z.string().min(1).optional(),
+	passwordEnv: z.string().regex(/^[a-z_]\w*$/iu),
+	dataFile: z.string().min(1),
+	svnBinary: z.string().min(1)
+});
+function runSvn(binary, arguments_, password) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, arguments_, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8").on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.setEncoding("utf8").on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			reject(new Error(`Unable to run ${binary}: ${error.message}`, { cause: error }));
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve({
+				stdout,
+				stderr
+			});
+			else reject(/* @__PURE__ */ new Error(`${binary} exited with code ${String(code)}: ${stderr.trim()}`));
+		});
+		child.stdin.end(password === void 0 ? void 0 : `${password}\n`);
+	});
+}
+function authArguments(username, password) {
+	const result = ["--non-interactive", "--trust-server-cert-failures=unknown-ca,cn-mismatch,expired,not-yet-valid,other"];
+	if (username !== void 0) result.push("--username", username);
+	if (password !== void 0) result.push("--password-from-stdin", "--no-auth-cache");
+	return result;
+}
+async function existingData(filePath) {
+	try {
+		await access(filePath);
+	} catch {
+		return;
+	}
+	return readData(filePath);
+}
+async function gather(rawOptions) {
+	const options = gatherOptionsSchema.parse(rawOptions);
+	const password = process.env[options.passwordEnv];
+	const auth = authArguments(options.username, password);
+	const info = await runSvn(options.svnBinary, [
+		"info",
+		"--xml",
+		...auth,
+		options.url
+	], password);
+	const source = parseInfoXml(info.stdout, options.url);
+	const headRevision = parseInfoRevision(info.stdout);
+	const previous = await existingData(options.dataFile);
+	if (previous !== void 0) assertSameSource(previous.source, source);
+	const lastRevision = previous?.lastRevision ?? 0;
+	let incoming = [];
+	if (lastRevision < headRevision) incoming = parseLogXml((await runSvn(options.svnBinary, [
+		"log",
+		"--xml",
+		...auth,
+		"--revision",
+		`${lastRevision + 1}:HEAD`,
+		options.url
+	], password)).stdout);
+	const commits = mergeCommits(previous?.commits ?? [], incoming);
+	const data = {
+		schemaVersion: 1,
+		source,
+		lastRevision: revisionCheckpoint(lastRevision, headRevision),
+		gatheredAt: (/* @__PURE__ */ new Date()).toISOString(),
+		commits
+	};
+	await writeData(options.dataFile, data);
+	return {
+		added: incoming.length,
+		data
+	};
+}
+//#endregion
+//#region src/aggregation.ts
+var DAY_MS = 864e5;
+var dateTextSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/u, "Expected YYYY-MM-DD");
+var OTHER_CONTRIBUTORS_LABEL = "(others)";
+function parseDateText(value) {
+	dateTextSchema.parse(value);
+	const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+	if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) throw new Error(`Invalid UTC date: ${value}`);
+	return date;
+}
+function dateText(date) {
+	return date.toISOString().slice(0, 10);
+}
+function addDays(value, amount) {
+	const date = parseDateText(value);
+	return dateText(new Date(date.getTime() + amount * DAY_MS));
+}
+function datasetBounds(commits, today) {
+	if (commits.length === 0) return {
+		from: today,
+		to: today
+	};
+	const dates = commits.map((commit) => commit.date.slice(0, 10)).sort();
+	const [first] = dates;
+	const last = dates.at(-1);
+	if (first === void 0 || last === void 0) return {
+		from: today,
+		to: today
+	};
+	return {
+		from: first,
+		to: last
+	};
+}
+function resolveRange(commits, options, now = /* @__PURE__ */ new Date()) {
+	const today = dateText(now);
+	parseDateText(today);
+	if (options.relativeDays !== void 0) {
+		if (options.from !== void 0 || options.to !== void 0) throw new Error("--from/--to cannot be used with --relative-days");
+		if (!Number.isInteger(options.relativeDays) || options.relativeDays <= 0) throw new Error("--relative-days must be a positive integer");
+		return {
+			from: addDays(today, 1 - options.relativeDays),
+			to: today
+		};
+	}
+	const bounds = datasetBounds(commits, today);
+	const from = options.from ?? bounds.from;
+	const to = options.to ?? bounds.to;
+	parseDateText(from);
+	parseDateText(to);
+	if (from > to) throw new Error(`Report start date ${from} is after end date ${to}`);
+	return {
+		from,
+		to
+	};
+}
+function countSeries(labels, keys) {
+	const counts = new Map(labels.map((label) => [label, 0]));
+	for (const key of keys) if (counts.has(key)) counts.set(key, (counts.get(key) ?? 0) + 1);
+	return {
+		labels: [...labels],
+		values: labels.map((label) => counts.get(label) ?? 0)
+	};
+}
+function countStackedSeries(labels, buckets, entries) {
+	const bucketValues = new Map(buckets.map((bucket) => [bucket, Array.from({ length: labels.length }, () => 0)]));
+	const indexByLabel = new Map(labels.map((label, index) => [label, index]));
+	for (const { key, bucket } of entries) {
+		const values = bucketValues.get(bucket);
+		const index = indexByLabel.get(key);
+		if (values === void 0 || index === void 0) continue;
+		values[index] = (values[index] ?? 0) + 1;
+	}
+	return {
+		labels: [...labels],
+		datasets: buckets.map((bucket) => ({
+			label: bucket,
+			values: [...bucketValues.get(bucket) ?? []]
+		}))
+	};
+}
+function monthLabels(end) {
+	const endDate = parseDateText(end);
+	const result = [];
+	for (let offset = 11; offset >= 0; offset--) result.push(dateText(new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - offset, 1))).slice(0, 7));
+	return result;
+}
+function aggregate(commits, range) {
+	parseDateText(range.from);
+	parseDateText(range.to);
+	if (range.from > range.to) throw new Error("Report date range is reversed");
+	const selected = commits.filter((commit) => {
+		const date = commit.date.slice(0, 10);
+		return date >= range.from && date <= range.to;
+	});
+	const userCounts = /* @__PURE__ */ new Map();
+	for (const commit of selected) {
+		const author = commit.author === null || commit.author === "" ? "(no author)" : commit.author;
+		userCounts.set(author, (userCounts.get(author) ?? 0) + 1);
+	}
+	const ranked = [...userCounts.entries()].sort(([leftName, leftCount], [rightName, rightCount]) => rightCount - leftCount || leftName.localeCompare(rightName));
+	let userLabels;
+	let userValues;
+	const bucketOf = /* @__PURE__ */ new Map();
+	if (ranked.length > 10) {
+		const top = ranked.slice(0, 10);
+		const others = ranked.slice(10).reduce((sum, [, count]) => sum + count, 0);
+		userLabels = [...top.map(([name]) => name), OTHER_CONTRIBUTORS_LABEL];
+		userValues = [...top.map(([, count]) => count), others];
+		for (const [name] of top) bucketOf.set(name, name);
+		for (const [name] of ranked.slice(10)) bucketOf.set(name, OTHER_CONTRIBUTORS_LABEL);
+	} else {
+		userLabels = ranked.map(([name]) => name);
+		userValues = ranked.map(([, count]) => count);
+		for (const [name] of ranked) bucketOf.set(name, name);
+	}
+	const weekdayLabels = [
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday",
+		"Sunday"
+	];
+	const hourLabels = Array.from({ length: 24 }, (_, hour) => hour.toString().padStart(2, "0"));
+	const dayLabels = Array.from({ length: 30 }, (_, index) => addDays(range.to, index - 29));
+	const months = monthLabels(range.to);
+	const recent = [...selected].sort((left, right) => right.revision - left.revision).slice(0, 20);
+	const daysByUser = countStackedSeries(dayLabels, userLabels, selected.map((commit) => {
+		const author = commit.author === null || commit.author === "" ? "(no author)" : commit.author;
+		return {
+			key: commit.date.slice(0, 10),
+			bucket: bucketOf.get(author) ?? "(others)"
+		};
+	}));
+	return {
+		range,
+		total: selected.length,
+		users: {
+			labels: userLabels,
+			values: userValues
+		},
+		weekdays: countSeries(weekdayLabels, selected.map((commit) => weekdayLabels[(new Date(commit.date).getUTCDay() + 6) % 7] ?? "Monday")),
+		hours: countSeries(hourLabels, selected.map((commit) => new Date(commit.date).getUTCHours().toString().padStart(2, "0"))),
+		days: countSeries(dayLabels, selected.map((commit) => commit.date.slice(0, 10))),
+		daysByUser,
+		months: countSeries(months, selected.map((commit) => commit.date.slice(0, 7))),
+		recent
+	};
+}
+//#endregion
+//#region src/report.ts
+var generateOptionsSchema = z.object({
+	dataFile: z.string().min(1),
+	outputDir: z.string().min(1),
+	from: z.string().optional(),
+	to: z.string().optional(),
+	relativeDays: z.number().int().positive().optional(),
+	title: z.string().min(1).default("Subversion activity")
+});
+function escapeHtml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function safeJson(value) {
+	return JSON.stringify(value).replaceAll("&", String.raw`\u0026`).replaceAll("<", String.raw`\u003c`).replaceAll(">", String.raw`\u003e`).replaceAll("\u2028", String.raw`\u2028`).replaceAll("\u2029", String.raw`\u2029`);
+}
+function renderHtml(data, clientScript) {
+	const title = escapeHtml(data.title);
+	const source = escapeHtml(data.sourceUrl);
+	return `<!doctype html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width,initial-scale=1">
+	<title>${title}</title>
+	<style>
+		:root{color-scheme:dark;--ink:#f4efe4;--muted:#aaa69d;--panel:#18201f;--line:#34413e;--accent:#f3b33d;--cool:#6dc8bf}*{box-sizing:border-box}body{margin:0;background:#0c1110;color:var(--ink);font:16px/1.5 Inter,ui-sans-serif,system-ui,sans-serif}body:before{content:"";position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 80% 0,#24423b 0,transparent 38%),linear-gradient(120deg,transparent 0 48%,#ffffff05 48% 49%,transparent 49%);z-index:-1}.wrap{width:min(1180px,calc(100% - 32px));margin:auto;padding:56px 0 72px}header{border-left:5px solid var(--accent);padding-left:24px;margin-bottom:36px}h1{font-family:Georgia,serif;font-size:clamp(2.25rem,6vw,5rem);font-weight:500;line-height:.95;letter-spacing:-.045em;margin:0 0 20px}.eyebrow{color:var(--accent);font-size:.75rem;font-weight:800;letter-spacing:.18em;text-transform:uppercase}.meta{display:flex;flex-wrap:wrap;gap:8px 24px;color:var(--muted);font-size:.875rem}.meta a{color:var(--cool);overflow-wrap:anywhere}.total{display:grid;grid-template-columns:auto 1fr;align-items:end;gap:18px;margin:28px 0}.total strong{font:500 clamp(4rem,14vw,9rem)/.8 Georgia,serif;color:var(--accent)}.total span{max-width:12rem;color:var(--muted);text-transform:uppercase;letter-spacing:.12em;font-weight:700}.grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:18px}.card{min-width:0;background:color-mix(in srgb,var(--panel) 94%,transparent);border:1px solid var(--line);border-radius:4px;padding:22px;box-shadow:0 16px 42px #0003}.card.wide{grid-column:1/-1}.card h2{font:500 1.25rem Georgia,serif;margin:0 0 18px}.chart{position:relative;height:280px}.wide .chart{height:330px}table.commits{width:100%;border-collapse:collapse;font-size:.875rem}table.commits th,table.commits td{text-align:left;padding:9px 12px;border-bottom:1px solid var(--line);vertical-align:top}table.commits th{color:var(--muted);font-size:.7rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase}table.commits td.rev{color:var(--accent);font-variant-numeric:tabular-nums;white-space:nowrap}table.commits td.date{white-space:nowrap;color:var(--muted)}table.commits .msg{overflow-wrap:anywhere}table.commits tbody tr:last-child td{border-bottom:none}footer{color:var(--muted);font-size:.75rem;margin-top:24px;text-align:right}@media(max-width:720px){.wrap{padding-top:32px}.grid{grid-template-columns:1fr}.card.wide{grid-column:auto}.chart,.wide .chart{height:260px}}
+	</style>
+</head>
+<body>
+	<main class="wrap">
+		<header><div class="eyebrow">Repository pulse / UTC</div><h1>${title}</h1><div class="meta"><span>${escapeHtml(data.range.from)} to ${escapeHtml(data.range.to)}</span><a href="${source}">${source}</a></div></header>
+		<section class="total" aria-label="Commit total"><strong>${String(data.total)}</strong><span>commits in selected period</span></section>
+		<section class="grid">
+			<article class="card wide"><h2>Last 30 days</h2><div class="chart"><canvas id="days" role="img" aria-label="Commits per day">Chart: commits per day.</canvas></div></article>
+			<article class="card wide"><h2>Commits per day and user</h2><div class="chart"><canvas id="days-by-user" role="img" aria-label="Commits per day and user">Chart: commits per day and user.</canvas></div></article>
+			<article class="card wide"><h2>Current and previous 11 months</h2><div class="chart"><canvas id="months" role="img" aria-label="Commits per month">Chart: commits per month.</canvas></div></article>
+			<article class="card"><h2>Contributors</h2><div class="chart"><canvas id="users" role="img" aria-label="Commits by contributor">Chart: commits by contributor.</canvas></div></article>
+			<article class="card"><h2>Weekday</h2><div class="chart"><canvas id="weekdays" role="img" aria-label="Commits by weekday in UTC">Chart: commits by weekday in UTC.</canvas></div></article>
+			<article class="card wide"><h2>Hour of day (UTC)</h2><div class="chart"><canvas id="hours" role="img" aria-label="Commits by hour in UTC">Chart: commits by hour in UTC.</canvas></div></article>
+			<article class="card wide"><h2>Recent commits</h2><table class="commits"><thead><tr><th>Revision</th><th>Author</th><th>Date (UTC)</th><th>Message</th></tr></thead><tbody id="commits"></tbody></table></article>
+		</section>
+		<footer>Generated ${escapeHtml(data.generatedAt)} · All dates and times UTC</footer>
+	</main>
+	<script id="report-data" type="application/json">${safeJson(data)}<\/script>
+	<script type="module">${clientScript.replaceAll("<\/script", String.raw`<\/script`)}<\/script>
+</body>
+</html>\n`;
+}
+async function generate(rawOptions, clientScript) {
+	const options = generateOptionsSchema.parse(rawOptions);
+	const data = await readData(options.dataFile);
+	const range = resolveRange(data.commits, options);
+	const reportData = {
+		...aggregate(data.commits, range),
+		title: options.title,
+		sourceUrl: data.source.requestedUrl,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const clientUrl = new URL("client/main.js", import.meta.url);
+	const script = clientScript ?? await readFile(fileURLToPath(clientUrl), "utf8");
+	const outputFile = path.resolve(options.outputDir, "index.html");
+	await mkdir(path.dirname(outputFile), { recursive: true });
+	await writeFile(outputFile, renderHtml(reportData, script), "utf8");
+	return outputFile;
+}
+//#endregion
+//#region src/cli.ts
+function positiveInteger(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error("Expected a positive integer");
+	return parsed;
+}
+function gatherOptions(command) {
+	return command.requiredOption("--url <url>", "SVN repository URL").option("--username <username>", "SVN username").option("--password-env <name>", "environment variable containing the SVN password", "SVN_PASSWORD").option("--data-file <path>", "JSON state file", "svn-data.json").option("--svn-binary <path>", "SVN executable", "svn");
+}
+function generateOptions(command, includeDataFile = true) {
+	if (includeDataFile) command.option("--data-file <path>", "JSON state file", "svn-data.json");
+	return command.option("--output-dir <path>", "report output directory", "output").option("--from <date>", "first UTC date (YYYY-MM-DD)").option("--to <date>", "last UTC date (YYYY-MM-DD)").addOption(new Option("--relative-days <days>", "rolling number of UTC days").argParser(positiveInteger)).option("--title <title>", "report title", "Subversion activity");
+}
+function createProgram() {
+	const program = new Command().name("svn-visualizer").description("Generate standalone HTML activity reports from Subversion history").version("0.1.0");
+	gatherOptions(program.command("gather").description("Incrementally gather SVN history")).action(async (options) => {
+		const result = await gather(options);
+		console.log(result.added === 0 ? "No new commits." : `Gathered ${String(result.added)} new commit(s).`);
+	});
+	generateOptions(program.command("generate").description("Generate a standalone HTML report")).action(async (options) => {
+		const output = await generate(options);
+		console.log(`Generated ${output}`);
+	});
+	generateOptions(gatherOptions(program.command("report").description("Gather history and generate a report")), false).action(async (options) => {
+		const result = await gather(options);
+		console.log(result.added === 0 ? "No new commits." : `Gathered ${String(result.added)} new commit(s).`);
+		const output = await generate(options);
+		console.log(`Generated ${output}`);
+	});
+	return program;
+}
+//#endregion
+//#region src/index.ts
+try {
+	await createProgram().parseAsync();
+} catch (error) {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+}
+//#endregion
+export {};

package/oxc.config.ts

@@ -0,0 +1,198 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════════════
+ * DO NOT EDIT THIS FILE — IT IS MANAGED AND WILL BE OVERWRITTEN ON UPDATES.
+ * ═══════════════════════════════════════════════════════════════════════════
+ *
+ * This file is the source of truth for the default `oxlint` and `oxfmt`
+ * configuration. It is automatically regenerated when the template is
+ * updated — any manual changes will be lost.
+ *
+ * To customize linting rules, edit `oxlint.config.ts`.
+ * To customize formatting settings, edit `oxfmt.config.ts`.
+ *
+ * Those two files are preserved across template updates and are designed
+ * to receive user overrides.
+ */
+
+import {defineConfig} from 'oxlint';
+import {configs as regexpConfigs} from 'eslint-plugin-regexp';
+
+/** Filter out core ESLint rules bundled into eslint-plugin-regexp recommended config */
+const regexpPluginRules = Object.fromEntries(Object.entries(regexpConfigs.recommended.rules).filter(([key]) => key.startsWith('regexp/')));
+
+const commonIgnore = ['**/.*', 'node_modules/**', 'dist/**', 'build/**', 'coverage/**', 'temp/**', 'public/**', '**/*.md'];
+
+export const linter = defineConfig({
+	options: {
+		typeAware: true,
+		typeCheck: true,
+	},
+	plugins: ['unicorn', 'typescript', 'oxc', 'import', 'react', 'jsdoc', 'promise', 'vitest'],
+	jsPlugins: ['eslint-plugin-regexp'],
+	categories: {
+		correctness: 'error',
+		nursery: 'error',
+		pedantic: 'error',
+		perf: 'error',
+		restriction: 'error',
+		style: 'error',
+		suspicious: 'error',
+	},
+	rules: {
+		...regexpPluginRules,
+		'eslint/capitalized-comments': 'off', // TODO: consider enabling
+		'eslint/complexity': 'off', // TODO: consider enabling
+		'eslint/curly': ['error', 'all'],
+		'eslint/id-length': 'off',
+		'eslint/init-declarations': 'off', // TODO: consider enabling
+		'eslint/max-depth': 'off', // TODO: consider enabling
+		'eslint/max-lines': 'off', // TODO: consider enabling
+		'eslint/max-lines-per-function': 'off', // TODO: consider enabling
+		'eslint/max-params': 'off', // TODO: consider enabling
+		'eslint/max-statements': 'off', // TODO: consider enabling
+		'eslint/no-await-in-loop': 'warn',
+		'eslint/no-console': 'off',
+		'eslint/no-continue': 'off',
+		'eslint/no-inline-comments': 'off',
+		'eslint/no-magic-numbers': 'off',
+		'eslint/no-negated-condition': 'off', // TODO: consider enabling
+		'eslint/no-nested-ternary': 'off',
+		'eslint/no-warning-comments': 'off',
+		'eslint/no-undefined': 'off', // TODO: consider enabling
+		'eslint/no-plusplus': 'off',
+		'eslint/one-var': 'off',
+		'eslint/sort-imports': 'off',
+		'eslint/sort-keys': 'off',
+		'eslint/no-ternary': 'off',
+		'eslint/no-void': ['error', {allowAsStatement: true}],
+		'typescript/consistent-type-definitions': ['error', 'type'],
+		'typescript/dot-notation': ['error', {allowPattern: '^[a-zA-Z]+(_[a-zA-Z]+)+$'}],
+		'typescript/no-import-type-side-effects': 'off',
+		'typescript/no-unused-vars': [
+			'error',
+			{
+				caughtErrors: 'none',
+				argsIgnorePattern: '^_',
+			},
+		],
+		'typescript/prefer-readonly-parameter-types': 'off',
+		'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
+		'import/exports-last': 'off',
+		'import/group-exports': 'off',
+		'import/max-dependencies': 'off',
+		'import/no-named-export': 'off',
+		'import/no-namespace': 'off', // TODO: consider enabling
+		'import/no-nodejs-modules': 'off',
+		'import/no-unassigned-import': ['error', {allow: ['**/*.css']}],
+		'import/prefer-default-export': 'off',
+		'import/no-default-export': 'off',
+		'jsdoc/require-param': 'error',
+		'jsdoc/require-param-type': 'off',
+		'jsdoc/require-returns': 'warn',
+		'jsdoc/require-returns-type': 'off',
+		'oxc/no-async-await': 'off',
+		'oxc/no-map-spread': 'off', // TODO: consider enabling
+		'oxc/no-optional-chaining': 'off',
+		'oxc/no-rest-spread-properties': 'off',
+		'unicorn/escape-case': 'off',
+		'unicorn/filename-case': 'off', // TODO: consider enabling
+		'unicorn/max-nested-calls': ['warn', {max: 5}],
+		'unicorn/no-array-reduce': 'off', // TODO: consider enabling
+		'unicorn/no-array-sort': 'off', // TODO: consider enabling
+		'unicorn/no-hex-escape': 'off',
+		'unicorn/no-immediate-mutation': 'off',
+		'unicorn/no-negated-condition': 'off',
+		'unicorn/no-nested-ternary': 'off',
+		'unicorn/no-null': 'off', // TODO: consider enabling
+		'unicorn/no-process-exit': 'off', // TODO: consider enabling
+		'unicorn/no-typeof-undefined': 'off', // TODO: consider enabling
+		'unicorn/prefer-module': 'off', // TODO: consider enabling
+		'unicorn/prefer-number-coercion': 'off', // TODO: consider enabling
+		'react/function-component-definition': 'off', // TODO: consider enabling
+		'react/jsx-filename-extension': ['error', {extensions: ['.tsx']}],
+		'react/jsx-max-depth': ['error', {max: 5}],
+		'react/jsx-no-literals': 'off',
+		'react/react-in-jsx-scope': 'off',
+		'vitest/max-expects': 'off',
+		'vitest/no-conditional-in-test': 'off',
+		'vitest/no-hooks': 'off',
+		'vitest/no-importing-vitest-globals': 'off',
+		'vitest/prefer-describe-function-title': 'off',
+		'vitest/prefer-expect-assertions': 'off',
+		'vitest/prefer-lowercase-title': 'off',
+		'vitest/prefer-to-be-falsy': 'off', // NOTE: Pick strictness: keep prefer-strict-boolean-matchers, disable truthy/falsy rules.
+		'vitest/prefer-to-be-truthy': 'off', // NOTE: Pick strictness: keep prefer-strict-boolean-matchers, disable truthy/falsy rules.
+		'vitest/require-hook': 'off',
+		'vitest/require-test-timeout': 'off',
+	},
+	overrides: [
+		{
+			// Relax strict type rules for unit tests to allow easier mocking and test scaffolding
+			files: ['**/*.test.ts', '**/*.test.tsx', '**/*.spec.ts', '**/*.spec.tsx'],
+			rules: {
+				'typescript/no-unsafe-type-assertion': 'off',
+				'typescript/no-explicit-any': 'off',
+				'typescript/no-unsafe-assignment': 'off',
+				'typescript/no-unsafe-member-access': 'off',
+				'no-useless-undefined': 'off',
+			},
+		},
+		{
+			files: ['tests/e2e/**/*.e2e-test.ts', '**/*.e2e-test.ts'],
+			rules: {
+				'vitest/prefer-importing-vitest-globals': 'off',
+			},
+		},
+	],
+	settings: {
+		'jsx-a11y': {
+			polymorphicPropName: undefined,
+			components: {},
+			attributes: {},
+		},
+		next: {
+			rootDir: [],
+		},
+		react: {
+			formComponents: [],
+			linkComponents: [],
+			version: undefined,
+		},
+		jsdoc: {
+			ignorePrivate: false,
+			ignoreInternal: false,
+			ignoreReplacesDocs: true,
+			overrideReplacesDocs: true,
+			augmentsExtendsReplacesDocs: false,
+			implementsReplacesDocs: false,
+			exemptDestructuredRootsFromChecks: false,
+			tagNamePreference: {},
+		},
+		vitest: {
+			typecheck: false,
+		},
+	},
+	env: {
+		builtin: true,
+		node: true,
+	},
+	globals: {},
+	ignorePatterns: commonIgnore,
+});
+
+export const formatter = {
+	printWidth: 160,
+	embeddedLanguageFormatting: 'off',
+	useTabs: true,
+	singleQuote: true,
+	bracketSpacing: false,
+	ignorePatterns: commonIgnore,
+	overrides: [
+		{
+			files: ['src/**/*.{scss,css}'],
+			options: {
+				singleQuote: false,
+			},
+		},
+	],
+};

package/oxfmt.config.ts

@@ -0,0 +1,9 @@
+import {formatter as defaults} from './oxc.config.ts';
+
+// Add custom oxfmt formatter overrides here.
+// This file is preserved on template updates.
+const formatter: Partial<typeof defaults> = {};
+
+const config = {...defaults, ...formatter};
+
+export default config;