@antelopejs/tooling-configs 0.2.1 → 0.2.3

package/dist/{ratchet-B2-4XxAl.mjs → ratchet-CNbpU42F.mjs}

@@ -1,8 +1,9 @@
-import { a as formatCeilings, n as MAX_FILE_BYTES, o as readCeilings, r as MEASURE_ENV, t as CEILINGS_FILE } from "./ceilings--pJmhSde.mjs";
-import { i as repositoryPath, n as fileBytes, r as gitFiles, t as authoredSizes } from "./files-Bocv-qA8.mjs";
-import { n as sizeFailure } from "./size-DJ7YSry_.mjs";
+import { a as formatCeilings, n as MAX_FILE_BYTES, o as isRetired, r as MEASURE_ENV, t as CEILINGS_FILE } from "./ceilings-BSw9p4YB.mjs";
+import { t as readCarriedCeilings } from "./renames-BGO4dWJ8.mjs";
+import { n as gitFiles, r as repositoryPath, t as authoredSizes } from "./files-jKlueTMd.mjs";
+import { n as sizeFailure } from "./size-BdYmv57u.mjs";
 import { createRequire } from "node:module";
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
 //#region src/guardrails/oxlint.ts
@@ -50,7 +51,7 @@ function lintDiagnostics(root, config, files) {
 			writeFileSync(path, config ?? "");
 			args.push("--config", path, "--ignore-pattern", `${basename(temporary)}/**`);
 		}
