knip 6.19.0 → 6.20.0

package/dist/WorkspaceWorker.js

@@ -219,22 +219,37 @@ export class WorkspaceWorker {
         const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
         const createGetInputsFromScripts = (containingFilePath) => (scripts, options) => _getInputsFromScripts(scripts, { ...baseOptions, ...options, containingFilePath });
         const inputs = [];
-        const remainingPlugins = new Set(this.enabledPlugins);
+        const enabledPlugins = new Set(this.enabledPlugins);
         const configFilesMap = this.configFilesMap;
-        const configFiles = this.configFilesMap.get(wsName);
         const seen = new Map();
         const parsedConfigCache = new Map();
+        const getSeenConfigFiles = (pluginName) => {
+            let configFilePaths = seen.get(pluginName);
+            if (!configFilePaths) {
+                configFilePaths = new Set();
+                seen.set(pluginName, configFilePaths);
+            }
+            return configFilePaths;
+        };
         const storeConfigFilePath = (pluginName, input) => {
             const configFilePath = this.handleInput(input);
             if (configFilePath) {
                 const workspace = this.findWorkspaceByFilePath(configFilePath);
                 if (workspace) {
                     const name = this.name === ROOT_WORKSPACE_NAME ? workspace.name : this.name;
-                    if (!configFilesMap.has(name))
-                        configFilesMap.set(name, new Map());
-                    if (!configFilesMap.get(name)?.has(pluginName))
-                        configFilesMap.get(name)?.set(pluginName, new Set());
-                    configFilesMap.get(name)?.get(pluginName)?.add(configFilePath);
+                    if (name === wsName && seen.get(pluginName)?.has(configFilePath))
+                        return;
+                    let configFiles = configFilesMap.get(name);
+                    if (!configFiles) {
+                        configFiles = new Map();
+                        configFilesMap.set(name, configFiles);
+                    }
+                    let configFilePaths = configFiles.get(pluginName);
+                    if (!configFilePaths) {
+                        configFilePaths = new Set();
+                        configFiles.set(pluginName, configFilePaths);
+                    }
+                    configFilePaths.add(configFilePath);
                 }
             }
         };
@@ -246,12 +261,13 @@ export class WorkspaceWorker {
                 inputs.push({ ...input, containingFilePath });
             }
         }
-        const runPlugin = async (pluginName, patterns) => {
+        const runPlugin = async (pluginName, patterns, isResolvedConfigFiles = false) => {
             const plugin = Plugins[pluginName];
             const config = this.getConfigForPlugin(pluginName);
             if (!config)
                 return [];
             const inputs = [];
+            const seenConfigFiles = getSeenConfigFiles(pluginName);
             const addInput = (input, containingFilePath = input.containingFilePath) => {
                 if (isConfig(input)) {
                     storeConfigFilePath(input.pluginName, { ...input, containingFilePath });
@@ -262,6 +278,13 @@ export class WorkspaceWorker {
             };
             const label = 'config file';
             const configFilePaths = await _glob({ patterns, cwd: rootCwd, dir: cwd, gitignore: false, label });
+            if (isResolvedConfigFiles) {
+                const foundConfigFilePaths = new Set(configFilePaths);
+                for (const filePath of patterns) {
+                    if (!foundConfigFilePaths.has(filePath))
+                        seenConfigFiles.add(filePath);
+                }
+            }
             const options = {
                 ...baseScriptOptions,
                 config,
@@ -289,6 +312,9 @@ export class WorkspaceWorker {
             if (typeof plugin.setup === 'function')
                 await plugin.setup();
             for (const configFilePath of configFilePaths) {
+                if (seenConfigFiles.has(configFilePath))
+                    continue;
+                seenConfigFiles.add(configFilePath);
                 const isManifest = basename(configFilePath) === 'package.json';
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
                 if (fd?.meta?.data && !fd.changed) {
@@ -323,8 +349,7 @@ export class WorkspaceWorker {
                 };
                 const cache = {};
                 let hasLoadConfigError = false;
-                const key = `${wsName}:${pluginName}`;
-                if (plugin.resolveConfig && !seen.get(key)?.has(configFilePath)) {
+                if (plugin.resolveConfig) {
                     if (parsed && isExternalReExportsOnly(parsed)) {
                         cache.resolveConfig = [];
                     }
@@ -369,12 +394,9 @@ export class WorkspaceWorker {
                     if (hasLoadConfigError) {
                         this.cache.removeEntry(configFilePath);
                     }
-                    else if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
+                    else if (fd?.meta) {
                         fd.meta.data = cache;
                     }
-                    if (!seen.has(key))
-                        seen.set(key, new Set());
-                    seen.get(key)?.add(configFilePath);
                 }
             }
             if (plugin.resolve) {
@@ -390,27 +412,38 @@ export class WorkspaceWorker {
         const enabledPluginTitles = this.enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
         for (const pluginName of this.enabledPlugins) {
+            const configFiles = this.configFilesMap.get(wsName);
             const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles?.get(pluginName) ?? [])];
             configFiles?.delete(pluginName);
             for (const input of await runPlugin(pluginName, compact(patterns)))
                 inputs.push(input);
-            remainingPlugins.delete(pluginName);
         }
         {
             const configFiles = this.configFilesMap.get(wsName);
             if (configFiles) {
-                do {
-                    for (const [pluginName, dependencies] of configFiles) {
-                        configFiles.delete(pluginName);
-                        if (this.enabledPlugins.includes(pluginName)) {
-                            for (const input of await runPlugin(pluginName, Array.from(dependencies)))
+                while (configFiles.size > 0) {
+                    const entry = configFiles.entries().next().value;
+                    if (!entry)
+                        break;
+                    const [pluginName, dependencies] = entry;
+                    configFiles.delete(pluginName);
+                    if (enabledPlugins.has(pluginName)) {
+                        const seenConfigFiles = getSeenConfigFiles(pluginName);
+                        const unprocessed = [];
+                        for (const filePath of dependencies) {
+                            if (!seenConfigFiles.has(filePath))
+                                unprocessed.push(filePath);
+                        }
+                        if (unprocessed.length > 0) {
+                            for (const input of await runPlugin(pluginName, unprocessed, true))
                                 inputs.push(input);
                         }
-                        else
-                            for (const id of dependencies)
-                                inputs.push(toEntry(id));
                     }
-                } while (remainingPlugins.size > 0 && configFiles.size > 0);
+                    else {
+                        for (const id of dependencies)
+                            inputs.push(toEntry(id));
+                    }
+                }
             }
         }
         debugLogArray(wsName, 'Plugin dependencies', () => compact(inputs.map(input => toDebugString(input, rootCwd))));

package/dist/typescript/ast-nodes.js

@@ -5,7 +5,7 @@ import { timerify } from '../util/Performance.js';
 import { EMPTY_TAGS } from './visitors/jsdoc.js';
 const defaultParseOptions = {
     sourceType: 'unambiguous',
-    experimentalRawTransfer: rawTransferSupported(),
+    experimentalRawTransfer: process.env.KNIP_DISABLE_RAW_TRANSFER !== '1' && rawTransferSupported(),
 };
 const parseFile = (filePath, sourceText) => {
     const ext = extname(filePath);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.19.0";
+export declare const version = "6.20.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.19.0';
+export const version = '6.20.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.19.0",
+  "version": "6.20.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",