knip 2.30.1 → 2.32.0

package/dist/ConfigurationValidator.js

@@ -51,7 +51,7 @@ const reportConfigSchema = z.object({
     exclude: z.array(z.string()).optional(),
 });
 export const pluginSchema = z.union([
-    z.literal(false),
+    z.boolean(),
     globSchema,
     z.object({
         config: globSchema.optional(),
@@ -79,6 +79,7 @@ const pluginsSchema = z.object({
     markdownlint: pluginSchema,
     mocha: pluginSchema,
     next: pluginSchema,
+    'node-test-runner': pluginSchema,
     'npm-package-json-lint': pluginSchema,
     nx: pluginSchema,
     nyc: pluginSchema,

package/dist/WorkspaceWorker.d.ts

@@ -31,19 +31,19 @@ export declare class WorkspaceWorker {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
+    entryFilePatterns: Set<string>;
+    productionEntryFilePatterns: Set<string>;
     constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private setEnabledPlugins;
     private initReferencedDependencies;
     private getConfigForPlugin;
     getEntryFilePatterns(): string[];
-    getProjectFilePatterns(): string[];
-    getPluginEntryFilePatterns(isIncludeProductionEntryFiles?: boolean): string[];
+    getProjectFilePatterns(testFilePatterns: string[]): string[];
     getPluginProjectFilePatterns(): string[];
     getPluginConfigPatterns(): string[];
-    getProductionEntryFilePatterns(): string[];
-    getProductionProjectFilePatterns(): string[];
-    getProductionPluginEntryFilePatterns(): string[];
+    getProductionEntryFilePatterns(negatedTestFilePatterns: string[]): string[];
+    getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
     getIgnorePatterns(): string[];
     private findDependenciesByPlugins;
@@ -52,7 +52,9 @@ export declare class WorkspaceWorker {
         installedBinaries: InstalledBinaries;
         referencedDependencies: ReferencedDependencies;
         hasTypesIncluded: Set<string>;
-        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "drizzle" | "githubActions" | "lintStaged" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "svelte")[];
+        enabledPlugins: ("angular" | "ava" | "babel" | "capacitor" | "changesets" | "commitizen" | "commitlint" | "cspell" | "cypress" | "eslint" | "gatsby" | "husky" | "jest" | "lefthook" | "markdownlint" | "mocha" | "next" | "nx" | "nyc" | "playwright" | "postcss" | "prettier" | "remark" | "remix" | "rollup" | "sentry" | "storybook" | "stryker" | "stylelint" | "tailwind" | "typedoc" | "typescript" | "vite" | "vitest" | "webpack" | "drizzle" | "githubActions" | "lintStaged" | "nodeTestRunner" | "npmPackageJsonLint" | "playwrightCt" | "releaseIt" | "semanticRelease" | "svelte")[];
+        entryFilePatterns: string[];
+        productionEntryFilePatterns: string[];
     }>;
 }
 export {};

package/dist/WorkspaceWorker.js

@@ -1,11 +1,11 @@
-import { TEST_FILE_PATTERNS } from './constants.js';
 import * as npm from './manifest/index.js';
 import * as plugins from './plugins/index.js';
 import { debugLogArray, debugLogObject } from './util/debug.js';
 import { _pureGlob, negate, hasProductionSuffix, hasNoProductionSuffix, prependDirToPattern } from './util/glob.js';
-import { getKeysByValue } from './util/object.js';
+import { get, getKeysByValue } from './util/object.js';
 import { join, toPosix } from './util/path.js';
-const negatedTestFilePatterns = TEST_FILE_PATTERNS.map(negate);
+import { fromEntryPattern, fromProductionEntryPattern, isEntryPattern, isProductionEntryPattern, } from './util/protocols.js';
+const nullConfig = { config: null, entry: null, project: null };
 export class WorkspaceWorker {
     name;
     dir;
@@ -23,6 +23,8 @@ export class WorkspaceWorker {
     hostDependencies = new Map();
     installedBinaries = new Map();
     hasTypesIncluded = new Set();
+    entryFilePatterns = new Set();
+    productionEntryFilePatterns = new Set();
     constructor({ name, dir, cwd, config, manifest, isProduction, isStrict, rootIgnore, negatedWorkspacePatterns, enabledPluginsInAncestors, }) {
         this.name = name;
         this.dir = dir;
@@ -49,6 +51,10 @@ export class WorkspaceWorker {
         for (const [pluginName, plugin] of pluginEntries) {
             if (this.config[pluginName] === false)
                 continue;
+            if (this.config[pluginName]) {
+                this.enabled[pluginName] = true;
+                continue;
+            }
             const isEnabledInAncestor = this.enabledPluginsInAncestors.includes(pluginName);
             if (isEnabledInAncestor ||
                 (await plugin.isEnabled({ cwd: this.dir, manifest, dependencies, config: this.config }))) {
@@ -72,61 +78,38 @@ export class WorkspaceWorker {
         this.hostDependencies = hostDependencies;
         this.installedBinaries = installedBinaries;
         this.hasTypesIncluded = hasTypesIncluded;
+        this.hasTypesIncluded = hasTypesIncluded;
     }
     getConfigForPlugin(pluginName) {
-        return this.config[pluginName] ?? { config: null, entry: null, project: null };
+        return this.config[pluginName] !== true ? this.config[pluginName] ?? nullConfig : nullConfig;
     }
     getEntryFilePatterns() {
         const { entry } = this.config;
         if (entry.length === 0)
             return [];
-        return [entry, TEST_FILE_PATTERNS, this.negatedWorkspacePatterns].flat();
+        return [entry, this.negatedWorkspacePatterns].flat();
     }
-    getProjectFilePatterns() {
+    getProjectFilePatterns(testFilePatterns) {
         const { project } = this.config;
         if (project.length === 0)
             return [];
         const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
         const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
         return [
             project,
             negatedPluginConfigPatterns,
-            negatedPluginEntryFilePatterns,
             negatedPluginProjectFilePatterns,
-            TEST_FILE_PATTERNS,
+            testFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
-    getPluginEntryFilePatterns(isIncludeProductionEntryFiles = true) {
-        const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
-                const { entry } = pluginConfig;
-                const defaultEntryFiles = 'ENTRY_FILE_PATTERNS' in plugin ? plugin.ENTRY_FILE_PATTERNS : [];
-                patterns.push(...(entry ?? defaultEntryFiles));
-                if (isIncludeProductionEntryFiles) {
-                    const entry = 'PRODUCTION_ENTRY_FILE_PATTERNS' in plugin ? plugin.PRODUCTION_ENTRY_FILE_PATTERNS : [];
-                    patterns.push(...entry);
-                }
-            }
-        }
-        return [patterns, this.negatedWorkspacePatterns].flat();
-    }
     getPluginProjectFilePatterns() {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabled[pluginName] && pluginConfig) {
-                const { entry, project } = pluginConfig;
-                patterns.push(...(project ??
-                    entry ??
-                    ('PROJECT_FILE_PATTERNS' in plugin
-                        ? plugin.PROJECT_FILE_PATTERNS
-                        : 'ENTRY_FILE_PATTERNS' in plugin
-                            ? plugin.ENTRY_FILE_PATTERNS
-                            : [])));
+                const { entry, project } = pluginConfig === true ? nullConfig : pluginConfig;
+                patterns.push(...(project ?? entry ?? ('PROJECT_FILE_PATTERNS' in plugin ? plugin.PROJECT_FILE_PATTERNS : [])));
             }
         }
         return [patterns, this.negatedWorkspacePatterns].flat();
@@ -136,24 +119,24 @@ export class WorkspaceWorker {
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabled[pluginName] && pluginConfig) {
-                const { config } = pluginConfig;
+                const { config } = pluginConfig === true ? nullConfig : pluginConfig;
                 const defaultConfigFiles = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
                 patterns.push(...(config ?? defaultConfigFiles));
             }
         }
         return patterns;
     }
-    getProductionEntryFilePatterns() {
+    getProductionEntryFilePatterns(negatedTestFilePatterns) {
         const entry = this.config.entry.filter(hasProductionSuffix);
         if (entry.length === 0)
             return [];
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
         return [entry, negatedEntryFiles, negatedTestFilePatterns, this.negatedWorkspacePatterns].flat();
     }
-    getProductionProjectFilePatterns() {
+    getProductionProjectFilePatterns(negatedTestFilePatterns) {
         const project = this.config.project;
         if (project.length === 0)
-            return this.getProductionEntryFilePatterns();
+            return this.getProductionEntryFilePatterns(negatedTestFilePatterns);
         const _project = this.config.project.map(pattern => {
             if (!pattern.endsWith('!') && !pattern.startsWith('!'))
                 return negate(pattern);
@@ -161,38 +144,22 @@ export class WorkspaceWorker {
         });
         const negatedEntryFiles = this.config.entry.filter(hasNoProductionSuffix).map(negate);
         const negatedPluginConfigPatterns = this.getPluginConfigPatterns().map(negate);
-        const negatedPluginEntryFilePatterns = this.getPluginEntryFilePatterns(false).map(negate);
         const negatedPluginProjectFilePatterns = this.getPluginProjectFilePatterns().map(negate);
         return [
             _project,
             negatedEntryFiles,
             negatedPluginConfigPatterns,
-            negatedPluginEntryFilePatterns,
             negatedPluginProjectFilePatterns,
             negatedTestFilePatterns,
             this.negatedWorkspacePatterns,
         ].flat();
     }
-    getProductionPluginEntryFilePatterns() {
-        const patterns = [];
-        for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
-                if ('PRODUCTION_ENTRY_FILE_PATTERNS' in plugin) {
-                    patterns.push(...(pluginConfig.entry ?? plugin.PRODUCTION_ENTRY_FILE_PATTERNS));
-                }
-            }
-        }
-        if (patterns.length === 0)
-            return [];
-        return [patterns.flat(), negatedTestFilePatterns].flat();
-    }
     getConfigurationFilePatterns(pluginName) {
         const plugin = plugins[pluginName];
         const pluginConfig = this.getConfigForPlugin(pluginName);
         if (pluginConfig) {
             const defaultConfig = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
-            return pluginConfig.config ?? defaultConfig;
+            return (pluginConfig === true ? null : pluginConfig.config) ?? defaultConfig;
         }
         return [];
     }
@@ -203,31 +170,41 @@ export class WorkspaceWorker {
         const cwd = this.dir;
         const ignore = this.getIgnorePatterns();
         for (const [pluginName, plugin] of Object.entries(plugins)) {
-            const isIncludePlugin = this.isProduction ? `PRODUCTION_ENTRY_FILE_PATTERNS` in plugin : true;
-            if (this.enabled[pluginName] && isIncludePlugin) {
+            if (this.enabled[pluginName]) {
                 const hasDependencyFinder = 'findDependencies' in plugin && typeof plugin.findDependencies === 'function';
                 if (hasDependencyFinder) {
                     const pluginConfig = this.getConfigForPlugin(pluginName);
                     if (!pluginConfig)
                         continue;
                     const patterns = this.getConfigurationFilePatterns(pluginName);
-                    const configFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
+                    const allConfigFilePaths = await _pureGlob({ patterns, cwd, ignore, gitignore: false });
+                    const configFilePaths = allConfigFilePaths.filter(filePath => !filePath.endsWith('package.json') ||
+                        get(this.manifest, 'PACKAGE_JSON_PATH' in plugin ? plugin.PACKAGE_JSON_PATH : pluginName));
                     debugLogArray(`Found ${plugin.NAME} config file paths`, configFilePaths);
-                    if (configFilePaths.length === 0)
+                    if (patterns.length > 0 && configFilePaths.length === 0)
                         continue;
+                    if (patterns.length === 0)
+                        configFilePaths.push('__FAKE__');
                     const pluginDependencies = new Set();
                     for (const configFilePath of configFilePaths) {
                         const dependencies = await plugin.findDependencies(configFilePath, {
                             cwd,
                             manifest: this.manifest,
-                            config: pluginConfig,
+                            config: pluginConfig === true ? nullConfig : pluginConfig,
                             isProduction: this.isProduction,
                         });
-                        dependencies.map(toPosix).forEach(specifier => {
+                        dependencies.forEach(specifier => {
                             pluginDependencies.add(specifier);
-                            this.referencedDependencies.add([configFilePath, specifier]);
+                            if (isEntryPattern(specifier)) {
+                                this.entryFilePatterns.add(fromEntryPattern(specifier));
+                            }
+                            else if (isProductionEntryPattern(specifier)) {
+                                this.productionEntryFilePatterns.add(fromProductionEntryPattern(specifier));
+                            }
+                            else {
+                                this.referencedDependencies.add([configFilePath, toPosix(specifier)]);
+                            }
                         });
-                        dependencies.forEach(dependency => pluginDependencies.add(dependency));
                     }
                     debugLogArray(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
                 }
@@ -242,6 +219,8 @@ export class WorkspaceWorker {
             referencedDependencies: this.referencedDependencies,
             hasTypesIncluded: this.hasTypesIncluded,
             enabledPlugins: this.enabledPlugins,
+            entryFilePatterns: Array.from(this.entryFilePatterns),
+            productionEntryFilePatterns: Array.from(this.productionEntryFilePatterns),
         };
     }
 }

package/dist/binaries/index.js

@@ -2,8 +2,8 @@ import { compact } from '../util/array.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { isInternal } from '../util/path.js';
 import { timerify } from '../util/Performance.js';
+import { isBinary } from '../util/protocols.js';
 import { getBinariesFromScript } from './bash-parser.js';
-import { isBinary } from './util.js';
 const defaultCwd = process.cwd();
 const getDependenciesFromScripts = (npmScripts, options = {}) => {
     const { cwd = defaultCwd, manifest = {}, knownGlobalsOnly = false } = options;

package/dist/binaries/resolvers/c8.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary, argsFrom } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { argsFrom } from '../util.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args, {
         boolean: ['all', 'check-coverage', 'clean', 'exclude-after-remap', 'per-file', 'skip-full'],

package/dist/binaries/resolvers/dotenv.js

@@ -1,5 +1,6 @@
 import parseArgs from 'minimist';
-import { toBinary, argsFrom } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { argsFrom } from '../util.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args);
     return [toBinary(binary), ...fromArgs(argsFrom(args, parsed._[0]))];

package/dist/binaries/resolvers/fallback.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 const withPositional = parsed => [parsed._[0], parsed.require].flat();
 const withoutPositional = parsed => [parsed.require].flat();
 const argFilters = {

package/dist/binaries/resolvers/nodemon.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { tryResolveFilePath, tryResolveSpecifiers } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs }) => {
     const parsed = parseArgs(args, {
         string: ['r', 'exec'],

package/dist/binaries/resolvers/npx.js

@@ -1,7 +1,8 @@
 import parseArgs from 'minimist';
 import { isInternal } from '../../util/path.js';
+import { toBinary } from '../../util/protocols.js';
 import { getBinariesFromScript } from '../bash-parser.js';
-import { argsFrom, stripVersionFromSpecifier, toBinary } from '../util.js';
+import { argsFrom, stripVersionFromSpecifier } from '../util.js';
 export const resolve = (binary, args, { cwd, fromArgs, manifest }) => {
     const parsed = parseArgs(args, {
         boolean: ['yes', 'no'],

package/dist/binaries/resolvers/nx.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 export const resolve = (binary, args, { fromArgs }) => {
     const parsed = parseArgs(args);
     const [command] = parsed._;

package/dist/binaries/resolvers/pnpm.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 const commands = [
     'add',
     'audit',

package/dist/binaries/resolvers/rollup.js

@@ -1,6 +1,7 @@
 import parseArgs from 'minimist';
 import { compact } from '../../util/array.js';
-import { toBinary, tryResolveSpecifiers } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
+import { 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' } });

package/dist/binaries/resolvers/yarn.js

@@ -1,5 +1,5 @@
 import parseArgs from 'minimist';
-import { toBinary } from '../util.js';
+import { toBinary } from '../../util/protocols.js';
 const commands = [
     'add',
     'bin',

package/dist/binaries/util.d.ts

@@ -1,8 +1,5 @@
 export declare const tryResolveFilePath: (cwd: string, specifier: string, acceptModuleSpecifier?: boolean) => string | undefined;
 export declare const tryResolveSpecifiers: (cwd: string, specifiers: string[]) => (string | undefined)[];
-export declare const toBinary: (specifier: string) => string;
-export declare const fromBinary: (specifier: string) => string;
-export declare const isBinary: (specifier: string) => boolean;
 export declare const stripVersionFromSpecifier: (specifier: string) => string;
 export declare const stripBinaryPath: (command: string) => string;
 export declare const argsFrom: (args: string[], from: string) => string[];

package/dist/binaries/util.js

@@ -1,5 +1,6 @@
 import { getPackageNameFromFilePath, getPackageNameFromModuleSpecifier } from '../util/modules.js';
 import { isInNodeModules, join } from '../util/path.js';
+import { toBinary } from '../util/protocols.js';
 import { _tryResolve } from '../util/require.js';
 export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
     if (specifier) {
@@ -22,9 +23,6 @@ export const tryResolveFilePath = (cwd, specifier, acceptModuleSpecifier) => {
     }
 };
 export const tryResolveSpecifiers = (cwd, specifiers) => specifiers.map(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:');
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
 const stripNodeModulesFromPath = (command) => command.replace(/^(\.\/)?node_modules\//, '');
 export const stripBinaryPath = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)

package/dist/constants.d.ts

@@ -2,7 +2,6 @@ import type { IssueType } from './types/issues.js';
 export declare const ROOT_WORKSPACE_NAME = ".";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
-export declare const TEST_FILE_PATTERNS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
 export declare const IGNORED_GLOBAL_BINARIES: string[];
 export declare const IGNORED_DEPENDENCIES: string[];

package/dist/constants.js

@@ -1,10 +1,6 @@
 export const ROOT_WORKSPACE_NAME = '.';
 export const KNIP_CONFIG_LOCATIONS = ['knip.json', 'knip.jsonc', '.knip.json', '.knip.jsonc', 'knip.ts', 'knip.js'];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
-export const TEST_FILE_PATTERNS = [
-    '**/*{.,-}{test,spec}.{js,jsx,ts,tsx,mjs,cjs}',
-    '**/{test,__tests__}/**/*.{js,jsx,ts,tsx,mjs,cjs}',
-];
 export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
 export const IGNORED_GLOBAL_BINARIES = [
     'bash',

package/dist/index.js

@@ -1,6 +1,5 @@
 import micromatch from 'micromatch';
 import { _getDependenciesFromScripts } from './binaries/index.js';
-import { fromBinary, isBinary } from './binaries/util.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { ROOT_WORKSPACE_NAME } from './constants.js';
@@ -12,9 +11,10 @@ import { compact } from './util/array.js';
 import { debugLogObject, debugLogArray, debugLog } from './util/debug.js';
 import { LoaderError } from './util/errors.js';
 import { findFile } from './util/fs.js';
-import { _glob } from './util/glob.js';
+import { _glob, negate } from './util/glob.js';
 import { getEntryPathFromManifest, getPackageNameFromFilePath, getPackageNameFromModuleSpecifier, } from './util/modules.js';
 import { dirname, isInNodeModules, join, isInternal, toAbsolute } from './util/path.js';
+import { fromBinary, isBinary } from './util/protocols.js';
 import { _resolveSpecifier, _tryResolve } from './util/require.js';
 import { _require } from './util/require.js';
 import { loadTSConfig } from './util/tsconfig-loader.js';
@@ -113,21 +113,30 @@ export const main = async (unresolvedConfiguration) => {
         const entryPathsFromManifest = await getEntryPathFromManifest(cwd, dir, manifest);
         debugLogArray(`Found entry paths in package.json (${name})`, entryPathsFromManifest);
         principal.addEntryPaths(entryPathsFromManifest);
+        const dependencies = await worker.findAllDependencies();
+        const { referencedDependencies, hostDependencies, installedBinaries, hasTypesIncluded, enabledPlugins, entryFilePatterns, productionEntryFilePatterns, } = dependencies;
+        deputy.addHostDependencies(name, hostDependencies);
+        deputy.setInstalledBinaries(name, installedBinaries);
+        deputy.setHasTypesIncluded(name, hasTypesIncluded);
+        enabledPluginsStore.set(name, enabledPlugins);
+        referencedDependencies.forEach(([containingFilePath, specifier]) => {
+            handleReferencedDependency({ specifier, containingFilePath, principal, workspace });
+        });
         if (isProduction) {
+            const negatedEntryPatterns = entryFilePatterns.map(negate);
             {
-                const patterns = worker.getProductionEntryFilePatterns();
+                const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
-                const patterns = worker.getProductionPluginEntryFilePatterns();
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns: productionEntryFilePatterns });
                 debugLogArray(`Found production plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
             {
-                const patterns = worker.getProductionProjectFilePatterns();
+                const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
@@ -141,13 +150,13 @@ export const main = async (unresolvedConfiguration) => {
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
-                const patterns = worker.getProjectFilePatterns();
+                const patterns = worker.getProjectFilePatterns([...productionEntryFilePatterns]);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
             {
-                const patterns = worker.getPluginEntryFilePatterns();
+                const patterns = [...entryFilePatterns, ...productionEntryFilePatterns];
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(`Found plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
@@ -165,17 +174,9 @@ export const main = async (unresolvedConfiguration) => {
                 principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
             }
         }
-        if (chief.resolvedConfigFilePath)
+        if (chief.resolvedConfigFilePath) {
             principal.addEntryPath(chief.resolvedConfigFilePath, { skipExportsAnalysis: true });
-        const dependencies = await worker.findAllDependencies();
-        const { referencedDependencies, hostDependencies, installedBinaries, enabledPlugins, hasTypesIncluded } = dependencies;
-        deputy.addHostDependencies(name, hostDependencies);
-        deputy.setInstalledBinaries(name, installedBinaries);
-        deputy.setHasTypesIncluded(name, hasTypesIncluded);
-        enabledPluginsStore.set(name, enabledPlugins);
-        referencedDependencies.forEach(([containingFilePath, specifier]) => {
-            handleReferencedDependency({ specifier, containingFilePath, principal, workspace });
-        });
+        }
     }
     const principals = factory.getPrincipals();
     debugLog(`Installed ${principals.length} principals for ${workspaces.length} workspaces`);
@@ -183,6 +184,7 @@ export const main = async (unresolvedConfiguration) => {
     const exportedSymbols = new Map();
     const importedSymbols = new Map();
     for (const principal of principals) {
+        const specifierFilePaths = new Set();
         const analyzeSourceFile = (filePath, _principal = principal) => {
             const workspace = chief.findWorkspaceByFilePath(filePath);
             if (workspace) {
@@ -200,8 +202,7 @@ export const main = async (unresolvedConfiguration) => {
                             if (workspace) {
                                 const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                                 if (principal && !principal.isGitIgnored(specifierFilePath)) {
-                                    analyzeSourceFile(specifierFilePath, principal);
-                                    analyzedFiles.add(specifierFilePath);
+                                    specifierFilePaths.add(specifierFilePath);
                                 }
                             }
                         }
@@ -257,6 +258,12 @@ export const main = async (unresolvedConfiguration) => {
                 analyzedFiles.add(filePath);
             });
         } while (size !== principal.entryPaths.size);
+        specifierFilePaths.forEach(specifierFilePath => {
+            if (!analyzedFiles.has(specifierFilePath)) {
+                analyzedFiles.add(specifierFilePath);
+                analyzeSourceFile(specifierFilePath, principal);
+            }
+        });
     }
     const isSymbolImported = (symbol, importingModule) => {
         if (!importingModule)

package/dist/plugins/ava/index.d.ts

@@ -3,5 +3,5 @@ export declare const NAME = "Ava";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
-export declare const ENTRY_FILE_PATTERNS: never[];
+export declare const ENTRY_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/ava/index.js

@@ -1,20 +1,38 @@
 import { _getDependenciesFromScripts } from '../../binaries/index.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Ava';
 export const ENABLERS = ['ava'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['ava.config.{js,cjs,mjs}', 'package.json'];
-export const ENTRY_FILE_PATTERNS = [];
-const findAvaDependencies = async (configFilePath, { cwd, manifest }) => {
+export const ENTRY_FILE_PATTERNS = [
+    `test.{js,cjs,mjs}`,
+    `{src,source}/test.{js,cjs,mjs}`,
+    `**/__tests__/**/*.{js,cjs,mjs}`,
+    `**/*.spec.{js,cjs,mjs}`,
+    `**/*.test.{js,cjs,mjs}`,
+    `**/test-*.{js,cjs,mjs}`,
+    `**/test/**/*.{js,cjs,mjs}`,
+    `**/tests/**/*.{js,cjs,mjs}`,
+    '!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
+    '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
+];
+const findAvaDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
     const config = configFilePath.endsWith('package.json') ? manifest.ava : await load(configFilePath);
-    const requireArgs = (config?.require ?? []).map(require => `--require ${require}`);
-    const otherArgs = config?.nodeArguments ?? [];
+    const entryPatterns = (config?.files ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
+    if (isProduction)
+        return entryPatterns;
+    if (!config)
+        return [];
+    const requireArgs = (config.require ?? []).map(require => `--require ${require}`);
+    const otherArgs = config.nodeArguments ?? [];
     const cmd = `node ${otherArgs.join(' ')} ${requireArgs.join(' ')}`;
-    return _getDependenciesFromScripts([cmd], {
+    const dependencies = _getDependenciesFromScripts([cmd], {
         cwd,
         manifest,
         knownGlobalsOnly: true,
     });
+    return [...entryPatterns, ...dependencies];
 };
 export const findDependencies = timerify(findAvaDependencies);

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

@@ -1,4 +1,5 @@
 export type PluginConfig = {
+    files?: string[];
     require?: string[];
     nodeArguments?: string[];
 };

package/dist/plugins/babel/index.js

@@ -20,7 +20,9 @@ export const getDependenciesFromConfig = (config) => {
     const nested = config.env ? Object.values(config.env).flatMap(getDependenciesFromConfig) : [];
     return compact([...presets, ...plugins, ...nested]);
 };
-const findBabelDependencies = async (configFilePath, { manifest }) => {
+const findBabelDependencies = async (configFilePath, { manifest, isProduction }) => {
+    if (isProduction)
+        return [];
     let config = configFilePath.endsWith('package.json') ? manifest.babel : await load(configFilePath);
     if (typeof config === 'function') {
         config = config(api);

package/dist/plugins/capacitor/index.js

@@ -4,7 +4,9 @@ export const NAME = 'Capacitor';
 export const ENABLERS = [/^@capacitor\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['capacitor.config.ts'];
-const findCapacitorDependencies = async (configFilePath) => {
+const findCapacitorDependencies = async (configFilePath, { isProduction }) => {
+    if (isProduction)
+        return [];
     const config = await load(configFilePath);
     return config.includePlugins ?? [];
 };