ts-builds 4.2.0 → 4.3.0

package/README.md

@@ -221,6 +221,23 @@ npx ts-builds validate:core
 npx ts-builds validate:landing
 ```
 
+A `commands` entry named after a built-in step (`format`, `format:check`, `lint`, `lint:check`, `typecheck`,
+`ts-types`, `test`, `test:watch`, `test:coverage`, `test:ui`, `build`, `build:watch`, `dev`, `preview`) replaces
+that step everywhere: inside a chain, and when you run it directly (`ts-builds lint:check`, or
+`ts-builds lint check`). A chain with one of those names takes precedence over both, as it does inside a chain.
+`compile` can be overridden too, but only runs inside a chain. An override runs your command instead of
+ts-builds' lint, so it sends no lint telemetry, and an override of `lint` or `lint:check` removes any old
+`.ts-builds/lint-report.json`, so `lint:summary` can't read stale counts.
+
+```json
+{
+  "commands": {
+    "lint": "eslint ./src ./test --fix --max-warnings=0",
+    "lint:check": "eslint ./src ./test --max-warnings=0"
+  }
+}
+```
+
 ### Aggregating lint results across a monorepo
 
 Under a task runner, `ts-builds` runs per-package, so each package's ESLint output
@@ -299,8 +316,9 @@ Each run sends one JSON object:
 
 - **Never sent:** file paths, source code or message text.
 - **Sent as-is:** the `package.json` name, left out when there isn't one, and rule ids as your config
-  names them. Plugin names and versions are sent only when they look like an npm package name and a
-  semver version.
+  names them. A plugin's declared name is used only when it looks like an npm package name, and
+  otherwise is replaced by the name derived from its rule prefix, such as `eslint-plugin-<prefix>`. Its
+  declared version is used only when it's semver.
 - **`project`:** a salted hash of the git remote, so one repo's packages group together. It's a
   stable pseudonym, not anonymity: anyone who knows the remote URL can compute it. It's left out
   when there's no remote.
@@ -311,8 +329,8 @@ Each run sends one JSON object:
 - **`enabled`:** the plugin rules that are on, with their severity, read from the first linted file's
   config. It tells a rule with no findings apart from a rule that's off. Core rules are left out.
 
-It never changes a run's result. It sends after lint finishes and its output is printed, waits at
-most 2 seconds, and ignores every error, so the exit code and output stay the same. A run that
+It never changes a run's result. It sends after lint finishes and its output is printed, the send
+waits at most 2 seconds, and it ignores every error, so the exit code and output stay the same. A run that
 fails before linting, such as one with a broken config, sends nothing.
 
 It doesn't cover `lint.useProjectEslint`, which spawns your own ESLint so ts-builds never sees the

package/dist/cli.js

@@ -343,6 +343,13 @@ const LINT_REPORT_VERSION = 1;
 function lintReportPath(dir = targetDir) {
 	return join(dir, ".ts-builds", "lint-report.json");
 }
+/**
+* Remove the sidecar. When a `commands` override replaces `lint` or `lint:check`, ts-builds' own lint
+* doesn't run and writes no report, so an old one would leave `lint:summary` reading stale counts.
+*/
+function forgetLintReport(dir = targetDir) {
+	rmSync(lintReportPath(dir), { force: true });
+}
 /** The `name` in `<dir>/package.json`, when the file exists, parses and has a non-empty name. */
 function packageJsonName(dir = targetDir) {
 	const pkgPath = join(dir, "package.json");
@@ -426,9 +433,10 @@ function resolveEnv(env) {
 		...env
 	} : process.env;
 }
-function runCommand(command, args, options = {}) {
+/** Spawn one shell command line; resolves with its exit code, or 1 if it can't start */
+function spawnShell(commandLine, label, options) {
 	return new Promise((resolve) => {
-		const child = spawn(command, args, {
+		const child = spawn(commandLine, {
 			cwd: resolveCwd(options.cwd),
 			env: resolveEnv(options.env),
 			stdio: "inherit",
@@ -438,27 +446,24 @@ function runCommand(command, args, options = {}) {
 			resolve(code ?? 1);
 		});
 		child.on("error", (err) => {
-			console.error(`Failed to run ${command}: ${err.message}`);
+			console.error(`Failed to run${label}: ${err.message}`);
 			resolve(1);
 		});
 	});
 }
+/**
+* Run `command` with `args` through the shell, so `.bin` shims (including
+* Windows `.cmd` files) and commands such as `npx eslint` resolve. `args` are
+* joined into the command line as given, not escaped: quote any argument that
+* holds spaces or shell characters, as `prettierFormatArgs` does. Joining here
+* rather than passing `args` to `spawn` gives the same command line Node built
+* before, without its DEP0190 warning, which flags exactly that unescaped join.
+*/
+function runCommand(command, args, options = {}) {
+	return spawnShell([command, ...args].join(" "), ` ${command}`, options);
+}
 function runShellCommand(shellCmd, options = {}) {
-	return new Promise((resolve) => {
-		const child = spawn(shellCmd, {
-			cwd: resolveCwd(options.cwd),
-			env: resolveEnv(options.env),
-			stdio: "inherit",
-			shell: true
-		});
-		child.on("close", (code) => {
-			resolve(code ?? 1);
-		});
-		child.on("error", (err) => {
-			console.error(`Failed to run: ${err.message}`);
-			resolve(1);
-		});
-	});
+	return spawnShell(shellCmd, "", options);
 }
 
 // src/cli/commands/build.ts
@@ -606,7 +611,7 @@ function prettierConfigArg() {
 * no prettier config of their own (see `prettierConfigArg`), so we fill the gap without ever
 * overriding a config they wrote.
 *
-* Bundled paths are quoted because `runCommand` spawns with `shell: true` (the shell strips the
+* Bundled paths are quoted because `runCommand` runs one shell command line (the shell strips the
 * quotes), keeping them correct when the install path contains spaces.
 */
 function prettierFormatArgs(check, bundledIgnore = bundledPrettierIgnorePath(), bundledConfig = prettierConfigArg()) {
@@ -2405,6 +2410,53 @@ function runSize(args) {
 function isRunFnCommand(cmd) {
 	return "runFn" in cmd;
 }
+/** The built-in chain steps. A `commands` entry with one of these names replaces it, in a chain or run directly. */
+const BUILTIN_STEP_NAMES = [
+	"format",
+	"format:check",
+	"lint",
+	"lint:check",
+	"typecheck",
+	"ts-types",
+	"test",
+	"test:watch",
+	"test:coverage",
+	"test:ui",
+	"build",
+	"build:watch",
+	"dev",
+	"preview",
+	"compile"
+];
+const isBuiltinStepName = (name) => BUILTIN_STEP_NAMES.includes(name);
+/** The step a top-level command runs: `lint check` is `lint:check`, `test watch` is `test:watch`, `test run` is `test` */
+function stepName(command, subCommand) {
+	if ((command === "lint" || command === "format") && subCommand === "check") return `${command}:check`;
+	if (command === "build" && subCommand === "watch") return "build:watch";
+	if (command === "test" && (subCommand === "watch" || subCommand === "coverage" || subCommand === "ui")) return `test:${subCommand}`;
+	return command;
+}
+/**
+* The user's replacement for a built-in step, if their config has one. Run directly, a built-in
+* resolves the same way it does inside a chain (`runStep`): `config.commands[step] ?? builtin`.
+*/
+function builtinOverride(step, config) {
+	return Option(config.commands[step]).filter(() => isBuiltinStepName(step));
+}
+/** An override of `lint` or `lint:check` replaces ts-builds' lint, so its old report must go */
+function forgetLintReportIfLint(step) {
+	if (step === "lint" || step === "lint:check") forgetLintReport();
+}
+/** Run a `commands` entry on its own: check its cwd, then run it through the shell */
+async function runConfiguredCommand(name, cmdDef) {
+	const cwdError = escapingValidateCwdError(name, cmdDef);
+	if (cwdError) {
+		console.error(cwdError);
+		return 1;
+	}
+	forgetLintReportIfLint(name);
+	return runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
+}
 function getBuiltinCommands(config) {
 	return {
 		format: { runFn: () => runFormat(false) },
@@ -2455,6 +2507,7 @@ async function runStep(step, config, builtins, path) {
 		console.error(cwdError);
 		return 1;
 	}
+	if (Object.hasOwn(config.commands, step)) forgetLintReportIfLint(step);
 	const cwdLabel = "cwd" in cmdDef && cmdDef.cwd ? ` (in ${cmdDef.cwd})` : "";
 	console.log(`\n▶ Running ${step}...${cwdLabel}`);
 	const code = isRunFnCommand(cmdDef) ? await cmdDef.runFn() : await runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
@@ -2472,6 +2525,12 @@ async function runValidate(chainName = "validate") {
 // src/cli.ts
 const command = process.argv[2] || "init";
 const subCommand = process.argv[3];
+const step = stepName(command, subCommand);
+if (isBuiltinStepName(step)) {
+	const config = loadConfig();
+	if (Object.hasOwn(config.chains, step)) process.exit(await runValidate(step));
+	await builtinOverride(step, config).fold(() => Promise.resolve(), async (cmd) => process.exit(await runConfiguredCommand(step, cmd)));
+}
 switch (command) {
 	case "help":
 	case "--help":
@@ -2550,16 +2609,8 @@ switch (command) {
 	default: {
 		const config = loadConfig();
 		if (config.chains[command]) process.exit(await runValidate(command));
-		else if (config.commands[command]) {
-			const cmdDef = config.commands[command];
-			const cwdError = escapingValidateCwdError(command, cmdDef);
-			if (cwdError) {
-				console.error(cwdError);
-				process.exit(1);
-			}
-			const code = await runShellCommand(cmdDef.run, { cwd: cmdDef.cwd });
-			process.exit(code);
-		} else {
+		else if (config.commands[command]) process.exit(await runConfiguredCommand(command, config.commands[command]));
+		else {
 			console.error(`Unknown command: ${command}`);
 			console.log("Run 'ts-builds help' for usage information.");
 			process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-builds",
-  "version": "4.2.0",
+  "version": "4.3.0",
   "description": "Shared TypeScript configuration files for library templates. Provides standardized ESLint, Prettier, Vitest, TypeScript, and build configs.",
   "keywords": [
     "typescript",