dt-clean 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.1.1](https://github.com/ljharb/dt-clean/compare/v1.1.0...v1.1.1) - 2026-06-21
+
+### Commits
+
+- [Fix] `--setup`: never duplicate `dt-clean`, and converge on the preferred hook [`bc32122`](https://github.com/ljharb/dt-clean/commit/bc321229b54decfd6000e8d58d202604c36af206)
+- [Dev Deps] add `dt-clean` (self-reference) [`d1a6cdf`](https://github.com/ljharb/dt-clean/commit/d1a6cdf7de2c29d1a17858bf8febf4bd586253f6)
+
 ## [v1.1.0](https://github.com/ljharb/dt-clean/compare/v1.0.1...v1.1.0) - 2026-06-21
 
 ### Commits

package/README.md

@@ -65,9 +65,10 @@ npx dt-clean --setup
 
 - if you have no `dependencies` script, it adds `"dependencies": "dt-clean --auto"`;
 - if you already have one, it adds `dt-clean --auto` to a free `postdependencies` (or `predependencies`) hook instead, so your existing script is never touched - and if every hook is taken, it appends `&& dt-clean --auto` to your `dependencies` script rather than clobbering it;
-- if `dt-clean --auto` is already wired in, it does nothing.
+- if it already added `dt-clean --auto` to a `post`/`pre` hook and the preferred `dependencies` slot later frees up, re-running moves it back to the most-preferred available hook;
+- if `dt-clean --auto` is already in the best available hook, it does nothing; and if some other `dt-clean` invocation (or a customized one you wrote) is already present, it leaves that alone rather than adding a duplicate.
 
-It only ever adds this one invocation and leaves the rest of your `package.json` (and its formatting) alone, so it's safe to re-run. The result is simply the equivalent of:
+It only ever manages this one invocation and leaves the rest of your `package.json` (and its formatting) alone, so it's safe to re-run - repeated runs converge on the same result. That result is simply the equivalent of:
 
 ```json
 {

package/bin.mjs

@@ -67,6 +67,8 @@ if (setup) {
 	const { action, script } = await setupScripts(cwd);
 	console.log({
 		chained: `Appended \`dt-clean --auto\` to the existing \`${script}\` script in \`package.json\`.`,
+		exists: `\`${script}\` already invokes \`dt-clean\` (without \`--auto\`); leaving it unchanged - add \`--auto\` there yourself for install-time cleanup.`,
+		moved: `Moved \`dt-clean --auto\` to the preferred \`${script}\` script in \`package.json\`.`,
 		present: `\`${script}\` already runs \`dt-clean --auto\`; nothing to do.`,
 		set: `Added \`dt-clean --auto\` to the \`${script}\` script in \`package.json\`.`,
 	}[action]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dt-clean",
-	"version": "1.1.0",
+	"version": "1.1.1",
 	"description": "Ensures the only DefinitelyTyped (`@types`) packages you have installed are the ones you need",
 	"bin": "./bin.mjs",
 	"exports": {
@@ -51,6 +51,7 @@
 		"@types/semver": "^7.7.1",
 		"auto-changelog": "^2.6.0",
 		"c8": "^11.0.0",
+		"dt-clean": "file:./",
 		"eslint": "^10.5.0",
 		"esmock": "^2.7.6",
 		"globals": "^17.6.0",

package/setup.d.ts

@@ -4,7 +4,7 @@ declare namespace setup {
     type DependencyHook = 'predependencies' | 'dependencies' | 'postdependencies';
 
     type SetupResult = {
-        action: 'present' | 'set' | 'chained';
+        action: 'present' | 'exists' | 'set' | 'moved' | 'chained';
         script: DependencyHook;
     };
 }

package/setup.mjs

@@ -21,6 +21,11 @@ function hasAuto(script) {
 	return typeof script === 'string' && (/\bdt-clean\b[^&|;]*--auto\b/).test(script);
 }
 
+/** @param {string | undefined} script */
+function hasDtClean(script) {
+	return typeof script === 'string' && (/\bdt-clean\b/).test(script);
+}
+
 /** @type {import('./setup.d.ts')} */
 export default async function setup(cwd) {
 	const packageJSONpath = join(cwd, 'package.json');
@@ -32,18 +37,38 @@ export default async function setup(cwd) {
 	/** @type {NonNullable<PackageJSON['scripts']>} */
 	const scripts = { ...pkg.scripts };
 
-	const present = HOOKS.find((hook) => hasAuto(scripts[hook]));
-	if (present) {
-		return { action: 'present', script: present };
+	// a standalone `dt-clean --auto` we wrote ourselves, which we may therefore safely relocate.
+	const owned = HOOKS.find((hook) => scripts[hook] === AUTO);
+
+	if (!owned) {
+		// a `dt-clean --auto` we didn't write (chained or customized): leave it exactly as-is.
+		const wired = HOOKS.find((hook) => hasAuto(scripts[hook]));
+		if (wired) {
+			return { action: 'present', script: wired };
+		}
+		// some other `dt-clean` invocation: don't add a second one.
+		const existing = HOOKS.find((hook) => hasDtClean(scripts[hook]));
+		if (existing) {
+			return { action: 'exists', script: existing };
+		}
 	}
 
-	const free = HOOKS.find((hook) => !scripts[hook]);
+	// the most-preferred hook our invocation should occupy: free, or already holding it.
+	const target = HOOKS.find((hook) => !scripts[hook] || scripts[hook] === AUTO);
+
+	if (owned && owned === target) {
+		return { action: 'present', script: owned };
+	}
 
 	/** @type {SetupResult} */
 	let result;
-	if (free) {
-		scripts[free] = AUTO;
-		result = { action: 'set', script: free };
+	if (target) {
+		if (owned) {
+			// a more-preferred hook is now free: relocate to it.
+			delete scripts[owned];
+		}
+		scripts[target] = AUTO;
+		result = { action: owned ? 'moved' : 'set', script: target };
 	} else {
 		// every hook is occupied, so chain onto `dependencies` rather than clobber anything.
 		scripts.dependencies = `${scripts.dependencies} && ${AUTO}`;