knip 2.19.9 → 2.19.11

package/dist/DependencyDeputy.d.ts

@@ -45,7 +45,7 @@ export declare class DependencyDeputy {
     addReferencedDependency(workspaceName: string, packageName: string): void;
     addReferencedBinary(workspaceName: string, binaryName: string): void;
     addPeerDependencies(workspaceName: string, peerDependencies: Map<string, Set<string>>): void;
-    getPeerDependencies(workspaceName: string, dependency: string): string[];
+    getPeerDependenciesOf(workspaceName: string, dependency: string): string[];
     maybeAddReferencedExternalDependency(workspace: Workspace, packageName: string): boolean;
     maybeAddReferencedBinary(workspace: Workspace, binaryName: string): boolean;
     private isInDependencies;

package/dist/DependencyDeputy.js

@@ -76,7 +76,7 @@ export class DependencyDeputy {
     addPeerDependencies(workspaceName, peerDependencies) {
         this.peerDependencies.set(workspaceName, peerDependencies);
     }
-    getPeerDependencies(workspaceName, dependency) {
+    getPeerDependenciesOf(workspaceName, dependency) {
         return Array.from(this.peerDependencies.get(workspaceName)?.get(dependency) ?? []);
     }
     maybeAddReferencedExternalDependency(workspace, packageName) {
@@ -150,35 +150,38 @@ export class DependencyDeputy {
                 return true;
             };
             const peerDepRecs = {};
-            const isNotReferencedDependency = (dependency, isPeerDep) => {
+            const isReferencedDependency = (dependency, isPeerDep) => {
                 if (referencedDependencies?.has(dependency))
-                    return false;
-                if (isPeerDep && peerDepRecs[dependency])
                     return true;
+                if (isPeerDep && peerDepRecs[dependency])
+                    return false;
                 const [scope, typedDependency] = dependency.split('/');
                 if (scope === '@types') {
                     const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);
                     if (IGNORE_DEFINITELY_TYPED.includes(typedPackageName))
-                        return false;
-                    const peerDependencies = this.getPeerDependencies(workspaceName, typedPackageName);
+                        return true;
+                    const peerDependencies = this.getPeerDependenciesOf(workspaceName, typedPackageName);
                     if (peerDependencies.length) {
-                        return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency, true));
+                        return !!peerDependencies.find(peerDependency => isReferencedDependency(peerDependency, true));
                     }
-                    return !referencedDependencies?.has(typedPackageName);
+                    if (!referencedDependencies)
+                        return false;
+                    return referencedDependencies.has(typedPackageName);
                 }
-                const peerDependencies = this.getPeerDependencies(workspaceName, dependency);
+                const peerDependencies = this.getPeerDependenciesOf(workspaceName, dependency);
                 peerDependencies.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
-                return !peerDependencies.find(peerDependency => !isNotReferencedDependency(peerDependency, true));
+                return !!peerDependencies.find(peerDependency => isReferencedDependency(peerDependency, true));
             };
+            const isNotReferencedDependency = (dependency) => !isReferencedDependency(dependency);
             const pd = this.getProductionDependencies(workspaceName);
             const dd = this.getDevDependencies(workspaceName);
             pd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
-                .filter(d => isNotReferencedDependency(d))
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => dependencyIssues.push({ type: 'dependencies', filePath: manifestPath, symbol }));
             dd.filter(isNotIgnoredDependency)
                 .filter(isNotIgnoredBinary)
-                .filter(d => isNotReferencedDependency(d))
+                .filter(isNotReferencedDependency)
                 .forEach(symbol => devDependencyIssues.push({ type: 'devDependencies', filePath: manifestPath, symbol }));
         }
         return { dependencyIssues, devDependencyIssues };

package/dist/ProjectPrincipal.js

