knip 2.10.0 → 2.10.2

package/dist/ConfigurationChief.js

@@ -195,6 +195,7 @@ export class ConfigurationChief {
     }
     getEnabledWorkspaces() {
         const allWorkspaces = this.getAllWorkspaces();
+        const ignoredWorkspaces = this.getIgnoredWorkspaces();
         const getAncestors = (name) => (ancestors, ancestorName) => {
             if (name === ancestorName)
                 return ancestors;
@@ -203,7 +204,10 @@ export class ConfigurationChief {
             return ancestors;
         };
         const workspaces = workspaceArg ? [workspaceArg] : allWorkspaces;
-        return workspaces.sort(byPathDepth).map((name) => ({
+        return workspaces
+            .filter(w => !ignoredWorkspaces.includes(w))
+            .sort(byPathDepth)
+            .map((name) => ({
             name,
             pkgName: this.manifestWorkspaces.get(name) ?? this.manifest?.name,
             dir: join(this.cwd, name),

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES } from './constants.js';
+import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 export class DependencyDeputy {
     isStrict;
@@ -191,27 +191,34 @@ export class DependencyDeputy {
             const referencedDependencies = this.referencedDependencies.get(workspaceName);
             const referencedBinaries = this.referencedBinaries.get(workspaceName);
             const installedBinaries = this.getInstalledBinaries(workspaceName);
+            referencedDependencies?.forEach(pkg => pkg in rootIgnoreDependencies && rootIgnoreDependencies[pkg]++);
             referencedBinaries?.forEach(binaryName => binaryName in rootIgnoreBinaries && rootIgnoreBinaries[binaryName]++);
-            const allDeps = [...this.getProductionDependencies(workspaceName), ...this.getDevDependencies(workspaceName)];
-            const isReferencedDep = (name) => referencedDependencies?.has(name) || (allDeps.includes(name) && !referencedDependencies?.has(name));
-            const isReferencedBin = (name) => !installedBinaries?.has(name) && referencedBinaries?.has(name);
+            const dependencies = this.isStrict
+                ? this.getProductionDependencies(workspaceName)
+                : [...this.getProductionDependencies(workspaceName), ...this.getDevDependencies(workspaceName)];
+            const isReferencedDep = (name) => referencedDependencies?.has(name) && dependencies.includes(name);
+            const isReferencedBin = (name) => referencedBinaries?.has(name) && installedBinaries?.has(name);
             ignoreDependencies
                 .filter(packageName => IGNORED_DEPENDENCIES.includes(packageName) ||
-                (workspaceName !== '.' && this.ignoreDependencies.includes(packageName)) ||
-                !isReferencedDep(packageName))
+                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreDependencies.includes(packageName)) ||
+                isReferencedDep(packageName))
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' }));
             ignoreBinaries
                 .filter(binaryName => IGNORED_GLOBAL_BINARIES.includes(binaryName) ||
-                (workspaceName !== '.' && this.ignoreBinaries.includes(binaryName)) ||
-                !isReferencedBin(binaryName))
+                (workspaceName !== ROOT_WORKSPACE_NAME && this.ignoreBinaries.includes(binaryName)) ||
+                isReferencedBin(binaryName))
                 .forEach(identifier => configurationHints.add({ workspaceName, identifier, type: 'ignoreBinaries' }));
         }
+        const installedBinaries = this.getInstalledBinaries(ROOT_WORKSPACE_NAME);
+        const dependencies = this.isStrict
+            ? this.getProductionDependencies(ROOT_WORKSPACE_NAME)
+            : [...this.getProductionDependencies(ROOT_WORKSPACE_NAME), ...this.getDevDependencies(ROOT_WORKSPACE_NAME)];
         Object.keys(rootIgnoreBinaries)
-            .filter(key => rootIgnoreBinaries[key] === 0)
-            .forEach(identifier => configurationHints.add({ workspaceName: '.', identifier, type: 'ignoreBinaries' }));
+            .filter(key => IGNORED_GLOBAL_BINARIES.includes(key) || (rootIgnoreBinaries[key] !== 0 && installedBinaries?.has(key)))
+            .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreBinaries' }));
         Object.keys(rootIgnoreDependencies)
-            .filter(key => rootIgnoreDependencies[key] === 0)
-            .forEach(identifier => configurationHints.add({ workspaceName: '.', identifier, type: 'ignoreDependencies' }));
+            .filter(key => IGNORED_DEPENDENCIES.includes(key) || (rootIgnoreDependencies[key] !== 0 && dependencies.includes(key)))
+            .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
         return { configurationHints };
     }
 }

package/dist/binaries/resolvers/fallback.js

@@ -1,6 +1,6 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePath, tryResolveFilePaths } from '../util.js';
+import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 const withPositional = parsed => [parsed._[0], parsed.require].flat();
 const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {
@@ -17,6 +17,6 @@ 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));
-    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary, binary) : [toBinary(binary)];
-    return [...bin, ...tryResolveFilePaths(cwd, filteredArgs)];
+    const bin = binary.startsWith('.') ? tryResolveFilePath(cwd, binary) : [toBinary(binary)];
+    return [...bin, ...tryResolveSpecifiers(cwd, filteredArgs)];
 };

