knip 2.3.1 → 2.4.0

package/dist/ConfigurationChief.d.ts

@@ -24,6 +24,7 @@ export declare class ConfigurationChief {
     additionalWorkspaces: Set<string>;
     workspaceDirs: string[];
     workspaces: Workspace[];
+    localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
     init(): Promise<void>;

package/dist/ConfigurationChief.js

@@ -50,6 +50,7 @@ export class ConfigurationChief {
     additionalWorkspaces = new Set();
     workspaceDirs = [];
     workspaces = [];
+    localWorkspaces = new Set();
     resolvedConfigFilePath;
     constructor({ cwd, isProduction }) {
         this.cwd = cwd;
@@ -152,6 +153,7 @@ export class ConfigurationChief {
         this.ignoreWorkspaces = this.getIgnoredWorkspaces();
         this.manifestWorkspaces = await this.getManifestWorkspaces();
         this.additionalWorkspaces = await this.getAdditionalWorkspaces();
+        this.localWorkspaces = new Set(compact(this.getEnabledWorkspaces().map(w => w.pkgName)));
         this.workspaces = this.getEnabledWorkspaces();
         this.workspaceDirs = this.getAllWorkspaces()
             .sort(byPathDepth)

package/dist/DependencyDeputy.js

@@ -1,4 +1,5 @@
 import { isBuiltin } from 'node:module';
+import { fromBinary, isBinary } from './binaries/util.js';
 import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 export class DependencyDeputy {
@@ -72,16 +73,16 @@ export class DependencyDeputy {
             return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         const closestWorkspaceName = workspaceNames.find(name => this.isInDependencies(name, packageName));
-        if (packageName.startsWith('bin:')) {
-            const pkg = packageName.replace(/^bin:/, '');
-            if (IGNORED_GLOBAL_BINARIES.includes(pkg))
+        if (isBinary(packageName)) {
+            const binaryName = fromBinary(packageName);
+            if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
                 return true;
-            if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(pkg))
+            if (this.getWorkspaceManifest(workspace.name)?.ignoreBinaries.includes(binaryName))
                 return true;
             for (const name of workspaceNames) {
                 const binaries = this.getInstalledBinaries(name);
-                if (binaries?.has(pkg)) {
-                    const dependencies = binaries.get(pkg);
+                if (binaries?.has(binaryName)) {
+                    const dependencies = binaries.get(binaryName);
                     if (dependencies?.size) {
                         dependencies.forEach(dependency => this.addReferencedDependency(name, dependency));
                         return true;

package/dist/binaries/bash-parser.js

@@ -3,6 +3,7 @@ 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'];
 export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
     if (!script)
@@ -11,7 +12,7 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
     const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
-                const binary = node.name?.text;
+                const binary = node.name?.text ? stripBinaryPath(node.name.text) : node.name?.text;
                 const commandExpansions = node.prefix?.flatMap(prefix => prefix.expansion?.filter(expansion => expansion.type === 'CommandExpansion') ?? []) ?? [];
                 if (commandExpansions.length > 0) {
                     return commandExpansions.flatMap(expansion => getBinariesFromNodes(expansion.commandAST.commands)) ?? [];
@@ -35,7 +36,7 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                     const [spawnedBinary] = parsedArgs._;
                     if (spawnedBinary) {
                         const restArgs = args.slice(args.indexOf(spawnedBinary));
-                        return [binary, ...fromArgs(restArgs)];
+                        return [toBinary(binary), ...fromArgs(restArgs)];
                     }
                     else {
                         return [];

package/dist/binaries/index.js

@@ -1,19 +1,20 @@
 import { compact } from '../util/array.js';
-import { getPackageNameFromModuleSpecifier, stripBinary } from '../util/modules.js';
+import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { isInternal } from '../util/path.js';
 import { timerify } from '../util/Performance.js';
 import { getBinariesFromScript } from './bash-parser.js';
+import { isBinary } from './util.js';
 const defaultCwd = process.cwd();
 const getDependenciesFromScripts = (npmScripts, options = {}) => {
     const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;
     const scripts = typeof npmScripts === 'string' ? [npmScripts] : [...npmScripts];
     const results = scripts.flatMap(script => getBinariesFromScript(script, { cwd, manifest, knownGlobalsOnly }));
     return compact(results.map(identifier => {
-        if (isInternal(identifier))
+        if (isBinary(identifier) || isInternal(identifier))
             return identifier;
-        const packageName = getPackageNameFromModuleSpecifier(stripBinary(identifier));
+        const packageName = getPackageNameFromModuleSpecifier(identifier);
         if (!packageName.startsWith('.'))
-            return `bin:${packageName}`;
+            return packageName;
     }));
 };
 export const _getDependenciesFromScripts = timerify(getDependenciesFromScripts);

package/dist/binaries/resolvers/fallback.js

@@ -1,11 +1,12 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { tryResolveFilePaths } from './util.js';
+import { toBinary, tryResolveFilePaths } from '../util.js';
 const withPositional = parsed => [parsed._[0], parsed.require].flat();
 const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {
     'babel-node': withPositional,
     esbuild: withPositional,
+    execa: withPositional,
     nodemon: withPositional,
     'ts-node': withPositional,
     zx: withPositional,
@@ -16,5 +17,5 @@ export const resolve = (binary, args, { cwd }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
     const argFilter = argFilters[binary] ?? argFilters.default;
     const filteredArgs = compact(argFilter(parsed));
-    return [binary, ...tryResolveFilePaths(cwd, filteredArgs)];
+    return [toBinary(binary), ...tryResolveFilePaths(cwd, filteredArgs)];
 };

package/dist/binaries/resolvers/node.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { tryResolveFilePath, tryResolveFilePaths } from './util.js';
+import { tryResolveFilePath, tryResolveFilePaths } 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]), ...tryResolveFilePaths(cwd, [parsed.require].flat())];

package/dist/binaries/resolvers/npx.js

@@ -1,7 +1,10 @@
 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' } });
-    const left = fromArgs(parsed._);
+    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 [...(parsed.yes ? left.slice(1) : left), ...right];
+    return [...packageName, ...left.slice(1), ...right];
 };

package/dist/binaries/resolvers/pnpm.js

@@ -1,4 +1,5 @@
 import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
 const commands = [
     'add',
     'dlx',
@@ -33,13 +34,13 @@ const commands = [
     't',
     'tst',
 ];
-export const resolve = (binary, args, { manifest }) => {
+export const resolve = (_binary, args, { manifest }) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
     const parsed = parseArgs(args, {});
-    const [command, result] = parsed._;
+    const [command, binary] = parsed._;
     if (scripts.includes(command) || commands.includes(command))
         return [];
     if (command === 'exec')
-        return [result];
-    return command ? [command] : [];
+        return [toBinary(binary)];
+    return command ? [toBinary(command)] : [];
 };

package/dist/binaries/resolvers/rollup.js

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

package/dist/binaries/resolvers/yarn.js

@@ -1,4 +1,5 @@
 import parseArgs from 'minimist';
+import { toBinary } from '../util.js';
 const commands = [
     'add',
     'bin',
@@ -30,17 +31,17 @@ const commands = [
     'workspace',
     'workspaces',
 ];
-export const resolve = (binary, args, { manifest, fromArgs }) => {
+export const resolve = (_binary, args, { manifest, fromArgs }) => {
     const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
     const parsed = parseArgs(args, {});
-    const [command, result] = parsed._;
+    const [command, binary] = parsed._;
     if (scripts.includes(command) || commands.includes(command))
         return [];
-    if (command === 'run' && scripts.includes(result))
+    if (command === 'run' && scripts.includes(binary))
         return [];
     if (command === 'run' || command === 'exec')
-        return [result];
+        return [toBinary(binary)];
     if (command === 'node')
         return fromArgs(parsed._);
-    return command ? [command] : [];
+    return command ? [toBinary(command)] : [];
 };

package/dist/binaries/util.d.ts

@@ -0,0 +1,6 @@
+export declare const tryResolveFilePath: (cwd: string, specifier: string, fallback?: string) => string[];
+export declare const tryResolveFilePaths: (cwd: string, specifiers: string[]) => string[];
+export declare const toBinary: (specifier: string) => string;
+export declare const fromBinary: (specifier: string) => string;
+export declare const isBinary: (specifier: string) => boolean;
+export declare const stripBinaryPath: (command: string) => string;

package/dist/binaries/util.js

@@ -0,0 +1,23 @@
+import { isInNodeModules, join } from '../util/path.js';
+import { _tryResolve } from '../util/require.js';
+export const tryResolveFilePath = (cwd, specifier, fallback) => {
+    if (specifier) {
+        const filePath = join(cwd, specifier);
+        if (!isInNodeModules(filePath)) {
+            const resolvedFilePath = _tryResolve(filePath, cwd);
+            if (resolvedFilePath)
+                return [resolvedFilePath];
+        }
+        return fallback ? [stripNodeModulesFromPath(fallback)] : [];
+    }
+    return [];
+};
+export const tryResolveFilePaths = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, specifier));
+export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
+export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
+export const isBinary = (specifier) => specifier.startsWith('bin:');
+const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
+export const stripBinaryPath = (command) => stripNodeModulesFromPath(command)
+    .replace(/^(\.bin\/)/, '')
+    .replace(/\$\(npm bin\)\/(\w+)/, '$1')
+    .replace(/(\S+)@.*/, '$1');

package/dist/index.js

@@ -183,15 +183,8 @@ export const main = async (unresolvedConfiguration) => {
                     exportedSymbols.set(filePath, exported);
                 for (const [specifierFilePath, importItems] of internal.entries()) {
                     const packageName = getPackageNameFromModuleSpecifier(importItems.specifier);
-                    const importedWorkspace = chief.findWorkspaceByPackageName(packageName);
-                    if (importedWorkspace) {
-                        if (importedWorkspace === workspace) {
-                            principal.addEntryPath(specifierFilePath);
-                        }
-                        else {
-                            external.add(importItems.specifier);
-                        }
-                    }
+                    if (chief.localWorkspaces.has(packageName))
+                        external.add(packageName);
                     if (!importedSymbols.has(specifierFilePath)) {
                         importedSymbols.set(specifierFilePath, importItems);
                     }

package/dist/typescript/visitors/scripts/execa.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => ((node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => string | string[] | undefined) | undefined;
+export default _default;

package/dist/typescript/visitors/scripts/execa.js

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+import { stripQuotes } from '../../ast-helpers.js';
+import { scriptVisitor as visit } from '../index.js';
+export default visit(sourceFile => sourceFile.statements.some(statementImportsExeca$), node => {
+    if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
+        return stripQuotes(node.template.getText());
+    }
+});
+function statementImportsExeca$(node) {
+    return (ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.moduleSpecifier.text === 'execa' &&
+        !!node.importClause?.namedBindings &&
+        ts.isNamedImports(node.importClause.namedBindings) &&
+        node.importClause.namedBindings.elements.some(element => element.name.text === '$'));
+}

package/dist/typescript/visitors/scripts/index.js

@@ -1,3 +1,4 @@
+import execa from './execa.js';
 import zx from './zx.js';
-const visitors = [zx];
+const visitors = [execa, zx];
 export default (sourceFile) => visitors.map(v => v(sourceFile)).filter(v => v);

package/dist/util/modules.d.ts

@@ -1,7 +1,6 @@
 import type { PackageJson } from '@npmcli/package-json';
 export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string;
 export declare const getPackageNameFromFilePath: (value: string) => string;
-export declare const stripBinary: (command: string) => string;
 export declare const isDefinitelyTyped: (packageName: string) => boolean;
 export declare const getDefinitelyTypedFor: (packageName: string) => string;
 export declare const getPackageFromDefinitelyTyped: (typedDependency: string) => string;

package/dist/util/modules.js

@@ -11,10 +11,6 @@ export const getPackageNameFromFilePath = (value) => {
         return match[match.length - 1];
     return value;
 };
-export const stripBinary = (command) => command
-    .replace(/(\.\/)?node_modules\/(\.bin\/)?(\w+)/, '$3')
-    .replace(/\$\(npm bin\)\/(\w+)/, '$1')
-    .replace(/(\S+)@.*/, '$1');
 export const isDefinitelyTyped = (packageName) => packageName.startsWith('@types/');
 export const getDefinitelyTypedFor = (packageName) => {
     if (isDefinitelyTyped(packageName))

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.3.1";
+export declare const version = "2.4.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.3.1';
+export const version = '2.4.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -55,7 +55,7 @@
     "pretty-ms": "^8.0.0",
     "strip-json-comments": "^5.0.0",
     "summary": "^2.1.0",
-    "typescript": "5.0.2",
+    "typescript": "^5.0.2",
     "zod": "^3.20.6"
   },
   "devDependencies": {
@@ -77,7 +77,7 @@
     "eslint-plugin-import": "2.27.5",
     "globstar": "1.0.0",
     "prettier": "2.8.7",
-    "release-it": "15.9.3",
+    "release-it": "15.10.0",
     "remark-cli": "11.0.0",
     "remark-preset-webpro": "0.0.2",
     "tsx": "3.12.6",
@@ -99,7 +99,10 @@
       ]
     },
     "github": {
-      "release": true
+      "release": true,
+      "comments": {
+        "submit": true
+      }
     },
     "plugins": {
       "@release-it/bumper": {

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

@@ -1,2 +0,0 @@
-export declare const tryResolveFilePath: (cwd: string, specifier: string, fallback?: string) => string[];
-export declare const tryResolveFilePaths: (cwd: string, specifiers: string[]) => string[];

package/dist/binaries/resolvers/util.js

@@ -1,15 +0,0 @@
-import { isInNodeModules, join } from '../../util/path.js';
-import { _tryResolve } from '../../util/require.js';
-export const tryResolveFilePath = (cwd, specifier, fallback) => {
-    if (specifier) {
-        const filePath = join(cwd, specifier);
-        if (!isInNodeModules(filePath)) {
-            const resolvedFilePath = _tryResolve(filePath, cwd);
-            if (resolvedFilePath)
-                return [resolvedFilePath];
-        }
-        return fallback ? [fallback] : [];
-    }
-    return [];
-};
-export const tryResolveFilePaths = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, specifier));