knip 2.15.5 → 2.16.0

package/dist/binaries/bash-parser.js

@@ -1,14 +1,12 @@
 import parse from '@ericcornelissen/bash-parser';
-import parseArgs from 'minimist';
 import { debugLogObject } from '../util/debug.js';
 import * as FallbackResolver from './resolvers/fallback.js';
 import * as KnownResolvers from './resolvers/index.js';
-import { stripBinaryPath, toBinary } from './util.js';
-const spawningBinaries = ['cross-env', 'dotenv'];
+import { stripBinaryPath } from './util.js';
 export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
     if (!script)
         return [];
-    const fromArgs = (args) => getBinariesFromScript(args.join(' '), { cwd, manifest });
+    const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { cwd, manifest });
     const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
@@ -31,25 +29,16 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                 }
                 if (knownGlobalsOnly)
                     return [];
-                if (spawningBinaries.includes(binary)) {
-                    const parsedArgs = parseArgs(args);
-                    const [spawnedBinary] = parsedArgs._;
-                    if (spawnedBinary) {
-                        const restArgs = args.slice(args.indexOf(spawnedBinary));
-                        return [toBinary(binary), ...fromArgs(restArgs)];
-                    }
-                    else {
-                        return [];
-                    }
-                }
                 return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
             }
             case 'LogicalExpression':
                 return getBinariesFromNodes([node.left, node.right]);
             case 'If':
-                return getBinariesFromNodes([...node.clause.commands, ...node.then.commands]);
+                return getBinariesFromNodes([...node.clause.commands, ...node.then.commands, ...(node.else?.commands ?? [])]);
             case 'For':
                 return getBinariesFromNodes(node.do.commands);
+            case 'CompoundList':
+                return getBinariesFromNodes(node.commands);
             default:
                 return [];
         }

package/dist/binaries/resolvers/c8.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/c8.js

@@ -0,0 +1,9 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args, {
+        boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],
+    });
+    parsed._ = parsed._.filter(a => a !== 'check-coverage');
+    return [toBinary(binary), ...fromArgs(parsed._)];
+};

package/dist/binaries/resolvers/dotenv.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/dotenv.js

@@ -0,0 +1,6 @@
+import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
+export const resolve = (binary, args, { fromArgs }) => {
+    const parsed = parseArgs(args);
+    return [toBinary(binary), ...fromArgs(parsed._)];
+};

package/dist/binaries/resolvers/fallback.js

@@ -13,10 +13,11 @@ const argFilters = {
     tsx: parsed => parsed._.filter(p => p !== 'watch'),
     default: withoutPositional,
 };
-export const resolve = (binary, args, { cwd }) => {
+const spawningBinaries = ['cross-env'];
+export const resolve = (binary, args, { cwd, fromArgs }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
-    const argFilter = argFilters[binary] ?? argFilters.default;
-    const filteredArgs = compact(argFilter(parsed));
-    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : [toBinary(binary)];
-    return [...bin, ...tryResolveSpecifiers(cwd, filteredArgs)];
+    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : toBinary(binary);
+    const filteredArgs = binary in argFilters ? argFilters[binary](parsed) : argFilters.default(parsed);
+    const shiftedArgs = spawningBinaries.includes(binary) ? fromArgs(args) : [];
+    return compact([bin, ...tryResolveSpecifiers(cwd, filteredArgs), ...shiftedArgs]);
 };

package/dist/binaries/resolvers/index.d.ts

@@ -1,3 +1,5 @@
+export * as c8 from './c8.js';
+export * as dotenv from './dotenv.js';
 export * as node from './node.js';
 export * as npx from './npx.js';
 export * as pnpm from './pnpm.js';

package/dist/binaries/resolvers/index.js

@@ -1,3 +1,5 @@
+export * as c8 from './c8.js';
+export * as dotenv from './dotenv.js';
 export * as node from './node.js';
 export * as npx from './npx.js';
 export * as pnpm from './pnpm.js';

package/dist/binaries/resolvers/node.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
 import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader', 'experimental-loader'] } });
-    return [...tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())];
+    return compact([tryResolveFilePath(cwd, parsed._[0]), ...tryResolveSpecifiers(cwd, [parsed.require].flat())]);
 };