package/dist/binaries/resolvers/node.js

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

package/dist/binaries/resolvers/rollup.js

@@ -1,10 +1,10 @@
 import parseArgs from 'minimist';
-import { toBinary, tryResolveFilePaths } from '../util.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)) : [];
-    const plugins = parsed.plugin ? tryResolveFilePaths(cwd, [parsed.plugin].flat()) : [];
-    const configPlugins = parsed.configPlugin ? tryResolveFilePaths(cwd, [parsed.configPlugin].flat()) : [];
+    const plugins = parsed.plugin ? tryResolveSpecifiers(cwd, [parsed.plugin].flat()) : [];
+    const configPlugins = parsed.configPlugin ? tryResolveSpecifiers(cwd, [parsed.configPlugin].flat()) : [];
     return [toBinary(binary), ...watchers, ...plugins, ...configPlugins];
 };

package/dist/binaries/util.d.ts

@@ -1,5 +1,5 @@
-export declare const tryResolveFilePath: (cwd: string, specifier: string, fallback?: string) => string[];
-export declare const tryResolveFilePaths: (cwd: string, specifiers: string[]) => string[];
+export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string[];
+export declare const tryResolveSpecifiers: (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;

package/dist/binaries/util.js

@@ -1,18 +1,23 @@
+import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { isInNodeModules, join } from '../util/path.js';
 import { _tryResolve } from '../util/require.js';
-export const tryResolveFilePath = (cwd, specifier, fallback) => {
+export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
     if (specifier) {
         const filePath = join(cwd, specifier);
         if (!isInNodeModules(filePath)) {
             const resolvedFilePath = _tryResolve(filePath, cwd);
             if (resolvedFilePath)
                 return [resolvedFilePath];
+            else if (acceptModuleSpecifier)
+                return [getPackageNameFromModuleSpecifier(specifier)];
+        }
+        else {
+            return [getPackageNameFromFilePath(specifier)];
         }
-        return fallback ? [stripNodeModulesFromPath(fallback)] : [];
     }
     return [];
 };
-export const tryResolveFilePaths = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, specifier));
+export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.flatMap(specifier => tryResolveFilePath(cwd, specifier, true));
 export const toBinary = (specifier) => specifier.replace(/^(bin:)?/, 'bin:');
 export const fromBinary = (specifier) => specifier.replace(/^(bin:)?/, '');
 export const isBinary = (specifier) => specifier.startsWith('bin:');

package/dist/index.js

@@ -1,3 +1,4 @@
+import micromatch from 'micromatch';
 import { _getDependenciesFromScripts } from './binaries/index.js';
 import { fromBinary, isBinary } from './binaries/util.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
