knip 2.30.0 → 2.31.0

package/README.md

@@ -80,7 +80,9 @@ For updates or questions, come hang out in [The Knip Barn (Discord)][10], or fol
 
 ### Installation
 
-    npm install -D knip
+```
+npm install -D knip
+```
 
 Knip supports LTS versions of Node.js, and currently requires at least Node.js v16.17 or v18.6.
 
@@ -445,7 +447,9 @@ In a more fine-grained manner, you can also ignore only specific issue types:
 
 When a repository is self-contained or private, you may want to include entry files when reporting unused exports:
 
-    knip --include-entry-exports
+```
+knip --include-entry-exports
+```
 
 Knip will also report unused exports in entry source files and scripts (such as those referenced in `package.json`). But
 not in entry and configuration files from plugins, such as `next.config.js` or `src/routes/+page.svelte`.
@@ -587,12 +591,16 @@ Alternatively, they can be added to the configuration (e.g. `"exclude": ["depend
 
 Use `--include` to report only specific issue types (the following example commands do the same):
 
-    knip --include files --include dependencies
-    knip --include files,dependencies
+```
+knip --include files --include dependencies
+knip --include files,dependencies
+```
 
 Use `--exclude` to ignore reports you're not interested in:
 
-    knip --include files --exclude classMembers,enumMembers
+```
+knip --include files --exclude classMembers,enumMembers
+```
 
 Use `--dependencies` or `--exports` as shortcuts to combine groups of related types.
 
@@ -660,7 +668,8 @@ Knip takes the following JSDoc/TSDoc tags into account:
 
 ## Command Line Options
 
-    $ npx knip --help
+```
+$ npx knip --help
     ✂️  Find unused files, dependencies and exports in your JavaScript and TypeScript projects
 
     Usage: knip [options]
@@ -704,6 +713,7 @@ Knip takes the following JSDoc/TSDoc tags into account:
     $ knip --debug --debug-file-filter '(specific|particular)-module'
 
     More documentation and bug reports: https://github.com/webpro/knip
+```
 
 ## Potential boost with `--no-gitignore`
 
@@ -739,15 +749,19 @@ Below some similar commands to get another idea of what Knip does in comparison:
 
 The following commands are similar:
 
-    depcheck
-    knip --dependencies
+```
+depcheck
+knip --dependencies
+```
 
 ### unimported
 
 The following commands are similar:
 
-    unimported
-    knip --production --dependencies --include files
+```
+unimported
+knip --production --dependencies --include files
+```
 
 Also see [production mode][25].
 
@@ -755,17 +769,21 @@ Also see [production mode][25].
 
 The following commands are similar:
 
-    ts-unused-exports
-    knip --include exports,types,nsExports,nsTypes
-    knip --exports  # Adds unused enum and class members
+```
+ts-unused-exports
+knip --include exports,types,nsExports,nsTypes
+knip --exports  # Adds unused enum and class members
+```
 
 ### ts-prune
 
 The following commands are similar:
 
-    ts-prune
-    knip --include exports,types
-    knip --exports  # Adds unused exports/types in namespaces and unused enum/class members
+```
+ts-prune
+knip --include exports,types
+knip --exports  # Adds unused exports/types in namespaces and unused enum/class members
+```
 
 ## Projects using Knip
 

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 };