knip 2.30.1 → 2.32.0

package/README.md

@@ -266,6 +266,7 @@ Knip contains a growing list of plugins:
 - [markdownlint][plugin-markdownlint]
 - [Mocha][plugin-mocha]
 - [Next.js][plugin-next]
+- [Node.js Test Runner][plugin-node-test-runner]
 - [npm-package-json-lint][plugin-npm-package-json-lint]
 - [Nx][plugin-nx]
 - [nyc][plugin-nyc]
@@ -310,35 +311,28 @@ unused or missing.
 Other configuration files use `require` or `import` statements to use dependencies, so they don't need special handing
 and can be analyzed like any other source file. That's why these configuration files are also used as `entry` files.
 
-#### Override plugin configuration
+#### Plugin configuration
 
-Usually, no custom configuration is required for plugins, but if your project uses custom file locations then Knip
-allows you to override any defaults. Let's take Cypress for example. By default it uses `cypress.config.js`, but your
-project uses `config/cypress.js`. Also, the default pattern for test files is `cypress/e2e/**/*.cy.js`, but your project
-has them at `e2e-tests/*.spec.ts`. Here's how to configure this:
+Is a plugin not behaving as expected? There are a few options to modify its behavior:
 
-```json
-{
-  "cypress": {
-    "entry": ["config/cypress.js", "e2e-tests/*.spec.js"]
-  }
-}
-```
-
-When overriding any plugin's configuration, the options object is fully replaced. Look at the plugin's page to find the
-default configuration and use that as a basis. Here's another example to override the test file pattern for Vitest:
+- Disable a plugin by setting its value to `false` (.e.g `"webpack": false`)
+- Force-enable a plugin by setting its value to `true`
+- Override a plugin's `config` or `entry` location, for example:
 
 ```json
 {
-  "vitest": {
-    "config": ["vitest.config.ts"],
-    "entry": ["**/*.vitest.ts"]
+  "mocha": {
+    "config": "config/mocha.config.js",
+    "entry": ["**/*.spec.js"]
   }
 }
 ```
 
-This plugin configuration can be set on root and workspace level. If set on root level, it can be disabled on workspace
-level by setting it to `false` there.
+It's rarely necessary to override the `entry` patterns, since plugins also read custom test file patterns from the
+tooling configuration (e.g. from the `include` option for Vitest or `testMatch` for Playwright).
+
+Plugin configuration can be set on root and workspace level. If enabled on root level, it can be disabled on workspace
+level by setting it to `false` there, and vice versa.
 
 #### Multi-project repositories
 
@@ -354,10 +348,6 @@ own Cypress configuration and test files. In that case, we could configure the C
 }
 ```
 
-#### Disable a plugin
-
-In case a plugin causes issues, it can be disabled by using `false` as its value (e.g. `"webpack": false`).
-
 #### Create a new plugin
 
 Getting false positives because a plugin is missing? Want to help out? Please read more at [writing a plugin][47]. This
@@ -920,6 +910,7 @@ Special thanks to the wonderful people who have contributed to this project:
 [plugin-markdownlint]: ./src/plugins/markdownlint
 [plugin-mocha]: ./src/plugins/mocha
 [plugin-next]: ./src/plugins/next
+[plugin-node-test-runner]: ./src/plugins/node-test-runner
 [plugin-npm-package-json-lint]: ./src/plugins/npm-package-json-lint
 [plugin-nx]: ./src/plugins/nx
 [plugin-nyc]: ./src/plugins/nyc

package/dist/ConfigurationChief.d.ts

@@ -27,6 +27,7 @@ export declare class ConfigurationChief {
     enabledWorkspaces: Workspace[];
     localWorkspaces: Set<string>;
     resolvedConfigFilePath?: string;
+    rawConfig?: any;
     constructor({ cwd, isProduction }: ConfigurationManagerOptions);
     init(): Promise<void>;
     getCompilers(): [SyncCompilers, AsyncCompilers];
@@ -36,6 +37,7 @@ export declare class ConfigurationChief {
     private getListedWorkspaces;
     private getIgnoredWorkspacePatterns;
     private getManifestWorkspaces;
+    private getConfiguredWorkspaceKeys;
     private getAdditionalWorkspaceNames;
     private getAvailableWorkspaceNames;
     private getEnabledWorkspaces;

package/dist/ConfigurationChief.js

@@ -41,9 +41,8 @@ const defaultConfig = {
     ignoreWorkspaces: [],
     syncCompilers: new Map(),
     asyncCompilers: new Map(),
-    workspaces: {
-        [ROOT_WORKSPACE_NAME]: getDefaultWorkspaceConfig(),
-    },
+    defaultWorkspaceConfig: getDefaultWorkspaceConfig(),
+    rootPluginConfigs: {},
 };
 const PLUGIN_NAMES = Object.keys(plugins);
 export class ConfigurationChief {
@@ -60,6 +59,7 @@ export class ConfigurationChief {
     enabledWorkspaces = [];
     localWorkspaces = new Set();
     resolvedConfigFilePath;
+    rawConfig;
     constructor({ cwd, isProduction }) {
         this.cwd = cwd;
         this.isProduction = isProduction;
@@ -86,11 +86,9 @@ export class ConfigurationChief {
         if (rawConfigArg && !this.resolvedConfigFilePath && !manifest.knip) {
             throw new ConfigurationError(`Unable to find ${rawConfigArg} or package.json#knip`);
         }
