knip 5.33.3 → 5.34.1

package/dist/ConfigurationValidator.js

@@ -68,6 +68,7 @@ const pluginsSchema = z.object({
     angular: pluginSchema,
     ava: pluginSchema,
     babel: pluginSchema,
+    c8: pluginSchema,
     capacitor: pluginSchema,
     changesets: pluginSchema,
     commitizen: pluginSchema,
@@ -75,6 +76,7 @@ const pluginsSchema = z.object({
     cspell: pluginSchema,
     cucumber: pluginSchema,
     cypress: pluginSchema,
+    dotenv: pluginSchema,
     eleventy: pluginSchema,
     eslint: pluginSchema,
     gatsby: pluginSchema,
@@ -95,6 +97,8 @@ const pluginsSchema = z.object({
     nest: pluginSchema,
     netlify: pluginSchema,
     next: pluginSchema,
+    node: pluginSchema,
+    nodemon: pluginSchema,
     'node-test-runner': pluginSchema,
     'npm-package-json-lint': pluginSchema,
     nuxt: pluginSchema,
@@ -103,6 +107,7 @@ const pluginsSchema = z.object({
     oclif: pluginSchema,
     playwright: pluginSchema,
     'playwright-ct': pluginSchema,
+    'playwright-test': pluginSchema,
     postcss: pluginSchema,
     preconstruct: pluginSchema,
     prettier: pluginSchema,
@@ -124,7 +129,9 @@ const pluginsSchema = z.object({
     syncpack: pluginSchema,
     tailwind: pluginSchema,
     travis: pluginSchema,
+    'ts-node': pluginSchema,
     tsup: pluginSchema,
+    tsx: pluginSchema,
     typedoc: pluginSchema,
     typescript: pluginSchema,
     unbuild: pluginSchema,

package/dist/DependencyDeputy.js

@@ -127,8 +127,10 @@ export class DependencyDeputy {
         const typesPackageName = !isDefinitelyTyped(packageName) && getDefinitelyTypedFor(packageName);
         const closestWorkspaceNameForTypes = typesPackageName && workspaceNames.find(name => this.isInDependencies(name, typesPackageName));
         if (closestWorkspaceName || closestWorkspaceNameForTypes) {
-            closestWorkspaceName && this.addReferencedDependency(closestWorkspaceName, packageName);
-            closestWorkspaceNameForTypes && this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
+            if (closestWorkspaceName)
+                this.addReferencedDependency(closestWorkspaceName, packageName);
+            if (closestWorkspaceNameForTypes)
+                this.addReferencedDependency(closestWorkspaceNameForTypes, typesPackageName);
             return true;
         }
         this.addReferencedDependency(workspace.name, packageName);
@@ -287,6 +289,7 @@ export class DependencyDeputy {
         this.handleIgnoredDependencies(issues, counters, 'devDependencies');
         this.handleIgnoredDependencies(issues, counters, 'optionalPeerDependencies');
         this.handleIgnoredDependencies(issues, counters, 'unlisted');
+        this.handleIgnoredDependencies(issues, counters, 'unresolved');
         this.handleIgnoredBinaries(issues, counters, 'binaries');
     }
     getConfigurationHints() {

package/dist/PrincipalFactory.d.ts

@@ -1,32 +1,15 @@
-import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
-import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
-import type { ToSourceFilePath } from './util/to-source-path.js';
-type Paths = ts.CompilerOptions['paths'];
+import type { PrincipalOptions } from './types/project.js';
 type Principal = {
     principal: ProjectPrincipal;
-    cwds: Set<string>;
+    wsDirs: Set<string>;
     pathKeys: Set<string>;
     pkgNames: Set<string>;
 };
 type Principals = Set<Principal>;
-export type PrincipalOptions = {
-    cwd: string;
-    isFile: boolean;
-    compilerOptions: ts.CompilerOptions;
-    paths: Paths;
-    compilers: [SyncCompilers, AsyncCompilers];
-    pkgName: string;
-    isIsolateWorkspaces: boolean;
-    isSkipLibs: boolean;
-    isWatch: boolean;
-    toSourceFilePath: ToSourceFilePath;
-    isCache: boolean;
-    cacheLocation: string;
-};
 export declare class PrincipalFactory {
     principals: Principals;
-    getPrincipal(options: PrincipalOptions): ProjectPrincipal;
+    createPrincipal(options: PrincipalOptions): ProjectPrincipal;
     private findReusablePrincipal;
     private linkPrincipal;
     private addNewPrincipal;

package/dist/PrincipalFactory.js

@@ -17,7 +17,7 @@ const mergePaths = (cwd, compilerOptions, paths = {}) => {
 };
 export class PrincipalFactory {
     principals = new Set();
-    getPrincipal(options) {
+    createPrincipal(options) {
         const { cwd, compilerOptions, isFile, paths, pkgName, isIsolateWorkspaces, compilers } = options;
         options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
         if (isFile && compilerOptions.module !== ts.ModuleKind.CommonJS)
@@ -50,14 +50,14 @@ export class PrincipalFactory {
             principal.pathKeys.add(p);
         principal.principal.addPaths(paths);
         principal.principal.addCompilers(compilers);
-        principal.cwds.add(cwd);
+        principal.wsDirs.add(cwd);
         principal.pkgNames.add(pkgName);
     }
     addNewPrincipal(options) {
         const { cwd, compilerOptions, pkgName } = options;
         const pathKeys = new Set(Object.keys(compilerOptions?.paths ?? {}));
         const principal = new ProjectPrincipal(options);
-        this.principals.add({ principal, cwds: new Set([cwd]), pathKeys, pkgNames: new Set([pkgName]) });
+        this.principals.add({ principal, wsDirs: new Set([cwd]), pathKeys, pkgNames: new Set([pkgName]) });
         return principal;
     }
     getPrincipals() {
@@ -69,7 +69,7 @@ export class PrincipalFactory {
     deletePrincipal(principal) {
         const p = Array.from(this.principals).find(p => p.principal === principal);
         if (p) {
-            debugLog('*', `Deleting principal at ${[...p.cwds].map(cwd => toRelative(cwd) || '.')} (${[...p.pkgNames]})`);
+            debugLog('*', `Deleting principal at ${[...p.wsDirs].map(cwd => toRelative(cwd) || '.')} (${[...p.pkgNames]})`);
             this.principals.delete(p);
         }
     }

package/dist/ProjectPrincipal.d.ts

@@ -1,18 +1,16 @@
 import ts from 'typescript';
 import { CacheConsultant } from './CacheConsultant.js';
-import type { PrincipalOptions } from './PrincipalFactory.js';
-import type { ReferencedDependencies } from './WorkspaceWorker.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
+import type { GetImportsAndExportsOptions } from './types/config.js';
 import type { DependencyGraph, Export, ExportMember, FileNode } from './types/dependency-graph.js';
+import type { PrincipalOptions } from './types/project.js';
 import type { SourceFileManager } from './typescript/SourceFileManager.js';
-import { type GetImportsAndExportsOptions } from './typescript/get-imports-and-exports.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
 import type { ToSourceFilePath } from './util/to-source-path.js';
 export declare class ProjectPrincipal {
     entryPaths: Set<string>;
     projectPaths: Set<string>;
     nonEntryPaths: Set<string>;
-    referencedDependencies: Set<[string, string, string]>;
     skipExportsAnalysis: Set<string>;
     cwd: string;
     compilerOptions: ts.CompilerOptions;
@@ -48,7 +46,6 @@ export declare class ProjectPrincipal {
     addProjectPath(filePath: string): void;
     deletedFiles: Set<unknown>;
     removeProjectPath(filePath: string): void;
-    addReferencedDependencies(workspaceName: string, referencedDependencies: ReferencedDependencies): void;
     runAsyncCompilers(): Promise<void>;
     getUsedResolvedFiles(): string[];
     private getProgramSourceFiles;

package/dist/ProjectPrincipal.js

@@ -30,7 +30,6 @@ export class ProjectPrincipal {
     entryPaths = new Set();
     projectPaths = new Set();
     nonEntryPaths = new Set();
-    referencedDependencies = new Set();
     skipExportsAnalysis = new Set();
     cwd;
     compilerOptions;
@@ -123,10 +122,6 @@ export class ProjectPrincipal {
         this.invalidateFile(filePath);
         this.deletedFiles.add(filePath);
     }
-    addReferencedDependencies(workspaceName, referencedDependencies) {
-        for (const referencedDependency of referencedDependencies)
-            this.referencedDependencies.add([...referencedDependency, workspaceName]);
-    }
     async runAsyncCompilers() {
         const add = timerify(this.backend.fileManager.compileAndAddSourceFile.bind(this.backend.fileManager));
         const extensions = Array.from(this.asyncCompilers.keys());

package/dist/WorkspaceWorker.d.ts

@@ -1,7 +1,9 @@
 import { CacheConsultant } from './CacheConsultant.js';
-import type { Configuration, PluginName, WorkspaceConfiguration } from './types/config.js';
+import type { PluginName } from './types/PluginNames.js';
+import type { Configuration, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJson } from './types/package-json.js';
 import type { DependencySet } from './types/workspace.js';
+import { type Input } from './util/input.js';
 type WorkspaceManagerOptions = {
     name: string;
     dir: string;
@@ -9,18 +11,20 @@ type WorkspaceManagerOptions = {
     config: WorkspaceConfiguration;
     manifest: PackageJson;
     dependencies: DependencySet;
+    getReferencedInternalFilePath: (input: Input) => string | undefined;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
+    ignoredWorkspacePatterns: string[];
     enabledPluginsInAncestors: string[];
     isProduction: boolean;
     isStrict: boolean;
     isCache: boolean;
     cacheLocation: string;
+    allConfigFilePaths: Set<string>;
 };
-export type ReferencedDependencies = Set<[string, string]>;
 type CacheItem = {
-    resolveEntryPaths?: string[];
-    resolveConfig?: string[];
+    resolveEntryPaths?: Input[];
+    resolveConfig?: Input[];
 };
 export declare class WorkspaceWorker {
     name: string;
@@ -28,17 +32,19 @@ export declare class WorkspaceWorker {
     cwd: string;
     config: WorkspaceConfiguration;
     manifest: PackageJson;
-    manifestScriptNames: Set<string>;
     dependencies: DependencySet;
+    getReferencedInternalFilePath: (input: Input) => string | undefined;
     isProduction: boolean;
     isStrict: boolean;
     rootIgnore: Configuration['ignore'];
     negatedWorkspacePatterns: string[];
-    enabledPluginsMap: Record<"astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cucumber" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "ladle" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "moonrepo" | "msw" | "nest" | "netlify" | "next" | "nuxt" | "nx" | "nyc" | "oclif" | "playwright" | "postcss" | "preconstruct" | "prettier" | "remark" | "remix" | "rollup" | "rsbuild" | "rspack" | "sentry" | "storybook" | "stryker" | "stylelint" | "svelte" | "syncpack" | "tailwind" | "travis" | "tsup" | "typedoc" | "typescript" | "unbuild" | "unocss" | "vue" | "vike" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "xo" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "lockfileLint" | "lostPixel" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "reactCosmos" | "releaseIt" | "semanticRelease" | "simpleGitHooks" | "sizeLimit" | "vercelOg" | "webdriverIo", boolean>;
+    ignoredWorkspacePatterns: string[];
+    enabledPluginsMap: Record<PluginName, boolean>;
     enabledPlugins: PluginName[];
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, isCache, cacheLocation, }: WorkspaceManagerOptions);
+    allConfigFilePaths: Set<string>;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, isCache, cacheLocation, allConfigFilePaths, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;
@@ -46,16 +52,12 @@ export declare class WorkspaceWorker {
     getProjectFilePatterns(projectFilePatterns: string[]): string[];
     getPluginProjectFilePatterns(): string[];
     getPluginConfigPatterns(): string[];
+    getPluginEntryFilePatterns(patterns: string[]): string[];
     getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
     getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
     getIgnorePatterns(): string[];
-    findDependenciesByPlugins(): Promise<{
-        entryFilePatterns: Set<string>;
-        productionEntryFilePatterns: Set<string>;
-        referencedDependencies: ReferencedDependencies;
-        enabledPlugins: ("astro" | "angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cucumber" | "cypress" | "eleventy" | "eslint" | "gatsby" | "husky" | "jest" | "ladle" | "lefthook" | "linthtml" | "markdownlint" | "mocha" | "moonrepo" | "msw" | "nest" | "netlify" | "next" | "nuxt" | "nx" | "nyc" | "oclif" | "playwright" | "postcss" | "preconstruct" | "prettier" | "remark" | "remix" | "rollup" | "rsbuild" | "rspack" | "sentry" | "storybook" | "stryker" | "stylelint" | "svelte" | "syncpack" | "tailwind" | "travis" | "tsup" | "typedoc" | "typescript" | "unbuild" | "unocss" | "vue" | "vike" | "vite" | "vitest" | "webpack" | "wireit" | "wrangler" | "xo" | "yorkie" | "drizzle" | "githubActions" | "graphqlCodegen" | "lintStaged" | "lockfileLint" | "lostPixel" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "reactCosmos" | "releaseIt" | "semanticRelease" | "simpleGitHooks" | "sizeLimit" | "vercelOg" | "webdriverIo")[];
-    }>;
+    findDependenciesByPlugins(): Promise<Input[]>;
     onDispose(): void;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -1,42 +1,49 @@
 import { CacheConsultant } from './CacheConsultant.js';
-import { plugins } from './plugins.js';
+import { _getInputsFromScripts } from './binaries/index.js';
+import { getFilteredScripts } from './manifest/helpers.js';
+import { PluginEntries, Plugins } from './plugins.js';
+import { compact } from './util/array.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _glob, hasNoProductionSuffix, hasProductionSuffix, negate, prependDirToPattern } from './util/glob.js';
-import { get, getKeysByValue } from './util/object.js';
-import { basename, dirname, join, toPosix } from './util/path.js';
+import { isConfigPattern, toDebugString, toEntry } from './util/input.js';
+import { getKeysByValue } from './util/object.js';
+import { basename, dirname, join } from './util/path.js';
 import { getFinalEntryPaths, loadConfigForPlugin } from './util/plugin.js';
-import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
 const nullConfig = { config: null, entry: null, project: null };
-const initEnabledPluginsMap = () => Object.keys(plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
+const initEnabledPluginsMap = () => Object.keys(Plugins).reduce((enabled, pluginName) => ({ ...enabled, [pluginName]: false }), {});
 export class WorkspaceWorker {
     name;
     dir;
     cwd;
     config;
     manifest;
-    manifestScriptNames;
     dependencies;
+    getReferencedInternalFilePath;
     isProduction;
     isStrict;
     rootIgnore;
     negatedWorkspacePatterns = [];
+    ignoredWorkspacePatterns = [];
     enabledPluginsMap = initEnabledPluginsMap();
     enabledPlugins = [];
     enabledPluginsInAncestors;
     cache;
-    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, isCache, cacheLocation, }) {
+    allConfigFilePaths;
+    constructor({ name, dir, cwd, config, manifest, dependencies, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, getReferencedInternalFilePath, isCache, cacheLocation, allConfigFilePaths, }) {
         this.name = name;
         this.dir = dir;
         this.cwd = cwd;
         this.config = config;
         this.manifest = manifest;
-        this.manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
         this.dependencies = dependencies;
         this.isProduction = isProduction;
         this.isStrict = isStrict;
         this.rootIgnore = rootIgnore;
         this.negatedWorkspacePatterns = negatedWorkspacePatterns;
+        this.ignoredWorkspacePatterns = ignoredWorkspacePatterns;
         this.enabledPluginsInAncestors = enabledPluginsInAncestors;
+        this.allConfigFilePaths = allConfigFilePaths;
+        this.getReferencedInternalFilePath = getReferencedInternalFilePath;
         this.cache = new CacheConsultant({ name: `plugins-${name}`, isEnabled: isCache, cacheLocation });
     }
     async init() {
@@ -44,8 +51,7 @@ export class WorkspaceWorker {
     }
     async determineEnabledPlugins() {
         const manifest = this.manifest;
-        const pluginEntries = Object.entries(plugins);
-        for (const [pluginName, plugin] of pluginEntries) {
+        for (const [pluginName, plugin] of PluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
             if (this.config[pluginName]) {
@@ -54,12 +60,13 @@ export class WorkspaceWorker {
             }
             const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
             if (isEnabledInAncestor ||
-                (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies: this.dependencies, config: this.config }))) {
+                (typeof plugin.isEnabled === 'function' &&
+                    (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies: this.dependencies, config: this.config })))) {
                 this.enabledPluginsMap[pluginName] = true;
             }
         }
         const enabledPlugins = getKeysByValue(this.enabledPluginsMap, true);
-        const enabledPluginTitles = enabledPlugins.map(name => plugins[name].title);
+        const enabledPluginTitles = enabledPlugins.map(name => Plugins[name].title);
         debugLogObject(this.name, 'Enabled plugins', enabledPluginTitles);
         return enabledPlugins;
     }
@@ -91,7 +98,7 @@ export class WorkspaceWorker {
     }
     getPluginProjectFilePatterns() {
         const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
+        for (const [pluginName, plugin] of PluginEntries) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabledPluginsMap[pluginName]) {
                 const { entry, project } = pluginConfig;
@@ -102,7 +109,7 @@ export class WorkspaceWorker {
     }
     getPluginConfigPatterns() {
         const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
+        for (const [pluginName, plugin] of PluginEntries) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabledPluginsMap[pluginName] && pluginConfig) {
                 const { config } = pluginConfig;
@@ -111,6 +118,9 @@ export class WorkspaceWorker {
         }
         return patterns;
     }
+    getPluginEntryFilePatterns(patterns) {
+        return [patterns, this.ignoredWorkspacePatterns.map(negate)].flat();
+    }
     getProductionEntryFilePatterns(negatedTestFilePatterns) {
         const entry = this.config.entry.filter(hasProductionSuffix);
         if (entry.length === 0)
@@ -140,115 +150,144 @@ export class WorkspaceWorker {
         ].flat();
     }
     getConfigurationFilePatterns(pluginName) {
-        const plugin = plugins[pluginName];
+        const plugin = Plugins[pluginName];
         const pluginConfig = this.getConfigForPlugin(pluginName);
-        if (pluginConfig) {
-            return pluginConfig.config ?? plugin.config ?? [];
-        }
-        return [];
+        return pluginConfig.config ?? plugin.config ?? [];
     }
     getIgnorePatterns() {
         return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async findDependenciesByPlugins() {
-        const entryFilePatterns = new Set();
-        const productionEntryFilePatterns = new Set();
-        const referencedDependencies = new Set();
         const name = this.name;
         const cwd = this.dir;
-        const baseOptions = {
-            rootCwd: this.cwd,
-            cwd,
-            manifest: this.manifest,
-            manifestScriptNames: this.manifestScriptNames,
-            dependencies: this.dependencies,
-            isProduction: this.isProduction,
-            enabledPlugins: this.enabledPlugins,
+        const rootCwd = this.cwd;
+        const manifest = this.manifest;
+        const containingFilePath = join(cwd, 'package.json');
+        const isProduction = this.isProduction;
+        const knownBinsOnly = false;
+        const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
+        const baseOptions = { manifestScriptNames, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const baseScriptOptions = { ...baseOptions, manifest, isProduction, enabledPlugins: this.enabledPlugins };
+        const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
+        const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);
+        const productionInputsFromManifest = _getInputsFromScripts(Object.values(productionScripts), baseOptions);
+        const hasProductionInput = (input) => productionInputsFromManifest.find(d => d.specifier === input.specifier && d.type === input.type);
+        const getInputsFromScripts = (scripts, options) => _getInputsFromScripts(scripts, { ...baseScriptOptions, ...options });
+        const inputs = [];
+        const configFiles = new Map();
+        const remainingPlugins = new Set(this.enabledPlugins);
+        const addInput = (input, containingFilePath = input.containingFilePath) => inputs.push({ ...input, containingFilePath });
+        const handleConfigInput = (pluginName, dependency) => {
+            const configFilePath = this.getReferencedInternalFilePath(dependency);
+            if (configFilePath) {
+                if (!configFiles.has(pluginName))
+                    configFiles.set(pluginName, new Set());
+                configFiles.get(pluginName)?.add(configFilePath);
+                addInput(toEntry(dependency.specifier), dependency.containingFilePath);
+            }
         };
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
-            if (this.enabledPluginsMap[pluginName]) {
-                const hasResolveEntryPaths = typeof plugin.resolveEntryPaths === 'function';
-                const hasResolveConfig = typeof plugin.resolveConfig === 'function';
-                const shouldRunConfigResolver = hasResolveConfig && (!this.isProduction || (this.isProduction && 'production' in plugin));
-                const hasResolve = typeof plugin.resolve === 'function';
-                const pluginConfig = this.getConfigForPlugin(pluginName);
-                if (!pluginConfig)
-                    continue;
-                const patterns = this.getConfigurationFilePatterns(pluginName);
-                const allConfigFilePaths = await _glob({ patterns, cwd: baseOptions.rootCwd, dir: cwd, gitignore: false });
-                const { packageJsonPath } = plugin;
-                const configFilePaths = allConfigFilePaths.filter(filePath => basename(filePath) !== 'package.json' ||
-                    (typeof packageJsonPath === 'function'
-                        ? packageJsonPath(this.manifest)
-                        : get(this.manifest, packageJsonPath ?? pluginName)));
+        for (const input of [...inputsFromManifest, ...productionInputsFromManifest]) {
+            if (isConfigPattern(input)) {
+                handleConfigInput(input.pluginName, { ...input, containingFilePath });
+            }
+            else {
+                if (!isProduction)
+                    addInput(input, containingFilePath);
+                else if (isProduction && (input.production || hasProductionInput(input)))
+                    addInput(input, containingFilePath);
+            }
+        }
+        const runPlugin = async (pluginName, patterns) => {
+            const plugin = Plugins[pluginName];
+            const hasResolveEntryPaths = typeof plugin.resolveEntryPaths === 'function';
+            const hasResolveConfig = typeof plugin.resolveConfig === 'function';
+            const shouldRunConfigResolver = hasResolveConfig && (!isProduction || (isProduction && 'production' in plugin));
+            const hasResolve = typeof plugin.resolve === 'function';
+            const config = this.getConfigForPlugin(pluginName);
+            if (!config)
+                return;
+            const configFilePaths = await _glob({ patterns, cwd: baseScriptOptions.rootCwd, dir: cwd, gitignore: false });
+            const remainingConfigFilePaths = configFilePaths.filter(filePath => !this.allConfigFilePaths.has(filePath));
+            for (const f of remainingConfigFilePaths)
+                if (basename(f) !== 'package.json')
+                    this.allConfigFilePaths.add(f);
+            if (configFilePaths.length > 0)
                 debugLogArray([name, plugin.title], 'config file paths', configFilePaths);
-                const pluginDependencies = new Set();
-                const addDependency = (specifier, configFilePath) => {
-                    pluginDependencies.add(specifier);
-                    if (isEntryPattern(specifier)) {
-                        entryFilePatterns.add(fromEntryPattern(specifier));
-                    }
-                    else if (isProductionEntryPattern(specifier)) {
-                        productionEntryFilePatterns.add(fromProductionEntryPattern(specifier));
-                    }
-                    else if (configFilePath) {
-                        referencedDependencies.add([configFilePath, toPosix(specifier)]);
-                    }
+            const options = {
+                ...baseScriptOptions,
+                config,
+                configFilePath: containingFilePath,
+                configFileDir: cwd,
+                configFileName: '',
+                getInputsFromScripts,
+            };
+            const configEntryPaths = [];
+            for (const configFilePath of remainingConfigFilePaths) {
+                const opts = {
+                    ...options,
+                    configFilePath,
+                    configFileDir: dirname(configFilePath),
+                    configFileName: basename(configFilePath),
                 };
-                const options = { ...baseOptions, config: pluginConfig, configFileDir: cwd, configFileName: '' };
-                const configEntryPaths = [];
-                for (const configFilePath of configFilePaths) {
-                    const opts = { ...options, configFileDir: dirname(configFilePath), configFileName: basename(configFilePath) };
-                    if (hasResolveEntryPaths || shouldRunConfigResolver) {
-                        const isManifest = basename(configFilePath) === 'package.json';
-                        const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
-                        if (fd?.meta?.data && !fd.changed) {
-                            if (fd.meta.data.resolveEntryPaths)
-                                for (const id of fd.meta.data.resolveEntryPaths)
-                                    configEntryPaths.push(id);
-                            if (fd.meta.data.resolveConfig)
-                                for (const id of fd.meta.data.resolveConfig)
-                                    addDependency(id, configFilePath);
-                        }
-                        else {
-                            const config = await loadConfigForPlugin(configFilePath, plugin, opts, pluginName);
-                            const data = {};
-                            if (config) {
-                                if (hasResolveEntryPaths) {
-                                    const dependencies = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
-                                    for (const id of dependencies)
-                                        configEntryPaths.push(id);
-                                    data.resolveEntryPaths = dependencies;
-                                }
-                                if (shouldRunConfigResolver) {
-                                    const dependencies = (await plugin.resolveConfig?.(config, opts)) ?? [];
-                                    for (const id of dependencies)
-                                        addDependency(id, configFilePath);
-                                    data.resolveConfig = dependencies;
+                if (hasResolveEntryPaths || shouldRunConfigResolver) {
+                    const isManifest = basename(configFilePath) === 'package.json';
+                    const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
+                    if (fd?.meta?.data && !fd.changed) {
+                        if (fd.meta.data.resolveEntryPaths)
+                            for (const id of fd.meta.data.resolveEntryPaths)
+                                configEntryPaths.push(id);
+                        if (fd.meta.data.resolveConfig)
+                            for (const id of fd.meta.data.resolveConfig)
+                                addInput(id, configFilePath);
+                    }
+                    else {
+                        const config = await loadConfigForPlugin(configFilePath, plugin, opts, pluginName);
+                        const data = {};
+                        if (config) {
+                            if (hasResolveEntryPaths) {
+                                const entryPaths = (await plugin.resolveEntryPaths?.(config, opts)) ?? [];
+                                for (const entryPath of entryPaths)
+                                    configEntryPaths.push(entryPath);
+                                data.resolveEntryPaths = entryPaths;
+                            }
+                            if (shouldRunConfigResolver) {
+                                const inputs = (await plugin.resolveConfig?.(config, opts)) ?? [];
+                                for (const input of inputs) {
+                                    if (isConfigPattern(input))
+                                        handleConfigInput(input.pluginName, { ...input, containingFilePath: configFilePath });
+                                    addInput(input, configFilePath);
                                 }
-                                if (!isManifest && fd?.changed && fd.meta)
-                                    fd.meta.data = data;
+                                data.resolveConfig = inputs;
                             }
+                            if (!isManifest && fd?.changed && fd.meta)
+                                fd.meta.data = data;
                         }
                     }
                 }
-                const finalEntryPaths = getFinalEntryPaths(plugin, options, configEntryPaths);
-                for (const id of finalEntryPaths)
-                    addDependency(id);
-                if (hasResolve) {
-                    const dependencies = (await plugin.resolve?.(options)) ?? [];
-                    for (const id of dependencies)
-                        addDependency(id, join(cwd, 'package.json'));
-                }
-                debugLogArray([name, plugin.title], 'dependencies', pluginDependencies);
             }
-        }
-        return {
-            entryFilePatterns,
-            productionEntryFilePatterns,
-            referencedDependencies,
-            enabledPlugins: this.enabledPlugins,
+            const finalEntryPaths = getFinalEntryPaths(plugin, options, configEntryPaths);
+            for (const id of finalEntryPaths)
+                addInput(id, id.containingFilePath ?? containingFilePath);
+            if (hasResolve) {
+                const dependencies = (await plugin.resolve?.(options)) ?? [];
+                for (const id of dependencies)
+                    addInput(id, containingFilePath);
+            }
         };
+        for (const pluginName of this.enabledPlugins) {
+            const patterns = [...this.getConfigurationFilePatterns(pluginName), ...(configFiles.get(pluginName) ?? [])];
+            configFiles.delete(pluginName);
+            await runPlugin(pluginName, compact(patterns));
+            remainingPlugins.delete(pluginName);
+        }
+        do {
+            for (const [pluginName, dependencies] of configFiles.entries()) {
+                configFiles.delete(pluginName);
+                await runPlugin(pluginName, Array.from(dependencies));
+            }
+        } while (remainingPlugins.size > 0 && configFiles.size > 0);
+        debugLogArray(name, 'Plugin dependencies', () => compact(inputs.map(toDebugString)));
+        return inputs;
     }
     onDispose() {
         this.cache.reconcile();

package/dist/binaries/bash-parser.d.ts

@@ -1,2 +1,3 @@
-import type { GetDependenciesFromScriptsOptions } from './types.js';
-export declare const getBinariesFromScript: (script: string, options: GetDependenciesFromScriptsOptions) => string[];
+import type { GetInputsFromScriptsOptions } from '../types/config.js';
+import { type Input } from '../util/input.js';
+export declare const getDependenciesFromScript: (script: string, options: GetInputsFromScriptsOptions) => Input[];