knip 2.33.3 → 2.33.4

package/README.md

@@ -87,6 +87,8 @@ npm install -D knip
 
 Knip supports LTS versions of Node.js, and currently requires at least Node.js v16.17 or v18.6.
 
+Since v2.33.0, the Bun runtime is also supported.
+
 ### Default Configuration
 
 Knip has good defaults and aims for no or little configuration. The (simplified) default config:

package/dist/WorkspaceWorker.js

@@ -64,7 +64,7 @@ export class WorkspaceWorker {
         }
         this.enabledPlugins = getKeysByValue(this.enabled, true);
         const enabledPluginNames = this.enabledPlugins.map(name => plugins[name].NAME);
-        debugLogObject(`Enabled plugins (${this.name})`, enabledPluginNames);
+        debugLogObject(this.name, `Enabled plugins (${this.name})`, enabledPluginNames);
     }
     async initReferencedDependencies() {
         const { dependencies, hostDependencies, installedBinaries, hasTypesIncluded } = await npm.findDependencies({
@@ -82,7 +82,8 @@ export class WorkspaceWorker {
         this.hasTypesIncluded = hasTypesIncluded;
     }
     getConfigForPlugin(pluginName) {
-        return this.config[pluginName] !== true ? this.config[pluginName] ?? nullConfig : nullConfig;
+        const config = this.config[pluginName];
+        return typeof config === 'undefined' || typeof config === 'boolean' ? nullConfig : config;
     }
     getEntryFilePatterns() {
         const { entry } = this.config;
@@ -108,8 +109,8 @@ export class WorkspaceWorker {
         const patterns = [];
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
-            if (this.enabled[pluginName] && pluginConfig) {
-                const { entry, project } = pluginConfig === true ? nullConfig : pluginConfig;
+            if (this.enabled[pluginName]) {
+                const { entry, project } = pluginConfig;
                 patterns.push(...(project ?? entry ?? ('PROJECT_FILE_PATTERNS' in plugin ? plugin.PROJECT_FILE_PATTERNS : [])));
             }
         }
@@ -120,7 +121,7 @@ export class WorkspaceWorker {
         for (const [pluginName, plugin] of Object.entries(plugins)) {
             const pluginConfig = this.getConfigForPlugin(pluginName);
             if (this.enabled[pluginName] && pluginConfig) {
-                const { config } = pluginConfig === true ? nullConfig : pluginConfig;
+                const { config } = pluginConfig;
                 const defaultConfigFiles = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
                 patterns.push(...(config ?? defaultConfigFiles));
             }
@@ -160,7 +161,7 @@ export class WorkspaceWorker {
         const pluginConfig = this.getConfigForPlugin(pluginName);
         if (pluginConfig) {
             const defaultConfig = 'CONFIG_FILE_PATTERNS' in plugin ? plugin.CONFIG_FILE_PATTERNS : [];
-            return (pluginConfig === true ? null : pluginConfig.config) ?? defaultConfig;
+            return pluginConfig.config ?? defaultConfig;
         }
         return [];
     }
@@ -168,6 +169,7 @@ export class WorkspaceWorker {
         return [...this.rootIgnore, ...this.config.ignore.map(pattern => prependDirToPattern(this.name, pattern))];
     }
     async findDependenciesByPlugins() {
+        const name = this.name;
         const cwd = this.dir;
         const ignore = this.getIgnorePatterns();
         for (const [pluginName, plugin] of Object.entries(plugins)) {
@@ -181,22 +183,15 @@ export class WorkspaceWorker {
                     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 (patterns.length > 0 && configFilePaths.length === 0) {
-                        if (typeof pluginConfig !== 'boolean' && pluginConfig.entry !== null && pluginConfig.entry.length > 0) {
-                        }
-                        else {
-                            continue;
-                        }
-                    }
-                    if (patterns.length === 0)
+                    debugLogArray([name, plugin.NAME], 'config file paths', configFilePaths);
+                    if (configFilePaths.length === 0)
                         configFilePaths.push(FAKE_PATH);
                     const pluginDependencies = new Set();
                     for (const configFilePath of configFilePaths) {
                         const dependencies = await plugin.findDependencies(configFilePath, {
                             cwd,
                             manifest: this.manifest,
-                            config: pluginConfig === true ? nullConfig : pluginConfig,
+                            config: pluginConfig,
                             isProduction: this.isProduction,
                         });
                         dependencies.forEach(specifier => {
@@ -212,7 +207,7 @@ export class WorkspaceWorker {
                             }
                         });
                     }
-                    debugLogArray(`Dependencies referenced in ${plugin.NAME}`, pluginDependencies);
+                    debugLogArray([name, plugin.NAME], 'dependencies', pluginDependencies);
                 }
             }
         }

package/dist/binaries/bash-parser.js

@@ -52,7 +52,7 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
         return parsed?.commands ? getBinariesFromNodes(parsed.commands) : [];
     }
     catch (error) {
-        debugLogObject('Bash parser error', error);
+        debugLogObject('*', 'Bash parser error', error);
         return [];
     }
 };

package/dist/index.js

@@ -17,7 +17,7 @@ import { loadTSConfig } from './util/tsconfig-loader.js';
 import { WorkspaceWorker } from './WorkspaceWorker.js';
 export const main = async (unresolvedConfiguration) => {
     const { cwd, tsConfigFile, gitignore, isStrict, isProduction, isIgnoreInternal, isShowProgress, isIncludeEntryExports, } = unresolvedConfiguration;
-    debugLogObject('Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
+    debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
     const chief = new ConfigurationChief({ cwd, isProduction });
     const deputy = new DependencyDeputy({ isStrict });
     const factory = new PrincipalFactory();
@@ -35,8 +35,9 @@ export const main = async (unresolvedConfiguration) => {
     const collector = new IssueCollector({ cwd, rules, filters });
     const enabledPluginsStore = new Map();
     deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
-    debugLogObject('Included workspaces', workspaces.map(w => w.pkgName));
-    debugLogObject('Included workspace configs', workspaces.map(w => ({ name: w.name, pkgName: w.pkgName, config: w.config, ancestors: w.ancestors })));
+    const o = () => workspaces.map(w => ({ pkgName: w.pkgName, name: w.name, config: w.config, ancestors: w.ancestors }));
+    debugLogObject('*', 'Included workspaces', () => workspaces.map(w => w.pkgName));
+    debugLogObject('*', 'Included workspace configs', o);
     const handleReferencedDependency = ({ specifier, containingFilePath, principal, workspace, }) => {
         if (isInternal(specifier)) {
             const filePath = principal.resolveModule(specifier, containingFilePath)?.resolvedFileName;
@@ -82,7 +83,7 @@ export const main = async (unresolvedConfiguration) => {
     for (const workspace of workspaces) {
         const { name, dir, config, ancestors, pkgName, manifestPath, manifest } = workspace;
         const { paths, ignoreDependencies, ignoreBinaries } = config;
-        streamer.cast(`Analyzing workspace (${name})...`);
+        streamer.cast(`Analyzing workspace ${name}...`);
         deputy.addWorkspace({ name, dir, manifestPath, manifest, ignoreDependencies, ignoreBinaries });
         const { compilerOptions, definitionPaths } = await loadTSConfig(join(dir, tsConfigFile ?? 'tsconfig.json'));
         const principal = factory.getPrincipal({ cwd: dir, paths, compilerOptions, compilers, pkgName });
@@ -100,10 +101,10 @@ export const main = async (unresolvedConfiguration) => {
         });
         await worker.init();
         principal.addEntryPaths(definitionPaths);
-        debugLogArray(`Found definition paths (${name})`, definitionPaths);
+        debugLogArray(name, `Definition paths`, definitionPaths);
         const sharedGlobOptions = { cwd, workingDir: dir, gitignore, ignore: worker.getIgnorePatterns() };
         const entryPathsFromManifest = await getEntryPathFromManifest(cwd, dir, manifest);
-        debugLogArray(`Found entry paths in package.json (${name})`, entryPathsFromManifest);
+        debugLogArray(name, 'Entry paths in package.json', entryPathsFromManifest);
         principal.addEntryPaths(entryPathsFromManifest);
         const dependencies = await worker.findAllDependencies();
         const { referencedDependencies, hostDependencies, installedBinaries, hasTypesIncluded, enabledPlugins, entryFilePatterns, productionEntryFilePatterns, } = dependencies;
@@ -119,18 +120,18 @@ export const main = async (unresolvedConfiguration) => {
             {
                 const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
+                debugLogArray(name, `Entry paths`, workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns: productionEntryFilePatterns });
-                debugLogArray(`Found production plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
+                debugLogArray(name, `Production plugin entry paths`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
             {
                 const patterns = worker.getProductionProjectFilePatterns(negatedEntryPatterns);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
+                debugLogArray(name, `Project paths`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
         }
@@ -138,31 +139,31 @@ export const main = async (unresolvedConfiguration) => {
             {
                 const patterns = worker.getEntryFilePatterns();
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found entry paths (${name})`, workspaceEntryPaths);
+                debugLogArray(name, `Entry paths`, workspaceEntryPaths);
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
                 const patterns = worker.getProjectFilePatterns([...productionEntryFilePatterns]);
                 const workspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found project paths (${name})`, workspaceProjectPaths);
+                debugLogArray(name, `Project paths`, workspaceProjectPaths);
                 workspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
             {
                 const patterns = [...entryFilePatterns, ...productionEntryFilePatterns];
                 const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found plugin entry paths (${name})`, pluginWorkspaceEntryPaths);
+                debugLogArray(name, `Plugin entry paths`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
             {
                 const patterns = worker.getPluginProjectFilePatterns();
                 const pluginWorkspaceProjectPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found plugin project paths (${name})`, pluginWorkspaceProjectPaths);
+                debugLogArray(name, `Plugin project paths`, pluginWorkspaceProjectPaths);
                 pluginWorkspaceProjectPaths.forEach(projectPath => principal.addProjectPath(projectPath));
             }
             {
                 const patterns = compact(worker.getPluginConfigPatterns());
                 const configurationEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
-                debugLogArray(`Found plugin configuration paths (${name})`, configurationEntryPaths);
+                debugLogArray(name, `Plugin configuration paths`, configurationEntryPaths);
                 principal.addEntryPaths(configurationEntryPaths, { skipExportsAnalysis: true });
             }
         }
@@ -171,7 +172,7 @@ export const main = async (unresolvedConfiguration) => {
         }
     }
     const principals = factory.getPrincipals();
-    debugLog(`Installed ${principals.length} principals for ${workspaces.length} workspaces`);
+    debugLog('*', `Installed ${principals.length} principals for ${workspaces.length} workspaces`);
     const analyzedFiles = new Set();
     const exportedSymbols = new Map();
     const importedSymbols = new Map();
@@ -244,7 +245,7 @@ export const main = async (unresolvedConfiguration) => {
             size = principal.entryPaths.size;
             const resolvedFiles = principal.getUsedResolvedFiles();
             const files = resolvedFiles.filter(filePath => !analyzedFiles.has(filePath));
-            debugLogArray(`Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
+            debugLogArray('*', `Analyzing used resolved files [P${principals.indexOf(principal) + 1}/${++round}]`, files);
             files.forEach(filePath => {
                 analyzeSourceFile(filePath);
                 analyzedFiles.add(filePath);

package/dist/plugins/_template/index.js

@@ -1,5 +1,6 @@
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = '';
 export const ENABLERS = [''];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
@@ -7,8 +8,18 @@ export const CONFIG_FILE_PATTERNS = [];
 export const ENTRY_FILE_PATTERNS = [];
 export const PRODUCTION_ENTRY_FILE_PATTERNS = [];
 export const PROJECT_FILE_PATTERNS = [];
-const findPluginDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json') ? manifest.plugin : await load(configFilePath);
-    return config?.plugins ?? [];
+const findPluginDependencies = async (configFilePath, options) => {
+    const { manifest, config, isProduction } = options;
+    const localConfig = configFilePath.endsWith('package.json')
+        ? manifest.plugin
+        : await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const entryPatterns = (config?.entry ?? localConfig.entryPathsOrPatterns ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
+    const productionPatterns = config.entry ? [] : PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
+    if (isProduction)
+        return [...entryPatterns, ...productionPatterns];
+    const dependencies = localConfig?.plugins ?? [];
+    return [...dependencies, ...entryPatterns, ...productionPatterns];
 };
 export const findDependencies = timerify(findPluginDependencies);

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

@@ -1,3 +1,4 @@
 export type PluginConfig = {
     plugins?: string[];
+    entryPathsOrPatterns?: string[];
 };

package/dist/plugins/angular/index.js

@@ -6,26 +6,26 @@ export const NAME = 'Angular';
 export const ENABLERS = ['@angular/cli'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['angular.json'];
-const findPluginDependencies = async (configFilePath, opts) => {
-    const { cwd } = opts;
-    const config = await load(configFilePath);
-    if (!config.projects)
+const findPluginDependencies = async (configFilePath, options) => {
+    const { cwd } = options;
+    const localConfig = await load(configFilePath);
+    if (!localConfig?.projects)
         return [];
     const dependencies = new Set();
-    for (const project of Object.values(config.projects)) {
+    for (const project of Object.values(localConfig.projects)) {
         if (!project.architect)
             return [];
         for (const target of Object.values(project.architect)) {
-            const { options } = target;
+            const { options: opts } = target;
             const [packageName] = typeof target.builder === 'string' ? target.builder.split(':') : [];
             if (typeof packageName === 'string')
                 dependencies.add(packageName);
-            if (options) {
-                if ('main' in options && typeof options?.main === 'string') {
-                    dependencies.add(join(cwd, options.main));
+            if (opts) {
+                if ('main' in opts && typeof opts.main === 'string') {
+                    dependencies.add(join(cwd, opts.main));
                 }
-                if ('tsConfig' in options && typeof options.tsConfig === 'string') {
-                    const tsConfigDependencies = await findTypeScriptDependencies(join(cwd, options.tsConfig), opts);
+                if ('tsConfig' in opts && typeof opts.tsConfig === 'string') {
+                    const tsConfigDependencies = await findTypeScriptDependencies(join(cwd, opts.tsConfig), options);
                     tsConfigDependencies.forEach(dependency => dependencies.add(dependency));
                 }
             }

package/dist/plugins/ava/index.js

@@ -18,19 +18,20 @@ export const ENTRY_FILE_PATTERNS = [
     '!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
     '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 ];
-const findAvaDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
-    let config = configFilePath.endsWith('package.json') ? manifest.ava : await load(configFilePath);
-    if (typeof config === 'function')
-        config = config();
-    const entryPatterns = (config?.files ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
-    if (isProduction)
+const findAvaDependencies = async (configFilePath, options) => {
+    const { cwd, manifest, isProduction, config } = options;
+    let localConfig = configFilePath.endsWith('package.json')
+        ? manifest.ava
+        : await load(configFilePath);
+    if (typeof localConfig === 'function')
+        localConfig = localConfig();
+    const entryPatterns = (config.entry ?? localConfig?.files ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
+    if (isProduction || !localConfig)
         return entryPatterns;
-    if (!config)
-        return [];
-    const requireArgs = (config.require ?? []).map(require => `--require ${require}`);
-    const otherArgs = config.nodeArguments ?? [];
-    const cmd = `node ${otherArgs.join(' ')} ${requireArgs.join(' ')}`;
-    const dependencies = _getDependenciesFromScripts([cmd], {
+    const nodeArgs = localConfig.nodeArguments ?? [];
+    const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
+    const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
+    const dependencies = _getDependenciesFromScripts([fakeCommand], {
         cwd,
         manifest,
         knownGlobalsOnly: true,

package/dist/plugins/babel/index.js

@@ -23,10 +23,13 @@ export const getDependenciesFromConfig = (config) => {
 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);
-    }
-    return config ? getDependenciesFromConfig(config) : [];
+    let localConfig = configFilePath.endsWith('package.json')
+        ? manifest.babel
+        : await load(configFilePath);
+    if (typeof localConfig === 'function')
+        localConfig = localConfig(api);
+    if (!localConfig)
+        return [];
+    return getDependenciesFromConfig(localConfig);
 };
 export const findDependencies = timerify(findBabelDependencies);

package/dist/plugins/capacitor/index.js

@@ -7,7 +7,9 @@ export const CONFIG_FILE_PATTERNS = ['capacitor.config.ts'];
 const findCapacitorDependencies = async (configFilePath, { isProduction }) => {
     if (isProduction)
         return [];
-    const config = await load(configFilePath);
-    return config.includePlugins ?? [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return localConfig.includePlugins ?? [];
 };
 export const findDependencies = timerify(findCapacitorDependencies);

package/dist/plugins/changesets/index.js

@@ -7,11 +7,13 @@ export const CONFIG_FILE_PATTERNS = ['.changeset/config.json'];
 const findChangesetsDependencies = async (configFilePath, { isProduction }) => {
     if (isProduction)
         return [];
-    const config = await load(configFilePath);
-    return Array.isArray(config.changelog)
-        ? [config.changelog[0]]
-        : typeof config.changelog === 'string'
-            ? [config.changelog]
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return Array.isArray(localConfig.changelog)
+        ? [localConfig.changelog[0]]
+        : typeof localConfig.changelog === 'string'
+            ? [localConfig.changelog]
             : [];
 };
 export const findDependencies = timerify(findChangesetsDependencies);

package/dist/plugins/commitizen/index.js

@@ -8,10 +8,11 @@ export const CONFIG_FILE_PATTERNS = ['.czrc', '.cz.json', 'package.json'];
 const findPluginDependencies = async (configFilePath, { manifest, isProduction }) => {
     if (isProduction)
         return [];
-    const config = configFilePath.endsWith('package.json')
+    const localConfig = configFilePath.endsWith('package.json')
         ? manifest.config?.commitizen
         : await load(configFilePath);
-    const path = config?.path;
-    return path === undefined ? [] : [path];
+    if (!localConfig)
+        return [];
+    return localConfig.path ? [localConfig.path] : [];
 };
 export const findDependencies = timerify(findPluginDependencies);

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

@@ -1,3 +1,3 @@
-export type PluginConfig = {
+export type CommitizenConfig = {
     path?: string;
 };

package/dist/plugins/commitlint/index.js

@@ -12,9 +12,11 @@ export const CONFIG_FILE_PATTERNS = [
 const findCommitLintDependencies = async (configFilePath, { manifest, isProduction }) => {
     if (isProduction)
         return [];
-    const config = configFilePath.endsWith('package.json')
+    const localConfig = configFilePath.endsWith('package.json')
         ? manifest.commitlint
         : await load(configFilePath);
-    return config?.extends ? [config.extends].flat() : [];
+    if (!localConfig)
+        return [];
+    return localConfig.extends ? [localConfig.extends].flat() : [];
 };
 export const findDependencies = timerify(findCommitLintDependencies);

package/dist/plugins/cspell/index.js

@@ -12,8 +12,10 @@ export const CONFIG_FILE_PATTERNS = [
 const findCspellDependencies = async (configFilePath, { isProduction }) => {
     if (isProduction)
         return [];
-    const config = await load(configFilePath);
-    const imports = config?.import ?? [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const imports = localConfig.import ?? [];
     return imports;
 };
 export const findDependencies = timerify(findCspellDependencies);

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

@@ -1,3 +1,3 @@
-export type PluginConfig = {
+export type CSpellConfig = {
     import?: string[];
 };

package/dist/plugins/cypress/index.js

@@ -10,11 +10,14 @@ const SUPPORT_FILE_PATTERNS = [
     'cypress/plugins/index.js',
 ];
 export const ENTRY_FILE_PATTERNS = [...TEST_FILE_PATTERNS, ...SUPPORT_FILE_PATTERNS];
-export const findDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    if (!config)
+export const findDependencies = async (configFilePath, options) => {
+    const { config } = options;
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
         return [];
-    const patterns = [config.e2e?.specPattern ?? [], config.component?.specPattern ?? []].flat();
+    if (config.entry)
+        return config.entry.map(toEntryPattern);
+    const patterns = [localConfig.e2e?.specPattern ?? [], localConfig.component?.specPattern ?? []].flat();
     const entryPatterns = (patterns.length > 0 ? patterns : TEST_FILE_PATTERNS).map(toEntryPattern);
     return [...entryPatterns, ...SUPPORT_FILE_PATTERNS.map(toEntryPattern)];
 };

package/dist/plugins/drizzle/index.js

@@ -1,14 +1,14 @@
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Drizzle';
 export const ENABLERS = ['drizzle-kit'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['drizzle.config.{ts,js,json}'];
 const findDrizzleDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    if (!config || !config.schema)
+    const localConfig = await load(configFilePath);
+    if (!localConfig?.schema)
         return [];
-    return [config.schema].flat().map(toEntryPattern);
+    return [localConfig.schema].flat().map(toProductionEntryPattern);
 };
 export const findDependencies = timerify(findDrizzleDependencies);

package/dist/plugins/eslint/fallback.js

@@ -1,5 +1,6 @@
 import createJITI from 'jiti';
 import transform from 'jiti/dist/babel.js';
+import { FAKE_PATH } from '../../util/loader.js';
 import { timerify } from '../../util/Performance.js';
 const rushstackMatch = /require\(("|')@rushstack\/(eslint-config\/patch|eslint-patch)\/modern-module-resolution("|')\)/;
 const jiti = createJITI(process.cwd(), {
@@ -9,5 +10,9 @@ const jiti = createJITI(process.cwd(), {
         return transform(opts);
     },
 });
-const load = (configFilePath) => jiti(configFilePath);
+const load = (configFilePath) => {
+    if (configFilePath === FAKE_PATH)
+        return;
+    return jiti(configFilePath);
+};
 export const fallback = timerify(load);

package/dist/plugins/eslint/helpers.d.ts

@@ -4,10 +4,10 @@ import type { PackageJson } from '@npmcli/package-json';
 type Manifest = PackageJson & {
     eslintConfig?: ESLintConfig;
 };
-type GetDependenciesDeep = (configFilePath: string, dependencies: Set<string>, options: {
+type GetDependenciesDeep = (configFilePath: string, options: {
     cwd: string;
     manifest: Manifest;
-}) => Promise<Set<string>>;
+}, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
 export declare const resolvePluginSpecifier: (specifier: string) => string;
 export declare const resolveExtendSpecifier: (specifier: string) => string | undefined;

package/dist/plugins/eslint/helpers.js

@@ -24,25 +24,25 @@ const getDependencies = (config) => {
         ...overrides,
     ]);
 };
-export const getDependenciesDeep = async (configFilePath, dependencies = new Set(), options) => {
+export const getDependenciesDeep = async (configFilePath, options, dependencies = new Set()) => {
     const addAll = (deps) => deps.forEach(dependency => dependencies.add(dependency));
-    const config = configFilePath.endsWith('package.json')
+    const localConfig = configFilePath.endsWith('package.json')
         ? options.manifest[PACKAGE_JSON_PATH]
         : /(\.(jsonc?|ya?ml)|rc)$/.test(configFilePath)
             ? await load(configFilePath)
             : await fallback(configFilePath);
-    if (config) {
-        if (config.extends) {
-            for (const extend of [config.extends].flat()) {
+    if (localConfig) {
+        if (localConfig.extends) {
+            for (const extend of [localConfig.extends].flat()) {
                 if (isInternal(extend)) {
                     const filePath = toAbsolute(extend, dirname(configFilePath));
                     const extendConfigFilePath = _resolve(filePath);
                     dependencies.add(extendConfigFilePath);
-                    addAll(await getDependenciesDeep(extendConfigFilePath, dependencies, options));
+                    addAll(await getDependenciesDeep(extendConfigFilePath, options, dependencies));
                 }
             }
         }
-        addAll(getDependencies(config));
+        addAll(getDependencies(localConfig));
     }
     return dependencies;
 };

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

@@ -4,5 +4,4 @@ export declare const ENABLERS: string[];
 export declare const PACKAGE_JSON_PATH = "eslintConfig";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
-export declare const ENTRY_FILE_PATTERNS: never[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/eslint/index.js

@@ -14,13 +14,12 @@ export const CONFIG_FILE_PATTERNS = [
     '.eslintrc.{yml,yaml}',
     'package.json',
 ];
-export const ENTRY_FILE_PATTERNS = [];
 const findESLintDependencies = async (configFilePath, { cwd, manifest, isProduction }) => {
-    if (configFilePath.endsWith('eslint.config.js'))
-        return [];
     if (isProduction)
         return [];
-    const dependencies = await getDependenciesDeep(configFilePath, new Set(), { cwd, manifest });
+    if (configFilePath.endsWith('eslint.config.js'))
+        return [];
+    const dependencies = await getDependenciesDeep(configFilePath, { cwd, manifest });
     return Array.from(dependencies);
 };
 export const findDependencies = timerify(findESLintDependencies);

package/dist/plugins/gatsby/index.js

@@ -4,10 +4,7 @@ import { toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Gatsby';
 export const ENABLERS = ['gatsby', 'gatsby-cli'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = [
-    'gatsby-{config,node}.{js,jsx,ts,tsx}',
-    'plugins/**/gatsby-node.{js,jsx,ts,tsx}',
-];
+export const CONFIG_FILE_PATTERNS = ['gatsby-{config,node}.{js,jsx,ts,tsx}', 'plugins/**/gatsby-node.{js,jsx,ts,tsx}'];
 export const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
     'src/api/**/*.{js,ts}',
@@ -17,17 +14,17 @@ export const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'plugins/**/gatsby-{browser,ssr}.{js,jsx,ts,tsx}',
 ];
 const findGatsbyDependencies = async (configFilePath, { isProduction }) => {
-    const config = await load(configFilePath);
+    const localConfig = await load(configFilePath);
     const entryPatterns = PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
-    if (isProduction)
+    if (isProduction || !localConfig)
         return entryPatterns;
     if (/gatsby-config/.test(configFilePath)) {
-        return config.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
+        return localConfig.plugins.map(plugin => (typeof plugin === 'string' ? plugin : plugin.resolve));
     }
     if (/gatsby-node/.test(configFilePath)) {
         const plugins = new Set();
         const actions = { setBabelPlugin: plugin => plugins.add(plugin.name) };
-        const _config = config;
+        const _config = localConfig;
         if (typeof _config.onCreateBabelConfig === 'function') {
             _config.onCreateBabelConfig({ actions });
         }

package/dist/plugins/github-actions/index.d.ts

@@ -1,6 +1,6 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "GitHub Actions";
-export declare const ENABLERS = "This plugin is enabled when a `.yml` file is found in the `.github/workflows` folder.";
+export declare const ENABLERS = "This plugin is enabled when a `.yml` or `.yaml` file is found in the `.github/workflows` folder.";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;