package/dist/binaries/resolvers/npx.js

@@ -1,10 +1,24 @@
 import parseArgs from 'minimist';
-import { fromBinary } from '../util.js';
-export const resolve = (binary, args, { fromArgs }) => {
-    const parsed = parseArgs(args, { '--': true, stopEarly: true, boolean: ['yes', 'no'], alias: { yes: 'y', no: 'n' } });
+import { isInternal } from '../../util/path.js';
+import { fromBinary, toBinary } from '../util.js';
+export const resolve = (binary, args, { fromArgs, manifest }) => {
+    const parsed = parseArgs(args, {
+        '--': true,
+        stopEarly: true,
+        boolean: ['yes', 'no'],
+        alias: { yes: 'y', no: 'no-install' },
+    });
     const leftParsed = fromArgs(parsed._);
-    const left = parsed.yes ? leftParsed.slice(1) : leftParsed;
-    const packageName = left[0] ? [fromBinary(left[0])] : [];
-    const right = parsed['--'] ? fromArgs(parsed['--']) : [];
-    return [...packageName, ...left.slice(1), ...right];
+    const leftHandCommand = parsed.yes ? leftParsed.slice(1) : leftParsed;
+    const rightHandCommand = parsed['--'] ? fromArgs(parsed['--']) : [];
+    const binaryOrPackageName = fromBinary(leftHandCommand[0] ?? rightHandCommand[0]);
+    const dependencies = manifest
+        ? [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})]
+        : [];
+    const dependency = !binaryOrPackageName.startsWith('@') &&
+        !isInternal(binaryOrPackageName) &&
+        !dependencies.includes(binaryOrPackageName)
+        ? toBinary(binaryOrPackageName)
+        : binaryOrPackageName;
+    return [dependency, ...leftHandCommand.slice(1), ...rightHandCommand];
 };

package/dist/binaries/resolvers/rollup.js

@@ -1,4 +1,5 @@
 import parseArgs from 'minimist';
+import { compact } from '../../util/array.js';
 import { toBinary, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs }) => {
     const safeArgs = args.filter(arg => arg !== '--watch');
@@ -6,5 +7,5 @@ export const resolve = (binary, args, { cwd, fromArgs }) => {
     const watchers = parsed.watch ? fromArgs(Object.values(parsed.watch)) : [];
     const plugins = parsed.plugin ? tryResolveSpecifiers(cwd, [parsed.plugin].flat()) : [];
     const configPlugins = parsed.configPlugin ? tryResolveSpecifiers(cwd, [parsed.configPlugin].flat()) : [];
-    return [toBinary(binary), ...watchers, ...plugins, ...configPlugins];
+    return compact([toBinary(binary), ...watchers, ...plugins, ...configPlugins]);
 };

package/dist/binaries/util.d.ts

@@ -1,5 +1,5 @@
-export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string[];
-export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => string[];
+export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string | undefined;
+export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => (string | undefined)[];
 export declare const toBinary: (specifier: string) => string;
 export declare const fromBinary: (specifier: string) => string;
 export declare const isBinary: (specifier: string) => boolean;

package/dist/binaries/util.js

@@ -7,20 +7,21 @@ export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
         if (!isInNodeModules(filePath)) {
             const resolvedFilePath = _tryResolve(filePath, cwd);
             if (resolvedFilePath) {
-                return [resolvedFilePath];
+                return resolvedFilePath;
             }
             else if (acceptModuleSpecifier) {
-                const packageName = getPackageNameFromModuleSpecifier(specifier);
-                return packageName ? [packageName] : [];
+                return getPackageNameFromModuleSpecifier(specifier);
             }
         }
+        else if (specifier.includes('node_modules/.bin')) {
+            return toBinary(stripBinaryPath(specifier));
+        }
         else {
-            return [getPackageNameFromFilePath(specifier)];
+            return getPackageNameFromFilePath(specifier);
         }
     }