-		if (files) args.push("--", ...files);
+		if (files) args.push("--no-error-on-unmatched-pattern", "--", ...files);
 		const result = spawnSync(process.execPath, args, {
 			cwd: root,
 			encoding: "utf8",
@@ -77,11 +78,12 @@ function lintDiagnostics(root, config, files) {
 function baseline(root, diagnostics) {
 	const rules = {};
 	const oversizeFiles = {};
+	const sizes = authoredSizes(root);
 	for (const diagnostic of diagnostics) if (diagnostic.rule === "eslint/max-lines") {
-		const size = fileBytes(root, diagnostic.file);
+		const size = sizes.get(diagnostic.file);
 		if (size !== void 0) oversizeFiles[diagnostic.file] = size;
 	} else rules[diagnostic.rule] = (rules[diagnostic.rule] ?? 0) + 1;
-	for (const [file, size] of authoredSizes(root)) if (size > 2e4) oversizeFiles[file] = size;
+	for (const [file, size] of sizes) if (size > 2e4) oversizeFiles[file] = size;
 	return {
 		rules,
 		oversizeFiles
@@ -136,9 +138,9 @@ function lowerCeilings(ceilings, current) {
 	}
 	return lowered;
 }
-function ratchet(root, update = false) {
+function ratchet(root, update = false, base = "HEAD") {
 	if (!existsSync(join(root, "guardrails.ratchet.json"))) throw new Error(`${CEILINGS_FILE} is missing. Run antelopejs-sync first.`);
-	const ceilings = readCeilings(root);
+	const ceilings = readCarriedCeilings(root, false, [base]);
 	const diagnostics = lintDiagnostics(root);
 	const current = baseline(root, diagnostics);
 	const changed = changedFiles(root);
@@ -154,18 +156,22 @@ function ratchet(root, update = false) {
 		if (shown.length < matches.length) failures.push(`  ...and ${matches.length - shown.length} recorded in files this change does not touch.`);
 	}
 	for (const [file, size] of Object.entries(current.oversizeFiles)) if (ceilings.oversizeFiles[file] === void 0) failures.push(size > 2e4 ? sizeFailure(file, size, MAX_FILE_BYTES) : `${file}: ${size} bytes and an eslint/max-lines diagnostic; this file has no oversize allowance. Split by responsibility into sibling modules, or split tests by behaviour under test, one file per describe.`);
+	const sizes = authoredSizes(root, Object.keys(ceilings.oversizeFiles));
 	for (const [file, limit] of Object.entries(ceilings.oversizeFiles)) {
-		const size = fileBytes(root, file);
+		const size = sizes.get(file);
 		if (size !== void 0 && size > limit) failures.push(sizeFailure(file, size, limit));
 	}
 	const lowered = update ? lowerCeilings(ceilings, current) : [];
+	const retired = update && isRetired(ceilings);
 	if (update) {
 		const path = join(root, CEILINGS_FILE);
-		writeFileSync(path, formatCeilings(ceilings));
+		if (retired) unlinkSync(path);
+		else writeFileSync(path, formatCeilings(ceilings));
 	}
 	return {
 		failures,
-		lowered
+		lowered,
+		retired
 	};
 }
 //#endregion

package/dist/renames-BGO4dWJ8.mjs

@@ -0,0 +1,59 @@
+import { s as readCeilings } from "./ceilings-BSw9p4YB.mjs";
+import { spawnSync } from "node:child_process";
+//#region src/guardrails/renames.ts
+/**
+* Renames git detects, as new path to old path. Without `revisions` it
+* compares the index with HEAD when `staged`, otherwise the working tree with
+* HEAD; with revisions it compares those. Copies are never reported, and a
+* repository without HEAD has no renames.
+*/
+function renamedPaths(root, staged = false, revisions = staged ? [] : ["HEAD"]) {
+	const result = spawnSync("git", [
+		"diff",
+		"--find-renames",
+		"--diff-filter=R",
+		"--name-status",
+		"-z",
+		"--no-ext-diff",
+		...staged ? ["--cached"] : [],
+		...revisions,
+		"--"
+	], {
+		cwd: root,
+		encoding: "utf8",
+		maxBuffer: 67108864
+	});
+	const renames = /* @__PURE__ */ new Map();
+	if (result.error || result.status !== 0) return renames;
+	const fields = result.stdout.split("\0");
+	for (let index = 0; index + 2 < fields.length; index += 3) renames.set(fields[index + 2], fields[index + 1]);
+	return renames;
+}
+/**
+* Moves the oversize allowance of each renamed file to its new path. The new
+* path never gets more than the old allowance; a copy or a new file has no
+* rename entry and so inherits nothing.
+*/
+function carryAllowances(ceilings, renames) {
+	const oversizeFiles = { ...ceilings.oversizeFiles };
+	const moved = [];
+	for (const [file, previous] of renames) {
+		const allowance = ceilings.oversizeFiles[previous];
+		if (allowance === void 0) continue;
+		delete oversizeFiles[previous];
+		moved.push([file, Math.min(allowance, ceilings.oversizeFiles[file] ?? allowance)]);
+	}
+	for (const [file, allowance] of moved) oversizeFiles[file] = allowance;
+	return {
+		rules: ceilings.rules,
+		oversizeFiles
+	};
+}
+/** The ceilings at `root` with allowances carried across the renames in `staged` or working-tree scope. */
+function readCarriedCeilings(root, staged = false, revisions) {
+	const ceilings = readCeilings(root);
+	if (Object.keys(ceilings.oversizeFiles).length === 0) return ceilings;
+	return carryAllowances(ceilings, renamedPaths(root, staged, revisions));
+}
+//#endregion
+export { renamedPaths as n, readCarriedCeilings as t };

package/dist/{shared-NC0T8ykm.mjs → shared-CsXIMK3I.mjs}

@@ -3,16 +3,18 @@
 * Paths every AntelopeJS project generates or vendors, and that no linter should read.
 * `.github/ISSUE_TEMPLATE/**` holds GitHub's legacy issue templates: Markdown with
 * YAML frontmatter saved under a .yml extension, which a YAML formatter cannot parse.
+* `build/**` and `output/**` match only at the repository root: a directory with
+* either name under `src/` or another authored root is source, not build output.
 */
 const IGNORE_PATTERNS = [
 	"**/node_modules/**",
 	"**/dist/**",
-	"**/build/**",
 	"**/coverage/**",
 	"**/.antelope/**",
 	"**/.nuxt/**",
 	"**/.output/**",
-	"**/output/**",
+	"build/**",
+	"output/**",
 	"**/i18n-registry.generated.ts",
 	".github/ISSUE_TEMPLATE/**"
 ];

package/dist/{size-DJ7YSry_.mjs → size-BdYmv57u.mjs}

@@ -1,11 +1,12 @@
-import { o as readCeilings } from "./ceilings--pJmhSde.mjs";
-import { t as authoredSizes } from "./files-Bocv-qA8.mjs";
+import "./ceilings-BSw9p4YB.mjs";
+import { t as readCarriedCeilings } from "./renames-BGO4dWJ8.mjs";
+import { t as authoredSizes } from "./files-jKlueTMd.mjs";
 //#region src/guardrails/size.ts
 function sizeFailure(file, size, limit) {
 	return `${file}: ${size} bytes, ${size - limit} bytes over the ${limit}-byte ceiling. Split by responsibility into sibling modules, one cohesive group of exports each; keep the original path re-exporting only if it is a public entry point. Split a test file by behaviour under test, one file per describe. Do not minify, strip whitespace, or move code under an excluded path to pass.`;
 }
 function checkSize(root, files, staged = false) {
-	const ceilings = readCeilings(root);
+	const ceilings = readCarriedCeilings(root, staged);
 	const failures = [];
 	for (const [file, size] of authoredSizes(root, files, staged)) {
 		const limit = ceilings.oversizeFiles[file] ?? 2e4;

package/dist/typescript-aLCrMi2y.mjs

@@ -0,0 +1,120 @@
+import { l as trackedManifests } from "./files-jKlueTMd.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, matchesGlob, relative, resolve, sep } from "node:path";
+//#region src/guardrails/typescript.ts
+function packagesAt(root, publishedOnly) {
+	return trackedManifests(root).flatMap((file) => {
+		const directory = dirname(file);
+		if (!existsSync(join(root, directory, "tsconfig.json"))) return [];
+		const manifest = JSON.parse(readFileSync(join(root, file), "utf8"));
+		if (publishedOnly && manifest.private === true) return [];
+		return [{
+			directory,
+			manifest
+		}];
+	});
+}
+/** Loads the consumer's compiler, including a package-local installation in a workspace. */
+function loadTypeScript(directory) {
+	return createRequire(join(directory, "package.json"))("typescript");
+}
+const TEST_SOURCE_GLOBS = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/__tests__/**",
+	"test/**",
+	"tests/**"
+];
+function isTestSource(root, file) {
+	const path = relative(root, file).split("\\").join("/");
+	return TEST_SOURCE_GLOBS.some((pattern) => matchesGlob(path, pattern));
+}
+function failDiagnostics(compiler, diagnostics) {
+	const errors = diagnostics.filter((item) => item.category === compiler.DiagnosticCategory.Error);
+	if (errors.length) throw new Error(compiler.formatDiagnostics(errors, {
+		getCanonicalFileName: (file) => file,
+		getCurrentDirectory: () => process.cwd(),
+		getNewLine: () => "\n"
+	}));
+}
+/** Declaration inputs are part of the local closure but TypeScript does not emit copies of them. */
+function copyDeclarations(program, directory, output) {
+	const sources = program.getSourceFiles().filter((source) => !program.isSourceFileDefaultLibrary(source) && !program.isSourceFileFromExternalLibrary(source) && !relative(directory, source.fileName).startsWith(`..${sep}`) && !isTestSource(directory, source.fileName));
+	const authored = sources.filter((source) => !source.isDeclarationFile);
+	let root = dirname((authored[0] ?? sources[0])?.fileName ?? join(directory, "index.ts"));
+	for (const source of authored.length ? authored : sources) while (relative(root, source.fileName).startsWith(`..${sep}`)) root = dirname(root);
+	root = program.getCompilerOptions().rootDir ?? root;
+	const files = [];
+	for (const source of sources) {
+		if (!source.isDeclarationFile) continue;
+		const path = relative(root, source.fileName);
+		if (path.startsWith(`..${sep}`)) continue;
+		const target = join(output, path);
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, source.text);
+		files.push(target);
+	}
+	return files;
+}
+function parseConfig(directory) {
+	const compiler = loadTypeScript(directory);
+	const config = compiler.readConfigFile(join(directory, "tsconfig.json"), compiler.sys.readFile);
+	if (config.error) failDiagnostics(compiler, [config.error]);
+	const parsed = compiler.parseJsonConfigFileContent(config.config, compiler.sys, directory);
+	failDiagnostics(compiler, parsed.errors);
+	return {
+		compiler,
+		parsed
+	};
+}
+/** The configured `outDir`, the root under which the declaration half already judges a built path as test output. */
+function outputRoot(directory) {
+	return resolve(directory, parseConfig(directory).parsed.options.outDir ?? ".");
+}
+/** Emits with the package's compiler and config; test roots and outputs never enter either proof. */
+function emitPackage(directory, output, declarations) {
+	const { compiler, parsed } = parseConfig(directory);
+	const options = {
+		...parsed.options,
+		rootDir: parsed.options.rootDir ?? (parsed.options.outDir ? void 0 : directory),
+		outDir: output,
+		declarationDir: declarations ? output : void 0,
+		declaration: declarations,
+		emitDeclarationOnly: declarations,
+		removeComments: true,
+		declarationMap: false,
+		sourceMap: false,
+		inlineSourceMap: false,
+		noEmit: false,
+		noEmitOnError: false,
+		composite: false,
+		incremental: false,
+		tsBuildInfoFile: void 0,
+		outFile: void 0,
+		allowImportingTsExtensions: declarations ? parsed.options.allowImportingTsExtensions : false
+	};
+	const program = compiler.createProgram({
+		rootNames: parsed.fileNames.filter((file) => !isTestSource(directory, file)),
+		options,
+		projectReferences: parsed.projectReferences
+	});
+	if (declarations) failDiagnostics(compiler, compiler.getPreEmitDiagnostics(program));
+	const files = [];
+	const result = program.emit(void 0, (file, text, _bom, _onError, sources) => {
+		if (sources?.some((source) => isTestSource(directory, source.fileName))) return;
+		if (declarations ? !/\.d\.[cm]?ts$/.test(file) : !/\.[cm]?jsx?$/.test(file)) return;
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(file, text);
+		files.push(file);
+	});
+	if (declarations) failDiagnostics(compiler, result.diagnostics);
+	if (declarations) files.push(...copyDeclarations(program, directory, output));
+	return {
+		compiler,
+		files,
+		options: parsed.options
+	};
+}
+//#endregion
+export { packagesAt as i, isTestSource as n, outputRoot as r, emitPackage as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/tooling-configs",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Shared tooling presets for AntelopeJS repositories: oxlint (with the vendored anti-slop rules), oxfmt, ESLint for Nuxt layers, Knip, and an interface range check",
   "keywords": [
     "antelopejs",
@@ -21,9 +21,11 @@
     "url": "git+https://github.com/AntelopeJS/tooling-configs.git"
   },
   "bin": {
+    "antelopejs-api-diff": "./dist/bin/api-diff.mjs",
     "antelopejs-check-interface-ranges": "./dist/bin/check-interface-ranges.mjs",
     "antelopejs-check-size": "./dist/bin/check-size.mjs",
     "antelopejs-checks": "./dist/bin/checks.mjs",
+    "antelopejs-comment-proof": "./dist/bin/comment-proof.mjs",
     "antelopejs-ratchet": "./dist/bin/ratchet.mjs",
     "antelopejs-sync": "./dist/bin/sync.mjs"
   },
@@ -55,15 +57,14 @@
     "checks": "node src/bin/checks.ts",
     "format:check": "oxfmt --check .",
     "size": "node src/bin/check-size.ts",
-    "ratchet": "node src/bin/ratchet.ts",
     "prepare": "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi",
     "sync": "node src/bin/sync.ts",
-    "ratchet:update": "node src/bin/ratchet.ts --update",
     "sync:check": "node src/bin/sync.ts --check",
     "knip": "knip"
   },
   "dependencies": {
     "@oxlint/plugins": "1.81.0",
+    "dts-bundle-generator": "^9.5.1",
     "yaml": "^2.9.1"
   },
   "devDependencies": {

package/dist/files-Bocv-qA8.mjs

@@ -1,103 +0,0 @@
-import { n as IGNORE_PATTERNS, t as AGENT_IGNORE_PATTERNS } from "./shared-NC0T8ykm.mjs";
-import { existsSync, lstatSync } from "node:fs";
-import { join, matchesGlob, relative, resolve } from "node:path";
-import { execFileSync, spawnSync } from "node:child_process";
-//#region src/guardrails/cli.ts
-function runCli(main) {
-	try {
-		process.exitCode = main();
-	} catch (error) {
-		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-		process.exitCode = 1;
-	}
-}
-//#endregion
-//#region src/guardrails/files.ts
-const SIZE_EXCLUSIONS = [
-	{
-		kind: "generated",
-		patterns: [
-			...IGNORE_PATTERNS,
-			...AGENT_IGNORE_PATTERNS,
-			"**/*.generated.*",
-			"**/generated/**",
-			"**/__snapshots__/**"
-		]
-	},
-	{
-		kind: "fixtures",
-		patterns: ["**/fixtures/**", "**/__fixtures__/**"]
-	},
-	{
-		kind: "lockfiles",
-		patterns: [
-			"**/{pnpm-lock.yaml,package-lock.json,npm-shrinkwrap.json,yarn.lock,bun.lock,bun.lockb,Cargo.lock,poetry.lock,uv.lock,Gemfile.lock,composer.lock,go.sum}",
-			"**/*.lock",
-			"**/*.lockb"
-		]
-	},
-	{
-		kind: "documentation",
-		patterns: ["**/CHANGELOG.md", "**/*.{md,mdx,markdown,MD}"]
-	},
-	{
-		kind: "assets",
-		patterns: ["**/*.{png,jpg,jpeg,gif,webp,avif,ico,svg,bmp,tiff,pdf,mp3,wav,ogg,flac,mp4,webm,mov,avi,woff,woff2,ttf,otf,eot,zip,gz,tgz,bz2,xz,7z,tar,rar,wasm,bin,exe,dll,so,dylib,db,sqlite,sqlite3,icns}"]
-	}
-];
-function gitFiles(root) {
-	return [...new Set(execFileSync("git", [
-		"ls-files",
-		"--cached",
-		"--others",
-		"--exclude-standard",
-		"-z"
-	], {
-		cwd: root,
-		encoding: "utf8"
-	}).split("\0").filter(Boolean))];
-}
-function repositoryRoot(cwd = process.cwd()) {
-	return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-		cwd,
-		encoding: "utf8"
-	}).trim();
-}
-function repositoryPath(root, file) {
-	return relative(root, resolve(root, file)).split("\\").join("/");
-}
-function fileBytes(root, file, staged = false) {
-	if (staged) {
-		const result = spawnSync("git", [
-			"cat-file",
-			"-s",
-			`:${file}`
-		], {
-			cwd: root,
-			encoding: "utf8"
-		});
-		if (result.error) throw result.error;
-		return result.status === 0 ? Number(result.stdout.trim()) : void 0;
-	}
-	const path = join(root, file);
-	if (!existsSync(path)) return void 0;
-	const stat = lstatSync(path);
-	return stat.isFile() ? stat.size : void 0;
-}
-/** `path.matchesGlob` never lets `*` or `**` cross a segment starting with a dot, so each path is also tried with those dots removed. */
-function isExcluded(file) {
-	const undotted = file.replace(/(^|\/)\./gu, "$1");
-	return SIZE_EXCLUSIONS.some(({ patterns }) => patterns.some((pattern) => matchesGlob(file, pattern) || matchesGlob(undotted, pattern)));
-}
-function authoredSizes(root, files = gitFiles(root), staged = false) {
-	const sizes = /* @__PURE__ */ new Map();
-	for (const input of files) {
-		const file = repositoryPath(root, input);
-		if (isExcluded(file)) continue;
-		const size = fileBytes(root, file, staged);
-		if (size !== void 0) sizes.set(file, size);
-	}
-	return sizes;
-}
-//#endregion
-export { repositoryRoot as a, repositoryPath as i, fileBytes as n, runCli as o, gitFiles as r, authoredSizes as t };