@@ -158,8 +158,7 @@ export class ProjectPrincipal {
     }
     getHasReferences(filePath, exportedItem) {
         const hasReferences = { external: false, internal: false };
-        const node = ts.isExportAssignment(exportedItem.node) ? exportedItem.node.getChildAt(1) : exportedItem.node;
-        const symbolReferences = this.findReferences(filePath, node).flatMap(f => f.references);
+        const symbolReferences = this.findReferences(filePath, exportedItem.pos).flatMap(f => f.references);
         for (const reference of symbolReferences) {
             if (reference.fileName === filePath) {
                 if (!reference.isDefinition) {
@@ -180,7 +179,7 @@ export class ProjectPrincipal {
             .filter(member => {
             if (this.isPublicExport(member))
                 return false;
-            const referencedSymbols = this.findReferences(filePath, member.node);
+            const referencedSymbols = this.findReferences(filePath, member.pos);
             const files = referencedSymbols
                 .flatMap(refs => refs.references)
                 .filter(ref => !ref.isDefinition)
@@ -191,8 +190,8 @@ export class ProjectPrincipal {
         })
             .map(member => member.identifier);
     }
-    findReferences(filePath, node) {
-        return this.backend.lsFindReferences(filePath, node.getStart()) ?? [];
+    findReferences(filePath, pos) {
+        return this.backend.lsFindReferences(filePath, pos) ?? [];
     }
     isPublicExport(exportedItem) {
         const tags = this.getJSDocTags(exportedItem);

package/dist/binaries/bash-parser.js

@@ -1,55 +1,51 @@
-import Parser from 'tree-sitter';
-import Bash from 'tree-sitter-bash';
+import parse from '@ericcornelissen/bash-parser';
 import { debugLogObject } from '../util/debug.js';
 import * as FallbackResolver from './resolvers/fallback.js';
 import * as KnownResolvers from './resolvers/index.js';
 import { stripBinaryPath } from './util.js';
-const parser = new Parser();
-parser.setLanguage(Bash);
-const getCommandsFromScript = (script) => {
-    const tree = parser.parse(script);
-    const commands = [];
-    const traverse = (node) => {
-        switch (node.type) {
-            case 'command': {
-                const commandNameIndex = node.children.findIndex(node => node.type === 'command_name');
-                const command = node.children.slice(commandNameIndex).map(node => node.text);
-                commands.push(command);
-                break;
-            }
-            default:
-                break;
-        }
-        for (const child of node.children) {
-            traverse(child);
-        }
-    };
-    traverse(tree.rootNode);
-    return commands;
-};
 export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly = false }) => {
     if (!script)
         return [];
     const fromArgs = (args) => getBinariesFromScript(args.filter(arg => arg !== '--').join(' '), { cwd, manifest });
-    const commands = getCommandsFromScript(script);
-    const getBinariesFromCommand = (command) => {
-        const [bin, ...args] = command;
-        const binary = stripBinaryPath(bin);
-        if (!binary || binary === '.' || binary === 'source')
-            return [];
-        if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
-            return [];
-        if (['bun', 'deno'].includes(binary))
-            return [];
-        if (binary in KnownResolvers) {
-            return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
+    const getBinariesFromNodes = (nodes) => nodes.flatMap(node => {
+        switch (node.type) {
+            case 'Command': {
+                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)) ?? [];
+                }
+                if (!binary || binary === '.' || binary === 'source')
+                    return [];
+                if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
+                    return [];
+                if (['bun', 'deno'].includes(binary))
+                    return [];
+                const args = node.suffix?.map(arg => arg.text) ?? [];
+                if (['!', 'test'].includes(binary))
+                    return fromArgs(args);
+                if (binary in KnownResolvers) {
+                    return KnownResolvers[binary].resolve(binary, args, { cwd, manifest, fromArgs });
+                }
+                if (knownGlobalsOnly)
+                    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, ...(node.else?.commands ?? [])]);
+            case 'For':
+                return getBinariesFromNodes(node.do.commands);
+            case 'CompoundList':
+                return getBinariesFromNodes(node.commands);
+            default:
+                return [];
         }
-        if (knownGlobalsOnly)
-            return [];
-        return FallbackResolver.resolve(binary, args, { cwd, manifest, fromArgs });
-    };
+    });
     try {
-        return commands.map(getBinariesFromCommand).flat();
+        const parsed = parse(script);
+        return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
     }
     catch (error) {
         debugLogObject('Bash parser error', error);

package/dist/binaries/resolvers/npx.js

@@ -1,6 +1,5 @@
 import parseArgs from 'minimist';
 import { isInternal } from '../../util/path.js';
-import { stripQuotes } from '../../util/string.js';
 import { getBinariesFromScript } from '../bash-parser.js';
 import { argsFrom, stripVersionFromSpecifier, toBinary } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
@@ -11,7 +10,7 @@ export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
     const packageSpecifier = parsed._[0];
     const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
     const packages = parsed.package ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
-    const command = parsed.call ? getBinariesFromScript(stripQuotes(parsed.call), { cwd, manifest }) : [];
+    const command = parsed.call ? getBinariesFromScript(parsed.call, { cwd, manifest }) : [];
     const restArgs = argsFrom(args, packageSpecifier);
     const dependencies = manifest ? Object.keys({ ...manifest.dependencies, ...manifest.devDependencies }) : [];
     const isBinary = specifier && !packageSpecifier.includes('@') && !isInternal(specifier) && !dependencies.includes(specifier);

package/dist/binaries/resolvers/rollup.js

@@ -1,11 +1,10 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { stripQuotes } from '../../util/string.js';
 import { toBinary, tryResolveSpecifiers } 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).map(value => stripQuotes(value))) : [];
+    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 compact([toBinary(binary), ...watchers, ...plugins, ...configPlugins]);

package/dist/typescript/ast-helpers.d.ts

@@ -18,6 +18,7 @@ type LiteralLikeElementAccessExpression = ts.ElementAccessExpression & ts.Declar
 export declare function isModuleExportsAccessExpression(node: ts.Node): node is LiteralLikeElementAccessExpression & {
     expression: ts.Identifier;
 };
+export declare function stripQuotes(name: string): string;
 export declare function findAncestor<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T | undefined;
 export declare function findDescendants<T>(node: ts.Node | undefined, callback: (element: ts.Node) => boolean | 'STOP'): T[];
 export declare const isDeclarationFileExtension: (extension: string) => boolean;

package/dist/typescript/ast-helpers.js

@@ -1,5 +1,4 @@
 import ts from 'typescript';
-import { stripQuotes } from '../util/string.js';
 export function isValidImportTypeNode(node) {
     return ts.isImportTypeNode(node);
 }
@@ -40,6 +39,24 @@ export function isModuleExportsAccessExpression(node) {
         node.expression.escapedText === 'module' &&
         getAccessExpressionName(node) === 'exports');
 }
+export function stripQuotes(name) {
+    const length = name.length;
+    if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
+        return name.substring(1, length - 1);
+    }
+    return name;
+}
+var CharacterCodes;
+(function (CharacterCodes) {
+    CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick";
+    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+    CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
+})(CharacterCodes || (CharacterCodes = {}));
+function isQuoteOrBacktick(charCode) {
+    return (charCode === CharacterCodes.singleQuote ||
+        charCode === CharacterCodes.doubleQuote ||
+        charCode === CharacterCodes.backtick);
+}
 export function findAncestor(node, callback) {
     node = node?.parent;
     while (node) {

package/dist/typescript/visitors/exports/exportAssignment.js

@@ -3,6 +3,7 @@ import { SymbolType } from '../../../types/issues.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (ts.isExportAssignment(node)) {
-        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: node.expression.getStart() };
+        const pos = node.getChildAt(1).getStart();
+        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos };
     }
 });

