knip 5.34.0 → 5.34.2

package/dist/IssueCollector.js

@@ -52,9 +52,10 @@ export class IssueCollector {
             return;
         const key = relative(this.cwd, issue.filePath);
         issue.severity = this.rules[issue.type];
-        this.issues[issue.type][key] = this.issues[issue.type][key] ?? {};
-        if (!this.issues[issue.type][key][issue.symbol]) {
-            this.issues[issue.type][key][issue.symbol] = issue;
+        const issues = this.issues[issue.type];
+        issues[key] = issues[key] ?? {};
+        if (!issues[key][issue.symbol]) {
+            issues[key][issue.symbol] = issue;
             this.counters[issue.type]++;
         }
         return issue;

package/dist/binaries/bash-parser.js

@@ -2,11 +2,11 @@ import parse, {} from '../../vendor/bash-parser/index.js';
 import { pluginArgsMap } from '../plugins.js';
 import { debugLogObject } from '../util/debug.js';
 import { toBinary, toDeferResolve } from '../util/input.js';
+import { extractBinary } from '../util/modules.js';
 import { resolve as fallbackResolve } from './fallback.js';
 import PackageManagerResolvers from './package-manager/index.js';
-import { parseNodeArgs } from './package-manager/node.js';
 import { resolve as resolverFromPlugins } from './plugins.js';
-import { trimBinary } from './util.js';
+import { parseNodeArgs } from './util.js';
 const spawningBinaries = ['cross-env', 'retry-cli'];
 const isExpansion = (node) => 'expansion' in node;
 const isAssignment = (node) => 'type' in node && node.type === 'AssignmentWord';
@@ -23,7 +23,7 @@ export const getDependenciesFromScript = (script, options) => {
         switch (node.type) {
             case 'Command': {
                 const text = node.name?.text;
-                const binary = text ? trimBinary(text) : text;
+                const binary = text ? extractBinary(text) : text;
                 const commandExpansions = node.prefix
                     ?.filter(isExpansion)
                     .map(prefix => prefix.expansion)

package/dist/binaries/index.js

@@ -1,12 +1,14 @@
 import { timerify } from '../util/Performance.js';
-import { fromBinary, isBinary } from '../util/input.js';
+import { fromBinary, isBinary, isDependency } from '../util/input.js';
 import { getDependenciesFromScript } from './bash-parser.js';
 const getInputsFromScripts = (npmScripts, options) => {
     const scripts = typeof npmScripts === 'string' ? [npmScripts] : Array.from(npmScripts);
     const results = scripts.flatMap(script => getDependenciesFromScript(script, options));
     const inputs = new Set();
     for (const input of results) {
-        if (!input.specifier || input.specifier.startsWith('http'))
+        if (!input.specifier)
+            continue;
+        if (isDependency(input) && input.specifier.startsWith('http'))
             continue;
         if (isBinary(input) && !/^\b/.test(fromBinary(input)))
             continue;

package/dist/binaries/package-manager/npx.js

@@ -1,7 +1,8 @@
 import parseArgs from 'minimist';
 import { toBinary, toDependency } from '../../util/input.js';
+import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';
-import { argsFrom, stripVersionFromSpecifier } from '../util.js';
+import { argsFrom } from '../util.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs } = options;
     const parsed = parseArgs(args, {

package/dist/binaries/util.d.ts

@@ -1,3 +1,3 @@
-export declare const stripVersionFromSpecifier: (specifier: string) => string;
-export declare const trimBinary: (command: string) => string;
+import parseArgs from 'minimist';
 export declare const argsFrom: (args: string[], from: string) => string[];
+export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;

package/dist/binaries/util.js

@@ -1,6 +1,6 @@
-export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
-const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
-export const trimBinary = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)
-    .replace(/^(\.bin\/)/, '')
-    .replace(/\$\(npm bin\)\/(\w+)/, '$1'));
+import parseArgs from 'minimist';
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));
+export const parseNodeArgs = (args) => parseArgs(args, {
+    string: ['r'],
+    alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
+});

package/dist/index.js

@@ -10,9 +10,9 @@ import { _getInputsFromScripts } from './binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
 import { debugLog, debugLogArray, debugLogObject } from './util/debug.js';
 import { getOrCreateFileNode, updateImportMap } from './util/dependency-graph.js';
+import { getReferencedInputsHandler } from './util/get-referenced-inputs.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { _glob, negate } from './util/glob.js';
-import { getReferencedDependencyHandler } from './util/handle-referenced-dependency.js';
 import { getHasStrictlyNsReferences, getType } from './util/has-strictly-ns-references.js';
 import { isConfigPattern, isEntry, isProductionEntry, toProductionEntry } from './util/input.js';
 import { getIsIdentifierReferencedHandler } from './util/is-identifier-referenced.js';
@@ -59,7 +59,7 @@ export const main = async (unresolvedConfiguration) => {
     debugLogObject('*', 'Included workspace configs', o);
     const isGitIgnored = await getGitIgnoredHandler({ cwd, gitignore });
     const toSourceFilePath = getToSourcePathHandler(chief);
-    const getReferencedInternalFilePath = getReferencedDependencyHandler(collector, deputy, chief, isGitIgnored);
+    const getReferencedInternalFilePath = getReferencedInputsHandler(collector, deputy, chief, isGitIgnored);
     const shouldIgnore = getShouldIgnoreHandler(isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(tags);
     for (const workspace of workspaces) {
@@ -461,7 +461,13 @@ export const main = async (unresolvedConfiguration) => {
                         const packageName = getPackageNameFromModuleSpecifier(specifier);
                         const isHandled = packageName && deputy.maybeAddReferencedExternalDependency(ws, packageName);
                         if (!isHandled)
-                            collector.addIssue({ type: 'unlisted', filePath, workspace: ws.name, symbol: specifier });
+                            collector.addIssue({
+                                type: 'unlisted',
+                                filePath,
+                                workspace: ws.name,
+                                symbol: packageName ?? specifier,
+                                specifier,
+                            });
                     }
                 }
                 if (file.imports?.unresolved) {

package/dist/plugins/typescript/index.js

@@ -12,15 +12,18 @@ const resolveConfig = async (localConfig, options) => {
     const extend = localConfig.extends
         ? [localConfig.extends].flat().map(specifier => toConfig('typescript', specifier, options.configFilePath))
         : [];
+    const references = localConfig.references
+        ?.filter(reference => reference.path.endsWith('.json'))
+        .map(reference => toConfig('typescript', reference.path, options.configFilePath)) ?? [];
     if (!(compilerOptions && localConfig))
-        return extend;
+        return compact([...extend, ...references]);
     const jsx = (compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : []).map(toProductionDependency);
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
         : [];
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
-    return compact([...extend, ...[...types, ...plugins, ...importHelpers].map(toDeferResolve), ...jsx]);
+    return compact([...extend, ...references, ...[...types, ...plugins, ...importHelpers].map(toDeferResolve), ...jsx]);
 };
 const args = {
     binaries: ['tsc'],

package/dist/reporters/symbols.js

@@ -3,13 +3,23 @@ import picocolors from 'picocolors';
 import { ROOT_WORKSPACE_NAME } from '../constants.js';
 import { relative, toRelative } from '../util/path.js';
 import { getTitle, identity, logTitle } from './util.js';
+const dim = picocolors.gray;
+const bright = picocolors.whiteBright;
 const TRUNCATE_WIDTH = 40;
 const truncate = (text) => (text.length > TRUNCATE_WIDTH ? `${text.slice(0, TRUNCATE_WIDTH - 3)}...` : text);
+const hl = (issue) => {
+    if (issue.specifier && issue.specifier !== issue.symbol && issue.specifier.includes(issue.symbol)) {
+        const parts = issue.specifier.split(issue.symbol);
+        const rest = parts.slice(1).join('');
+        return [dim(parts[0]), bright(issue.symbol), dim(rest)].join('');
+    }
+    return issue.symbol;
+};
 const logIssueRecord = (issues) => {
     const table = new EasyTable();
     for (const issue of issues) {
-        const print = issue.isFixed || issue.severity === 'warn' ? picocolors.gray : identity;
-        table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.map(s => s.symbol).join(', ')) : issue.symbol));
+        const print = issue.isFixed || issue.severity === 'warn' ? dim : identity;
+        table.cell('symbol', print(issue.symbols ? truncate(issue.symbols.map(s => s.symbol).join(', ')) : hl(issue)));
         issue.parentSymbol && table.cell('parentSymbol', print(issue.parentSymbol));
         issue.symbolType && table.cell('symbolType', print(issue.symbolType));
         const pos = issue.line === undefined ? '' : `:${issue.line}${issue.col === undefined ? '' : `:${issue.col}`}`;
@@ -35,9 +45,9 @@ export default ({ report, issues, tagHints, configurationHints, noConfigHints, i
                     for (const issue of issuesForType) {
                         const relPath = toRelative(issue.filePath);
                         if (issue.isFixed)
-                            console.log(picocolors.gray(`${relPath} (removed)`));
+                            console.log(dim(`${relPath} (removed)`));
                         else if (issue.severity === 'warn')
-                            console.log(picocolors.gray(relPath));
+                            console.log(dim(relPath));
                         else
                             console.log(relPath);
                     }
@@ -61,7 +71,7 @@ export default ({ report, issues, tagHints, configurationHints, noConfigHints, i
                 const { type, workspaceName, identifier } = hint;
                 const message = `Unused item in ${type}`;
                 const workspace = workspaceName && workspaceName !== ROOT_WORKSPACE_NAME ? ` (workspace: ${workspaceName})` : '';
-                console.warn(picocolors.gray(`${message}${workspace}:`), identifier);
+                console.warn(dim(`${message}${workspace}:`), identifier);
             }
         }
         if (tagHints.size > 0) {
@@ -69,7 +79,7 @@ export default ({ report, issues, tagHints, configurationHints, noConfigHints, i
             for (const hint of tagHints) {
                 const { filePath, identifier, tagName } = hint;
                 const message = `Unused tag in ${toRelative(filePath)}:`;
-                console.warn(picocolors.gray(message), `${identifier} → ${tagName}`);
+                console.warn(dim(message), `${identifier} → ${tagName}`);
             }
         }
     }

package/dist/types/issues.d.ts

@@ -21,6 +21,7 @@ export type Issue = {
     symbols?: IssueSymbol[];
     symbolType?: SymbolType;
     parentSymbol?: string;
+    specifier?: string;
     severity?: IssueSeverity;
     pos?: number;
     line?: number;

package/dist/util/{handle-referenced-dependency.d.ts → get-referenced-inputs.d.ts}

@@ -2,4 +2,4 @@ import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 import type { DependencyDeputy } from '../DependencyDeputy.js';
 import type { IssueCollector } from '../IssueCollector.js';
 import { type Input } from './input.js';
-export declare const getReferencedDependencyHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean) => (input: Input, workspace: Workspace) => string | undefined;
+export declare const getReferencedInputsHandler: (collector: IssueCollector, deputy: DependencyDeputy, chief: ConfigurationChief, isGitIgnored: (s: string) => boolean) => (input: Input, workspace: Workspace) => string | undefined;

package/dist/util/{handle-referenced-dependency.js → get-referenced-inputs.js}

@@ -5,7 +5,7 @@ import { fromBinary, isBinary, isConfigPattern, isDeferResolveEntry, isDependenc
 import { getPackageNameFromSpecifier } from './modules.js';
 import { dirname, isAbsolute, isInternal, join } from './path.js';
 import { _resolveSync } from './resolve.js';
-export const getReferencedDependencyHandler = (collector, deputy, chief, isGitIgnored) => (input, workspace) => {
+export const getReferencedInputsHandler = (collector, deputy, chief, isGitIgnored) => (input, workspace) => {
     const { specifier, containingFilePath } = input;
     if (!containingFilePath || IGNORED_RUNTIME_DEPENDENCIES.has(specifier))
         return;
@@ -20,6 +20,7 @@ export const getReferencedDependencyHandler = (collector, deputy, chief, isGitIg
             filePath: containingFilePath,
             workspace: workspace.name,
             symbol: binaryName,
+            specifier,
         });
         return;
     }
@@ -36,7 +37,8 @@ export const getReferencedDependencyHandler = (collector, deputy, chief, isGitIg
                             type: 'unlisted',
                             filePath: containingFilePath,
                             workspace: specifierWorkspace.name,
-                            symbol: specifier,
+                            symbol: packageName ?? specifier,
+                            specifier,
                         });
                     }
                     return;
@@ -64,6 +66,7 @@ export const getReferencedDependencyHandler = (collector, deputy, chief, isGitIg
             filePath: containingFilePath,
             workspace: workspace.name,
             symbol: packageName ?? specifier,
+            specifier,
         });
     }
     else if (!isGitIgnored(filePath)) {

package/dist/util/modules.d.ts

@@ -2,6 +2,8 @@ export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string
 export declare const getPackageNameFromFilePath: (value: string) => string;
 export declare const getPackageNameFromSpecifier: (specifier: string) => string | undefined;
 export declare const isStartsLikePackageName: (specifier: string) => boolean;
+export declare const stripVersionFromSpecifier: (specifier: string) => string;
+export declare const extractBinary: (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

@@ -9,6 +9,8 @@ export const getPackageNameFromModuleSpecifier = (moduleSpecifier) => {
 };
 const lastPackageNameMatch = /(?<=node_modules\/)(@[^/]+\/[^/]+|[^/]+)/g;
 export const getPackageNameFromFilePath = (value) => {
+    if (value.includes('node_modules/.bin/'))
+        return extractBinary(value);
     const match = toPosix(value).match(lastPackageNameMatch);
     if (match)
         return match[match.length - 1];
@@ -16,6 +18,11 @@ export const getPackageNameFromFilePath = (value) => {
 };
 export const getPackageNameFromSpecifier = (specifier) => isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : getPackageNameFromModuleSpecifier(specifier);
 export const isStartsLikePackageName = (specifier) => /^(@[a-z0-9._]|[a-z0-9])/.test(specifier);
+export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
+const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
+export const extractBinary = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)
+    .replace(/^(\.bin\/)/, '')
+    .replace(/\$\(npm bin\)\/(\w+)/, '$1'));
 export const isDefinitelyTyped = (packageName) => packageName.startsWith(`${DT_SCOPE}/`);
 export const getDefinitelyTypedFor = (packageName) => {
     if (isDefinitelyTyped(packageName))

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.34.0";
+export declare const version = "5.34.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.34.0';
+export const version = '5.34.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.34.0",
+  "version": "5.34.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {

package/dist/binaries/package-manager/node.d.ts

@@ -1,2 +0,0 @@
-import parseArgs from 'minimist';
-export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;

package/dist/binaries/package-manager/node.js

@@ -1,5 +0,0 @@
-import parseArgs from 'minimist';
-export const parseNodeArgs = (args) => parseArgs(args, {
-    string: ['r'],
-    alias: { require: ['r', 'loader', 'experimental-loader', 'test-reporter', 'watch', 'import'] },
-});