@@ -42,7 +43,10 @@ export const main = async (unresolvedConfiguration) => {
             const absSpecifier = toAbsolute(specifier, dirname(containingFilePath));
             const filePath = _tryResolve(absSpecifier, containingFilePath);
             if (filePath) {
-                principal.addEntryPath(filePath);
+                const ignorePatterns = workspace.config.ignore.map(pattern => join(dirname(containingFilePath), pattern));
+                const isIgnored = micromatch.isMatch(filePath, ignorePatterns);
+                if (!isIgnored)
+                    principal.addEntryPath(filePath);
             }
             else {
                 collector.addIssue({ type: 'unresolved', filePath: containingFilePath, symbol: specifier });
@@ -277,7 +281,7 @@ export const main = async (unresolvedConfiguration) => {
                             }
                             continue;
                         }
-                        if (importedModule.isReExport || importedModule.isStar) {
+                        if (importedModule.isStar) {
                             const isReExportedByEntryFile = isExportedInEntryFile(importedModule);
                             if (!isReExportedByEntryFile && !principal.hasExternalReferences(filePath, exportedItem)) {
                                 if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
@@ -292,8 +296,13 @@ export const main = async (unresolvedConfiguration) => {
                             if (['enum', 'type', 'interface'].includes(exportedItem.type)) {
                                 collector.addIssue({ type: 'types', filePath, symbol, symbolType: exportedItem.type });
                             }
-                            else if (!importedModule.isDynamic || !principal.hasExternalReferences(filePath, exportedItem)) {
-                                collector.addIssue({ type: 'exports', filePath, symbol });
+                            else {
+                                if (importedModule.isReExport && !principal.hasExternalReferences(filePath, exportedItem)) {
+                                    collector.addIssue({ type: 'exports', filePath, symbol });
+                                }
+                                else if (!importedModule.isDynamic || !principal.hasExternalReferences(filePath, exportedItem)) {
+                                    collector.addIssue({ type: 'exports', filePath, symbol });
+                                }
                             }
                         }
                     }

package/dist/plugins/vitest/index.js

@@ -15,6 +15,8 @@ const findVitestDependencies = async (configFilePath) => {
     const environments = cfg.environment ? [getEnvPackageName(cfg.environment)] : [];
     const reporters = getExternalReporters(cfg.reporters);
     const coverage = cfg.coverage?.provider ? [`@vitest/coverage-${cfg.coverage.provider}`] : [];
-    return compact([...environments, ...reporters, ...coverage]);
+    const setupFiles = cfg.setupFiles ? [cfg.setupFiles].flat() : [];
+    const globalSetup = cfg.globalSetup ? [cfg.globalSetup].flat() : [];
+    return compact([...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup]);
 };
 export const findDependencies = timerify(findVitestDependencies);

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

@@ -1,9 +1,11 @@
 export type VitestConfig = {
     test: {
-        environment?: string;
-        reporters?: string[];
         coverage?: {
             provider: string;
         };
+        environment?: string;
+        globalSetup?: string | string[];
+        reporters?: string[];
+        setupFiles?: string | string[];
     };
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.10.0";
+export declare const version = "2.10.2";

package/dist/version.js

@@ -1 +1 @@
-export const version = '2.10.0';
+export const version = '2.10.2';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "2.10.0",
+  "version": "2.10.2",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://github.com/webpro/knip",
   "repository": "github:webpro/knip",
@@ -19,10 +19,10 @@
   "scripts": {
     "knip": "node ./dist/cli.js",
     "knip:production": "node ./dist/cli.js --production --strict",
-    "lint": "eslint src tests",
-    "lint:fix": "eslint src tests --fix",
+    "lint": "eslint scripts src tests",
+    "lint:fix": "eslint scripts src tests --fix",
     "format": "prettier scripts src tests schema.json --with-node-modules --write --config .prettierrc",
-    "test": "globstar -- node --loader tsx --test \"tests/**/*.test.ts\"",
+    "test": "globstar -- node --no-warnings --loader tsx --test \"tests/**/*.test.ts\"",
     "coverage": "c8 npm test",
     "watch": "tsc --watch",
     "prebuild": "node -e \"require('fs').rmSync('dist', { force: true, recursive: true })\"",
@@ -57,7 +57,7 @@
     "summary": "^2.1.0",
     "typescript": "^5.0.2",
     "zod": "^3.20.6",
-    "zod-validation-error": "1.2.1"
+    "zod-validation-error": "1.3.0"
   },
   "devDependencies": {
     "@jest/types": "29.5.0",
@@ -67,18 +67,18 @@
     "@types/js-yaml": "4.0.5",
     "@types/micromatch": "4.0.2",
     "@types/minimist": "1.2.2",
-    "@types/node": "18.15.11",
-    "@types/npmcli__map-workspaces": "3.0.0",
+    "@types/node": "18.16.0",
+    "@types/npmcli__map-workspaces": "3.0.1",
     "@types/webpack": "5.28.1",
-    "@typescript-eslint/eslint-plugin": "5.57.1",
-    "@typescript-eslint/parser": "5.57.1",
+    "@typescript-eslint/eslint-plugin": "5.59.0",
+    "@typescript-eslint/parser": "5.59.0",
     "c8": "7.13.0",
-    "eslint": "8.37.0",
+    "eslint": "8.39.0",
     "eslint-import-resolver-typescript": "3.5.5",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-n": "15.7.0",
     "globstar": "1.0.0",
-    "prettier": "2.8.7",
+    "prettier": "2.8.8",
     "release-it": "15.10.1",
     "remark-cli": "11.0.0",
     "remark-preset-webpro": "0.0.2",