package/dist/typescript/visitors/exports/exportKeyword.js

@@ -1,8 +1,7 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
 import { compact } from '../../../util/array.js';
-import { stripQuotes } from '../../../util/string.js';
-import { isPrivateMember } from '../../ast-helpers.js';
+import { isPrivateMember, stripQuotes } from '../../ast-helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     const modifierKinds = node.modifiers?.map(modifier => modifier.kind) ?? [];

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -1,7 +1,6 @@
 import ts from 'typescript';
 import { SymbolType } from '../../../types/issues.js';
-import { stripQuotes } from '../../../util/string.js';
-import { isModuleExportsAccessExpression } from '../../ast-helpers.js';
+import { isModuleExportsAccessExpression, stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isJS, node => {

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { stripQuotes } from '../../../util/string.js';
+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)) {

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { stripQuotes } from '../../../util/string.js';
+import { stripQuotes } from '../../ast-helpers.js';
 import { scriptVisitor as visit } from '../index.js';
 export default visit(sourceFile => ts.getShebang(sourceFile.text) === '#!/usr/bin/env zx', node => {
     if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.19.9";
+export declare const version = "2.19.11";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.19.9';
+export const version = '2.19.11';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.19.9",
+  "version": "2.19.11",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -42,6 +42,7 @@
     "schema.json"
   ],
   "dependencies": {
+    "@ericcornelissen/bash-parser": "^0.5.2",
     "@npmcli/map-workspaces": "^3.0.4",
     "@snyk/github-codeowners": "^1.1.0",
     "chalk": "^5.2.0",
@@ -55,8 +56,6 @@
     "pretty-ms": "^8.0.0",
     "strip-json-comments": "^5.0.0",
     "summary": "^2.1.0",
-    "tree-sitter": "0.20.5",
-    "tree-sitter-bash": "0.19.0",
     "typescript": "^5.0.2",
     "zod": "^3.22.2",
     "zod-validation-error": "^1.5.0"

package/dist/util/string.d.ts

@@ -1 +0,0 @@
-export declare function stripQuotes(name: string): string;

package/dist/util/string.js

@@ -1,18 +0,0 @@
-export function stripQuotes(name) {
-    const length = name.length;
-    if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
-        return name.substring(1, length - 1);
-    }
-    return name;
-}
-var CharacterCodes;
-(function (CharacterCodes) {
-    CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick";
-    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
-    CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
-})(CharacterCodes || (CharacterCodes = {}));
-function isQuoteOrBacktick(charCode) {
-    return (charCode === CharacterCodes.singleQuote ||
-        charCode === CharacterCodes.doubleQuote ||
-        charCode === CharacterCodes.backtick);
-}