knip 2.17.1 → 2.17.2

package/dist/ConfigurationChief.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="npmcli__package-json" />
 import type { SyncCompilers, AsyncCompilers } from './types/compilers.js';
-import type { RawConfiguration, Configuration, WorkspaceConfiguration } from './types/config.js';
+import type { Configuration, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJson } from '@npmcli/package-json';
 type ConfigurationManagerOptions = {
     cwd: string;
@@ -19,56 +19,32 @@ export declare class ConfigurationChief {
     config: Configuration;
     manifestPath?: string;
     manifest?: PackageJson;
-    ignoreWorkspaces: string[];
+    ignoredWorkspacePatterns: string[];
     manifestWorkspaces: Map<string, string>;
-    additionalWorkspaces: Set<string>;
-    workspaceDirs: string[];
-    workspaces: Workspace[];
+    additionalWorkspaceNames: Set<string>;
+    enabledWorkspaceNames: string[];
+    enabledWorkspaceDirs: string[];
+    enabledWorkspaces: Workspace[];
     localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
     init(): Promise<void>;
     getCompilers(): [SyncCompilers, AsyncCompilers];
     getRules(): import("./types/issues.js").Rules;
-    normalize(rawLocalConfig: RawConfiguration): {
-        rules: {
-            files: import("./types/issues.js").IssueSeverity;
-            dependencies: import("./types/issues.js").IssueSeverity;
-            devDependencies: import("./types/issues.js").IssueSeverity;
-            unlisted: import("./types/issues.js").IssueSeverity;
-            binaries: import("./types/issues.js").IssueSeverity;
-            unresolved: import("./types/issues.js").IssueSeverity;
-            exports: import("./types/issues.js").IssueSeverity;
-            types: import("./types/issues.js").IssueSeverity;
-            nsExports: import("./types/issues.js").IssueSeverity;
-            nsTypes: import("./types/issues.js").IssueSeverity;
-            duplicates: import("./types/issues.js").IssueSeverity;
-            enumMembers: import("./types/issues.js").IssueSeverity;
-            classMembers: import("./types/issues.js").IssueSeverity;
-        };
-        include: string[];
-        exclude: string[];
-        ignore: string[];
-        ignoreBinaries: string[];
-        ignoreDependencies: string[];
-        ignoreExportsUsedInFile: boolean | Partial<Record<"function" | "type" | "enum" | "class" | "interface" | "member", boolean>>;
-        ignoreWorkspaces: string[];
-        syncCompilers: Map<string, (args_0: string, ...args_1: unknown[]) => string>;
-        asyncCompilers: Map<string, (args_0: string, ...args_1: unknown[]) => Promise<string>>;
-        workspaces: Record<string, WorkspaceConfiguration>;
-    };
-    setWorkspaces(): Promise<void>;
+    private normalize;
+    private setWorkspaces;
+    private getListedWorkspaces;
+    private getIgnoredWorkspacePatterns;
     private getManifestWorkspaces;
-    private getAdditionalWorkspaces;
-    private getAllWorkspaceNames;
-    private getAllWorkspaces;
-    getEnabledWorkspaces(): Workspace[];
-    getDescendentWorkspaces(name: string): string[];
-    getIgnoredWorkspaces(): string[];
-    getIgnoredWorkspacesFor(name: string): string[];
+    private getAdditionalWorkspaceNames;
+    private getEnabledWorkspaceNames;
+    private getEnabledWorkspaces;
+    getWorkspaces(): Workspace[];
+    private getDescendentWorkspaces;
+    private getIgnoredWorkspacesFor;
     getNegatedWorkspacePatterns(name: string): string[];
     private getConfigKeyForWorkspace;
-    getConfigForWorkspace(workspaceName: string): WorkspaceConfiguration;
+    private getConfigForWorkspace;
     getIssueTypesToReport(): import("./types/issues.js").Report;
     findWorkspaceByFilePath(filePath: string): Workspace | undefined;
     findWorkspaceByPackageName(packageName: string): Workspace | undefined;

package/dist/ConfigurationChief.js

@@ -51,11 +51,12 @@ export class ConfigurationChief {
     config;
     manifestPath;
     manifest;
-    ignoreWorkspaces = [];
+    ignoredWorkspacePatterns = [];
     manifestWorkspaces = new Map();
-    additionalWorkspaces = new Set();
-    workspaceDirs = [];
-    workspaces = [];
+    additionalWorkspaceNames = new Set();
+    enabledWorkspaceNames = [];
+    enabledWorkspaceDirs = [];
+    enabledWorkspaces = [];
     localWorkspaces = new Set();
     resolvedConfigFilePath;
     constructor({ cwd, isProduction }) {
@@ -165,15 +166,29 @@ export class ConfigurationChief {
         };
     }
     async setWorkspaces() {
-        this.ignoreWorkspaces = this.getIgnoredWorkspaces();
+        this.ignoredWorkspacePatterns = this.getIgnoredWorkspacePatterns();
         this.manifestWorkspaces = await this.getManifestWorkspaces();
-        this.additionalWorkspaces = await this.getAdditionalWorkspaces();
-        this.localWorkspaces = new Set(compact(this.getAllWorkspaces().map(w => w.pkgName)));
-        this.workspaces = this.getEnabledWorkspaces();
-        this.workspaceDirs = this.getAllWorkspaceNames()
+        this.additionalWorkspaceNames = await this.getAdditionalWorkspaceNames();
+        this.enabledWorkspaceNames = this.getEnabledWorkspaceNames();
+        this.enabledWorkspaces = this.getEnabledWorkspaces();
+        this.enabledWorkspaceDirs = this.enabledWorkspaceNames
             .sort(byPathDepth)
             .reverse()
             .map(dir => join(this.cwd, dir));
+        this.localWorkspaces = new Set(compact(this.enabledWorkspaces.map(w => w.pkgName)));
+    }
+    getListedWorkspaces() {
+        return this.manifest?.workspaces
+            ? Array.isArray(this.manifest.workspaces)
+                ? this.manifest.workspaces
+                : this.manifest.workspaces.packages ?? []
+            : [];
+    }
+    getIgnoredWorkspacePatterns() {
+        const ignoredWorkspaces = this.getListedWorkspaces()
+            .filter(name => name.startsWith('!'))
+            .map(name => name.replace(/^!/, ''));
+        return [...ignoredWorkspaces, ...this.config.ignoreWorkspaces];
     }
     async getManifestWorkspaces() {
         const workspaces = await mapWorkspaces({
@@ -186,18 +201,22 @@ export class ConfigurationChief {
         }
         return manifestWorkspaces;
     }
-    async getAdditionalWorkspaces() {
+    async getAdditionalWorkspaceNames() {
         const additionalWorkspaceKeys = Object.keys(this.config.workspaces);
         const patterns = additionalWorkspaceKeys.filter(key => key.includes('*'));
         const dirs = additionalWorkspaceKeys.filter(key => !key.includes('*'));
         const globbedDirs = await _dirGlob({ patterns, cwd: this.cwd });
-        return new Set([...dirs, ...globbedDirs].filter(name => name !== ROOT_WORKSPACE_NAME && !this.manifestWorkspaces.has(name) && !this.ignoreWorkspaces.includes(name)));
+        return new Set([...dirs, ...globbedDirs].filter(name => name !== ROOT_WORKSPACE_NAME &&
+            !this.manifestWorkspaces.has(name) &&
+            !micromatch.isMatch(name, this.ignoredWorkspacePatterns)));
     }
-    getAllWorkspaceNames() {
-        return compact([ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaces]);
+    getEnabledWorkspaceNames() {
+        return [ROOT_WORKSPACE_NAME, ...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames].filter(name => !micromatch.isMatch(name, this.ignoredWorkspacePatterns));
     }
-    getAllWorkspaces() {
-        const workspaceDirs = this.getAllWorkspaceNames();
+    getEnabledWorkspaces() {
+        const workspaceNames = workspaceArg
+            ? this.enabledWorkspaceNames.filter(name => name === workspaceArg)
+            : this.enabledWorkspaceNames;
         const getAncestors = (name) => (ancestors, ancestorName) => {
             if (name === ancestorName)
                 return ancestors;
@@ -205,36 +224,24 @@ export class ConfigurationChief {
                 ancestors.push(ancestorName);
             return ancestors;
         };
-        return workspaceDirs.sort(byPathDepth).map((name) => ({
+        return workspaceNames.sort(byPathDepth).map((name) => ({
             name,
             pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
             dir: join(this.cwd, name),
             config: this.getConfigForWorkspace(name),
-            ancestors: workspaceDirs.reduce(getAncestors(name), []),
+            ancestors: workspaceNames.reduce(getAncestors(name), []),
         }));
     }
-    getEnabledWorkspaces() {
-        const allWorkspaces = this.getAllWorkspaces();
-        const ignoredWorkspaces = this.getIgnoredWorkspaces();
-        const workspaces = workspaceArg ? allWorkspaces.filter(w => w.name === workspaceArg) : allWorkspaces;
-        return workspaces.filter(w => !ignoredWorkspaces.includes(w.name));
+    getWorkspaces() {
+        return this.enabledWorkspaces;
     }
     getDescendentWorkspaces(name) {
-        return this.getAllWorkspaceNames()
+        return this.enabledWorkspaceNames
             .filter(workspaceName => workspaceName !== name)
             .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name + '/'));
     }
-    getIgnoredWorkspaces() {
-        const ignored = this.config.ignoreWorkspaces;
-        const workspaces = this.manifest?.workspaces
-            ? Array.isArray(this.manifest.workspaces)
-                ? this.manifest.workspaces
-                : this.manifest.workspaces.packages ?? []
-            : [];
-        return [...ignored, ...workspaces.filter(name => name.startsWith('!'))].map(name => name.replace(/^!/, ''));
-    }
     getIgnoredWorkspacesFor(name) {
-        return this.getIgnoredWorkspaces()
+        return this.ignoredWorkspacePatterns
             .filter(workspaceName => workspaceName !== name)
             .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name));
     }
@@ -269,15 +276,15 @@ export class ConfigurationChief {
         return getIncludedIssueTypes(cliArgs, config);
     }
     findWorkspaceByFilePath(filePath) {
-        const workspaceDir = this.workspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir + '/'));
-        return this.workspaces.find(workspace => workspace.dir === workspaceDir);
+        const workspaceDir = this.enabledWorkspaceDirs.find(workspaceDir => filePath.startsWith(workspaceDir + '/'));
+        return this.enabledWorkspaces.find(workspace => workspace.dir === workspaceDir);
     }
     findWorkspaceByPackageName(packageName) {
-        return this.workspaces.find(workspace => workspace.pkgName === packageName);
+        return this.enabledWorkspaces.find(workspace => workspace.pkgName === packageName);
     }
     getUnusedIgnoredWorkspaces() {
         const ignoredWorkspaceNames = this.config.ignoreWorkspaces;
-        const workspaceNames = this.getAllWorkspaceNames();
-        return ignoredWorkspaceNames.filter(workspaceName => !workspaceNames.includes(workspaceName));
+        const workspaceNames = [...this.manifestWorkspaces.keys(), ...this.additionalWorkspaceNames];
+        return ignoredWorkspaceNames.filter(ignoredWorkspaceName => !workspaceNames.some(name => micromatch.isMatch(name, ignoredWorkspaceName)));
     }
 }

package/dist/binaries/resolvers/fallback.js

@@ -13,7 +13,7 @@ const argFilters = {
     tsx: parsed => parsed._.filter(p => p !== 'watch'),
     default: withoutPositional,
 };
-const spawningBinaries = ['cross-env'];
+const spawningBinaries = ['cross-env', 'retry-cli'];
 export const resolve = (binary, args, { cwd, fromArgs }) => {
     const parsed = parseArgs(args, { string: ['r'], alias: { require: ['r', 'loader'] }, boolean: ['quiet', 'verbose'] });
     const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : toBinary(binary);

package/dist/binaries/resolvers/npx.js

@@ -1,24 +1,20 @@
 import parseArgs from 'minimist';
 import { isInternal } from '../../util/path.js';
-import { fromBinary, toBinary } from '../util.js';
-export const resolve = (binary, args, { fromArgs, manifest }) => {
+import { getBinariesFromScript } from '../bash-parser.js';
+import { argsFrom, stripVersionFromSpecifier, toBinary } from '../util.js';
+export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
     const parsed = parseArgs(args, {
-        '--': true,
-        stopEarly: true,
         boolean: ['yes', 'no'],
-        alias: { yes: 'y', no: 'no-install' },
+        alias: { yes: 'y', no: 'no-install', package: 'p', call: 'c' },
     });
-    const leftParsed = fromArgs(parsed._);
-    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];
+    const packageSpecifier = parsed._[0];
+    const specifier = packageSpecifier ? stripVersionFromSpecifier(packageSpecifier) : '';
+    const packages = parsed.package ? [parsed.package].flat().map(stripVersionFromSpecifier) : [];
+    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);
+    const dependency = isBinary ? toBinary(specifier) : specifier;
+    const specifiers = dependency && !parsed.yes ? [dependency] : [];
+    return [...specifiers, ...packages, ...command, ...fromArgs(restArgs).slice(1)];
 };

package/dist/binaries/util.d.ts

@@ -3,5 +3,6 @@ export declare const tryResolveSpecifiers: (cwd: string, specifiers: 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 stripVersionFromSpecifier: (specifier: string) => string;
 export declare const stripBinaryPath: (command: string) => string;
 export declare const argsFrom: (args: string[], from: string) => string[];

package/dist/binaries/util.js

@@ -25,9 +25,9 @@ export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(specifie
 export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
 export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
 export const isBinary = (specifier) => specifier.startsWith('bin:');
+export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
 const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
-export const stripBinaryPath = (command) => stripNodeModulesFromPath(command)
+export const stripBinaryPath = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)
     .replace(/^(\.bin\/)/, '')
-    .replace(/\$\(npm bin\)\/(\w+)/, '$1')
-    .replace(/(\S+)@.*/, '$1');
+    .replace(/\$\(npm bin\)\/(\w+)/, '$1'));
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));

package/dist/index.js

@@ -28,7 +28,7 @@ export const main = async (unresolvedConfiguration) => {
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
     const compilers = chief.getCompilers();
-    const workspaces = chief.getEnabledWorkspaces();
+    const workspaces = chief.getWorkspaces();
     const report = chief.getIssueTypesToReport();
     const rules = chief.getRules();
     const isReportDependencies = report.dependencies || report.unlisted || report.unresolved;

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

@@ -1,5 +1,6 @@
+import type { VitestConfig } from './types.js';
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 export declare const getEnvPackageName: (env: VitestEnvironment) => any;
-export declare const getExternalReporters: (reporters?: string | string[]) => string[];
+export declare const getExternalReporters: (reporters?: VitestConfig['test']['reporters']) => unknown[];
 export {};

package/dist/plugins/vitest/helpers.js

@@ -17,4 +17,6 @@ export const getEnvPackageName = (env) => {
     return `vitest-environment-${env}`;
 };
 const builtInReporters = ['default', 'verbose', 'dot', 'json', 'tap', 'tap-flat', 'junit', 'hanging-process'];
-export const getExternalReporters = (reporters) => reporters ? [reporters].flat().filter(reporter => !builtInReporters.includes(reporter)) : [];
+export const getExternalReporters = (reporters) => reporters
+    ? [reporters].flat().filter(reporter => typeof reporter === 'string' && !builtInReporters.includes(reporter))
+    : [];

package/dist/plugins/vitest/types.d.ts

@@ -5,7 +5,7 @@ export type VitestConfig = {
         };
         environment?: string;
         globalSetup?: string | string[];
-        reporters?: string[];
+        reporters?: (string | unknown)[];
         setupFiles?: string | string[];
     };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.17.1";
+export declare const version = "2.17.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.17.1';
+export const version = '2.17.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.17.1",
+  "version": "2.17.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",