-        const rawLocalConfig = this.resolvedConfigFilePath ? await _load(this.resolvedConfigFilePath) : manifest.knip;
-        if (rawLocalConfig) {
-            const parsedConfig = ConfigurationValidator.parse(partitionCompilers(rawLocalConfig));
-            this.config = this.normalize(parsedConfig);
-        }
+        this.rawConfig = this.resolvedConfigFilePath ? await _load(this.resolvedConfigFilePath) : manifest.knip;
+        const parsedConfig = this.rawConfig ? ConfigurationValidator.parse(partitionCompilers(this.rawConfig)) : {};
+        this.config = this.normalize(parsedConfig);
         await this.setWorkspaces();
     }
     getCompilers() {
@@ -99,58 +97,25 @@ export class ConfigurationChief {
     getRules() {
         return this.config.rules;
     }
-    normalize(rawLocalConfig) {
-        const initialWorkspaces = rawLocalConfig.workspaces ?? {
-            [ROOT_WORKSPACE_NAME]: {
-                ...rawLocalConfig,
-            },
-        };
-        const rules = { ...defaultRules, ...rawLocalConfig.rules };
-        const include = rawLocalConfig.include ?? defaultConfig.include;
-        const exclude = rawLocalConfig.exclude ?? defaultConfig.exclude;
-        const ignore = arrayify(rawLocalConfig.ignore ?? defaultConfig.ignore);
-        const ignoreBinaries = rawLocalConfig.ignoreBinaries ?? [];
-        const ignoreExportsUsedInFile = rawLocalConfig.ignoreExportsUsedInFile ?? false;
-        const ignoreDependencies = rawLocalConfig.ignoreDependencies ?? [];
-        const ignoreWorkspaces = rawLocalConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
-        const { syncCompilers, asyncCompilers } = rawLocalConfig;
+    normalize(rawConfig) {
+        const rules = { ...defaultRules, ...rawConfig.rules };
+        const include = rawConfig.include ?? defaultConfig.include;
+        const exclude = rawConfig.exclude ?? defaultConfig.exclude;
+        const ignore = arrayify(rawConfig.ignore ?? defaultConfig.ignore);
+        const ignoreBinaries = rawConfig.ignoreBinaries ?? [];
+        const ignoreExportsUsedInFile = rawConfig.ignoreExportsUsedInFile ?? false;
+        const ignoreDependencies = rawConfig.ignoreDependencies ?? [];
+        const ignoreWorkspaces = rawConfig.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
+        const { syncCompilers, asyncCompilers } = rawConfig;
         const extensions = [...Object.keys(syncCompilers ?? {}), ...Object.keys(asyncCompilers ?? {})];
         const defaultWorkspaceConfig = getDefaultWorkspaceConfig(extensions);
         const rootPluginConfigs = {};
-        for (const [name, pluginConfig] of Object.entries(rawLocalConfig)) {
+        for (const [name, pluginConfig] of Object.entries(rawConfig)) {
             const pluginName = toCamelCase(name);
             if (PLUGIN_NAMES.includes(pluginName)) {
                 rootPluginConfigs[pluginName] = normalizePluginConfig(pluginConfig);
             }
         }
-        const workspaces = Object.entries(initialWorkspaces)
-            .filter(([workspaceName]) => !ignoreWorkspaces.includes(workspaceName))
-            .reduce((workspaces, workspace) => {
-            const [workspaceName, workspaceConfig] = workspace;
-            const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultWorkspaceConfig.entry;
-            const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultWorkspaceConfig.project;
-            const paths = workspaceConfig.paths ?? defaultWorkspaceConfig.paths;
-            workspaces[workspaceName] = {
-                entry,
-                project,
-                paths,
-                ignore: arrayify(workspaceConfig.ignore),
-                ignoreBinaries: arrayify(workspaceConfig.ignoreBinaries),
-                ignoreDependencies: arrayify(workspaceConfig.ignoreDependencies),
-            };
-            for (const [name, pluginConfig] of Object.entries(rootPluginConfigs)) {
-                const pluginName = toCamelCase(name);
-                if (pluginConfig)
-                    workspaces[workspaceName][pluginName] = pluginConfig;
-            }
-            for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
-                const pluginName = toCamelCase(name);
-                if (PLUGIN_NAMES.includes(pluginName)) {
-                    workspaces[workspaceName][pluginName] = normalizePluginConfig(pluginConfig);
-                }
-            }
-            return workspaces;
-        }, {});
         return {
             rules,
             include,
@@ -162,7 +127,8 @@ export class ConfigurationChief {
             ignoreWorkspaces,
             syncCompilers: new Map(Object.entries(syncCompilers ?? {})),
             asyncCompilers: new Map(Object.entries(asyncCompilers ?? {})),
-            workspaces,
+            rootPluginConfigs,
+            defaultWorkspaceConfig,
         };
     }
     async setWorkspaces() {
@@ -197,14 +163,21 @@ export class ConfigurationChief {
         });
         const manifestWorkspaces = new Map();
         for (const [pkgName, dir] of workspaces.entries()) {
-            manifestWorkspaces.set(relative(this.cwd, dir), pkgName);
+            manifestWorkspaces.set(relative(this.cwd, dir) || ROOT_WORKSPACE_NAME, pkgName);
         }
         return manifestWorkspaces;
     }
+    getConfiguredWorkspaceKeys() {
+        const initialWorkspaces = this.rawConfig?.workspaces
+            ? Object.keys(this.rawConfig.workspaces)
+            : [ROOT_WORKSPACE_NAME];
+        const ignoreWorkspaces = this.rawConfig?.ignoreWorkspaces ?? defaultConfig.ignoreWorkspaces;
+        return initialWorkspaces.filter(workspaceName => !ignoreWorkspaces.includes(workspaceName));
+    }
     async getAdditionalWorkspaceNames() {
-        const additionalWorkspaceKeys = Object.keys(this.config.workspaces);
-        const patterns = additionalWorkspaceKeys.filter(key => key.includes('*'));
-        const dirs = additionalWorkspaceKeys.filter(key => !key.includes('*'));
+        const workspaceKeys = this.getConfiguredWorkspaceKeys();
+        const patterns = workspaceKeys.filter(key => key.includes('*'));
+        const dirs = workspaceKeys.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) &&
@@ -260,16 +233,39 @@ export class ConfigurationChief {
             .map(workspaceName => `!${workspaceName}`);
     }
     getConfigKeyForWorkspace(workspaceName) {
-        return Object.keys(this.config.workspaces)
+        return this.getConfiguredWorkspaceKeys()
             .sort(byPathDepth)
             .reverse()
             .find(pattern => micromatch.isMatch(workspaceName, pattern));
     }
     getConfigForWorkspace(workspaceName) {
         const key = this.getConfigKeyForWorkspace(workspaceName);
-        if (key && this.config?.workspaces?.[key])
-            return this.config.workspaces[key];
-        return getDefaultWorkspaceConfig();
+        const defaultConfig = this.config.defaultWorkspaceConfig;
+        const workspaces = this.rawConfig?.workspaces ?? {};
+        const workspaceConfig = (key
+            ? key === ROOT_WORKSPACE_NAME && !(ROOT_WORKSPACE_NAME in workspaces)
+                ? this.rawConfig
+                : workspaces[key]
+            : {}) ?? {};
+        const entry = workspaceConfig.entry ? arrayify(workspaceConfig.entry) : defaultConfig.entry;
+        const project = workspaceConfig.project ? arrayify(workspaceConfig.project) : defaultConfig.project;
+        const paths = workspaceConfig.paths ?? defaultConfig.paths;
+        const ignore = arrayify(workspaceConfig.ignore);
+        const ignoreBinaries = arrayify(workspaceConfig.ignoreBinaries);
+        const ignoreDependencies = arrayify(workspaceConfig.ignoreDependencies);
+        const plugins = {};
+        for (const [name, pluginConfig] of Object.entries(this.config.rootPluginConfigs)) {
+            const pluginName = toCamelCase(name);
+            if (typeof pluginConfig !== 'undefined')
+                plugins[pluginName] = pluginConfig;
+        }
+        for (const [name, pluginConfig] of Object.entries(workspaceConfig)) {
+            const pluginName = toCamelCase(name);
+            if (PLUGIN_NAMES.includes(pluginName)) {
+                plugins[pluginName] = normalizePluginConfig(pluginConfig);
+            }
+        }
+        return { entry, project, paths, ignore, ignoreBinaries, ignoreDependencies, ...plugins };
     }
     getIssueTypesToReport() {
         const cliArgs = { include, exclude, dependencies, exports };