-    return [];
 };
-export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, true));
+export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(specifier => tryResolveFilePath(cwd, specifier, true));
 export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
 export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
 export const isBinary = (specifier) => specifier.startsWith('bin:');

package/dist/constants.js

@@ -8,26 +8,27 @@ export const TEST_FILE_PATTERNS = [
 export const IGNORED_GLOBAL_BINARIES = [
     'bash',
     'bun',
-    'deno',
-    'git',
-    'node',
-    'npm',
-    'npx',
-    'pnpm',
-    'pnpx',
-    'true',
-    'yarn',
     'cat',
     'cd',
     'cp',
+    'deno',
     'echo',
+    'exec',
     'exit',
+    'git',
     'grep',
     'mkdir',
     'mv',
+    'node',
+    'npm',
+    'npx',
+    'pnpm',
+    'pnpx',
     'rm',
     'sh',
     'sudo',
+    'true',
+    'yarn',
 ];
 export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
 export const IGNORED_FILE_EXTENSIONS = [

package/dist/plugins/husky/helpers.d.ts

@@ -0,0 +1 @@
+export declare const getGitHooksPath: () => string;

package/dist/plugins/husky/helpers.js

@@ -0,0 +1,9 @@
+import { execSync } from 'child_process';
+export const getGitHooksPath = () => {
+    try {
+        return execSync('git config --get core.hooksPath', { encoding: 'utf8' }).trim();
+    }
+    catch (error) {
+        return '.husky';
+    }
+};

package/dist/plugins/husky/index.js

@@ -2,14 +2,16 @@ import { readFileSync } from 'fs';
 import { _getDependenciesFromScripts } from '../../binaries/index.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getGitHooksPath } from './helpers.js';
 export const NAME = 'husky';
 export const ENABLERS = ['husky'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+const gitHooksPath = getGitHooksPath();
 export const CONFIG_FILE_PATTERNS = [
-    '.husky/prepare-commit-msg',
-    '.husky/commit-msg',
-    '.husky/pre-{applypatch,commit,merge-commit,push,rebase,receive}',
-    '.husky/post-{checkout,commit,merge,rewrite}',
+    `${gitHooksPath}/prepare-commit-msg`,
+    `${gitHooksPath}/commit-msg`,
+    `${gitHooksPath}/pre-{applypatch,commit,merge-commit,push,rebase,receive}`,
+    `${gitHooksPath}/post-{checkout,commit,merge,rewrite}`,
 ];
 const findHuskyDependencies = async (configFilePath, { cwd, manifest }) => {
     const script = readFileSync(configFilePath);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.15.5";
+export declare const version = "2.16.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.15.5';
+export const version = '2.16.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.15.5",
+  "version": "2.16.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -67,23 +67,23 @@
     "@types/js-yaml": "4.0.5",
     "@types/micromatch": "4.0.2",
     "@types/minimist": "1.2.2",
-    "@types/node": "20.4.1",
+    "@types/node": "20.4.2",
     "@types/npmcli__map-workspaces": "3.0.1",
     "@types/webpack": "5.28.1",
     "@typescript-eslint/eslint-plugin": "6.0.0",
     "@typescript-eslint/parser": "6.0.0",
     "c8": "8.0.0",
-    "eslint": "8.44.0",
+    "eslint": "8.45.0",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-n": "16.0.1",
     "glob": "10.3.3",
     "prettier": "3.0.0",
-    "release-it": "16.1.0",
+    "release-it": "16.1.2",
     "remark-cli": "11.0.0",
     "remark-preset-webpro": "0.0.3",
     "tsx": "3.12.7",
-    "type-fest": "3.13.0"
+    "type-fest": "4.0.0"
   },
   "engines": {
     "node": ">=16.17.0 <17 || >=18.6.0"