knip 2.19.10 → 2.19.11

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/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.10";
+export declare const version = "2.19.11";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.19.10",
+  "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);
-}