knip 4.1.0 → 4.2.1

package/dist/index.js

@@ -1,11 +1,12 @@
 import micromatch from 'micromatch';
 import { _getDependenciesFromScripts } from './binaries/index.js';
-import { getExtensions, mergeCompilers } from './compilers/index.js';
+import { getCompilerExtensions, getIncludedCompilers } from './compilers/index.js';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
 import { IssueCollector } from './IssueCollector.js';
 import { IssueFixer } from './IssueFixer.js';
+import { getFilteredScripts } from './manifest/helpers.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { debugLogObject, debugLogArray, debugLog, exportLookupLog } from './util/debug.js';
@@ -28,8 +29,8 @@ export const main = async (unresolvedConfiguration) => {
     const isGitIgnored = await isGitIgnoredFn({ cwd, gitignore });
     streamer.cast('Reading workspace configuration(s)...');
     await chief.init();
-    const workspaces = chief.getWorkspaces();
-    const report = chief.getIssueTypesToReport();
+    const workspaces = chief.getIncludedWorkspaces();
+    const report = chief.getIncludedIssueTypes();
     const rules = chief.getRules();
     const filters = chief.getFilters();
     const fixer = new IssueFixer({ isEnabled: isFix, cwd, fixTypes });
@@ -40,7 +41,7 @@ export const main = async (unresolvedConfiguration) => {
     const isReportClassMembers = report.classMembers;
     const collector = new IssueCollector({ cwd, rules, filters });
     const enabledPluginsStore = new Map();
-    deputy.addIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
+    deputy.setIgnored(chief.config.ignoreBinaries, chief.config.ignoreDependencies);
     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);
@@ -87,12 +88,18 @@ export const main = async (unresolvedConfiguration) => {
         }
     };
     for (const workspace of workspaces) {
-        const { name, dir, ancestors, pkgName, manifestPath, manifest } = workspace;
+        const { name, dir, ancestors, pkgName, manifestPath } = workspace;
         streamer.cast(`Analyzing workspace ${name}...`);
-        const compilers = mergeCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, manifest);
-        const extensions = getExtensions(compilers);
+        const manifest = chief.getManifestForWorkspace(dir);
+        const { ignoreBinaries, ignoreDependencies } = chief.getIgnores(name);
+        deputy.addWorkspace({ name, cwd, dir, manifestPath, manifest, ignoreBinaries, ignoreDependencies });
+        const dependencies = deputy.getDependencies(name);
+        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
+        const extensions = getCompilerExtensions(compilers);
         const config = chief.getConfigForWorkspace(name, extensions);
-        deputy.addWorkspace({ name, dir, manifestPath, manifest, ...config });
+        const filteredScripts = getFilteredScripts({ isProduction, scripts: manifest.scripts });
+        const manifestScripts = Object.values(filteredScripts);
+        const manifestScriptNames = new Set(Object.keys(manifest.scripts ?? {}));
         const { compilerOptions, definitionPaths } = await loadTSConfig(join(dir, tsConfigFile ?? 'tsconfig.json'));
         const principal = factory.getPrincipal({
             cwd: dir,
@@ -109,6 +116,7 @@ export const main = async (unresolvedConfiguration) => {
             cwd,
             config,
             manifest,
+            dependencies,
             isProduction,
             isStrict,
             rootIgnore: chief.config.ignore,
@@ -121,18 +129,21 @@ export const main = async (unresolvedConfiguration) => {
         const ignore = worker.getIgnorePatterns();
         const sharedGlobOptions = { cwd, workingDir: dir, gitignore };
         collector.addIgnorePatterns(ignore.map(pattern => join(cwd, pattern)));
-        const entryPathsFromManifest = await getEntryPathFromManifest(manifest, { ...sharedGlobOptions, ignore });
-        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;
-        principal.addReferencedDependencies(referencedDependencies, name);
-        deputy.addHostDependencies(name, hostDependencies);
-        deputy.setInstalledBinaries(name, installedBinaries);
-        deputy.setHasTypesIncluded(name, hasTypesIncluded);
+        {
+            const options = { manifestScriptNames, cwd: dir, dependencies };
+            const dependenciesFromManifest = _getDependenciesFromScripts(manifestScripts, options);
+            principal.addReferencedDependencies(name, new Set(dependenciesFromManifest.map(id => [manifestPath, id])));
+        }
+        {
+            const entryPathsFromManifest = await getEntryPathFromManifest(manifest, { ...sharedGlobOptions, ignore });
+            debugLogArray(name, 'Entry paths in package.json', entryPathsFromManifest);
+            principal.addEntryPaths(entryPathsFromManifest);
+        }
+        const { referencedDependencies, enabledPlugins, entryFilePatterns, productionEntryFilePatterns } = await worker.findDependenciesByPlugins();
         enabledPluginsStore.set(name, enabledPlugins);
+        principal.addReferencedDependencies(name, referencedDependencies);
         if (isProduction) {
-            const negatedEntryPatterns = entryFilePatterns.map(negate);
+            const negatedEntryPatterns = Array.from(entryFilePatterns).map(negate);
             {
                 const patterns = worker.getProductionEntryFilePatterns(negatedEntryPatterns);
                 const workspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
@@ -140,7 +151,8 @@ export const main = async (unresolvedConfiguration) => {
                 principal.addEntryPaths(workspaceEntryPaths);
             }
             {
-                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns: productionEntryFilePatterns });
+                const patterns = Array.from(productionEntryFilePatterns);
+                const pluginWorkspaceEntryPaths = await _glob({ ...sharedGlobOptions, patterns });
                 debugLogArray(name, `Production plugin entry paths`, pluginWorkspaceEntryPaths);
                 principal.addEntryPaths(pluginWorkspaceEntryPaths, { skipExportsAnalysis: true });
             }
@@ -265,7 +277,11 @@ export const main = async (unresolvedConfiguration) => {
                     const { specifier, pos, line, col } = unresolvedImport;
                     collector.addIssue({ type: 'unresolved', filePath, symbol: specifier, pos, line, col });
                 });
-                _getDependenciesFromScripts(scripts, { cwd: dirname(filePath) }).forEach(specifier => {
+                _getDependenciesFromScripts(scripts, {
+                    cwd: dirname(filePath),
+                    manifestScriptNames: new Set(),
+                    dependencies: deputy.getDependencies(workspace.name),
+                }).forEach(specifier => {
                     handleReferencedDependency({ specifier, containingFilePath: filePath, principal: _principal, workspace });
                 });
             }

package/dist/manifest/helpers.d.ts

@@ -1,7 +1,13 @@
-type Options = {
+import type { Scripts } from '../types/package-json.js';
+type LoadPackageManifestOptions = {
     dir: string;
     packageName: string;
     cwd: string;
 };
-export declare const getPackageManifest: ({ dir, packageName, cwd }: Options) => Promise<any>;
+export declare const loadPackageManifest: ({ dir, packageName, cwd }: LoadPackageManifestOptions) => any;
+type GetFilteredScriptsOptions = {
+    isProduction: boolean;
+    scripts?: Scripts;
+};
+export declare const getFilteredScripts: ({ isProduction, scripts }: GetFilteredScriptsOptions) => Scripts;
 export {};

package/dist/manifest/helpers.js

@@ -1,6 +1,6 @@
 import { join } from '../util/path.js';
 import { _require } from '../util/require.js';
-export const getPackageManifest = async ({ dir, packageName, cwd }) => {
+export const loadPackageManifest = ({ dir, packageName, cwd }) => {
     try {
         return _require(join(dir, 'node_modules', packageName, 'package.json'));
     }
@@ -14,3 +14,16 @@ export const getPackageManifest = async ({ dir, packageName, cwd }) => {
         }
     }
 };
+export const getFilteredScripts = ({ isProduction, scripts }) => {
+    if (!scripts)
+        return {};
+    if (!isProduction)
+        return scripts;
+    const scriptFilter = new Set(['start', 'postinstall']);
+    const filteredScripts = {};
+    for (let scriptName in scripts) {
+        if (scriptFilter.has(scriptName))
+            filteredScripts[scriptName] = scripts[scriptName];
+    }
+    return filteredScripts;
+};

package/dist/manifest/index.d.ts

@@ -1,17 +1,12 @@
-/// <reference types="npmcli__package-json" />
 import type { InstalledBinaries, HostDependencies } from '../types/workspace.js';
-import type { PackageJson } from '@npmcli/package-json';
 type Options = {
-    manifest: PackageJson;
-    isProduction: boolean;
-    isStrict: boolean;
+    packageNames: string[];
     dir: string;
     cwd: string;
 };
-export declare const findDependencies: ({ manifest, isProduction, isStrict, dir, cwd }: Options) => Promise<{
-    dependencies: string[];
+export declare const getDependencyMetaData: ({ cwd, dir, packageNames }: Options) => {
     hostDependencies: HostDependencies;
     installedBinaries: InstalledBinaries;
     hasTypesIncluded: Set<string>;
-}>;
+};
 export {};

package/dist/manifest/index.js

@@ -1,26 +1,12 @@
-import { _getDependenciesFromScripts } from '../binaries/index.js';
 import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
-import { getPackageManifest } from './helpers.js';
-const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir, cwd }) => {
-    const scriptFilter = isProduction ? ['start', 'postinstall'] : [];
+import { loadPackageManifest } from './helpers.js';
+const _getDependencyMetaData = ({ cwd, dir, packageNames }) => {
     const hostDependencies = new Map();
-    const scripts = Object.entries(manifest.scripts ?? {}).reduce((scripts, [scriptName, script]) => {
-        if (script && (scriptFilter.length === 0 || scriptFilter.includes(scriptName))) {
-            scripts.push(script);
-        }
-        return scripts;
-    }, []);
-    const dependencies = _getDependenciesFromScripts(scripts, { cwd: dir, manifest });
     const installedBinaries = new Map();
     const hasTypesIncluded = new Set();
-    const packageNames = [
-        ...Object.keys(manifest.dependencies ?? {}),
-        ...(isStrict ? Object.keys(manifest.peerDependencies ?? {}) : []),
-        ...(isProduction ? [] : Object.keys(manifest.devDependencies ?? {})),
-    ];
     for (const packageName of packageNames) {
-        const manifest = await getPackageManifest({ dir, packageName, cwd });
+        const manifest = loadPackageManifest({ cwd, dir, packageName });
         if (manifest) {
             const binaryName = packageName.replace(/^@[^/]+\//, '');
             const binaries = typeof manifest.bin === 'string' ? [binaryName] : Object.keys(manifest.bin ?? {});
@@ -45,10 +31,10 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
                     isPeerOptional: manifest.peerDependenciesMeta?.[packagePeerDependency]?.optional ?? false,
                 };
                 if (hostDependencies.has(packagePeerDependency)) {
-                    hostDependencies.get(packagePeerDependency)?.add(hostDependency);
+                    hostDependencies.get(packagePeerDependency).push(hostDependency);
                 }
                 else {
-                    hostDependencies.set(packagePeerDependency, new Set([hostDependency]));
+                    hostDependencies.set(packagePeerDependency, [hostDependency]);
                 }
             }
             if (!isDefinitelyTyped(packageName) && (manifest.types || manifest.typings))
@@ -56,10 +42,9 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
         }
     }
     return {
-        dependencies,
         hostDependencies,
         installedBinaries,
         hasTypesIncluded,
     };
 };
-export const findDependencies = timerify(findManifestDependencies);
+export const getDependencyMetaData = timerify(_getDependencyMetaData);

package/dist/plugins/ava/index.js

@@ -19,7 +19,7 @@ const ENTRY_FILE_PATTERNS = [
     '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 ];
 const findAvaDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction, config } = options;
+    const { manifest, isProduction, config } = options;
     let localConfig = basename(configFilePath) === 'package.json' ? manifest.ava : await load(configFilePath);
     if (typeof localConfig === 'function')
         localConfig = localConfig();
@@ -29,11 +29,7 @@ const findAvaDependencies = async (configFilePath, options) => {
     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,
-    });
+    const dependencies = getDependenciesFromScripts([fakeCommand], { ...options, knownGlobalsOnly: true });
     return [...entryPatterns, ...dependencies];
 };
 const findDependencies = timerify(findAvaDependencies);

package/dist/plugins/eleventy/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { isDirectory } from '../../util/fs.js';
-import { dirname, isInternal, join } from '../../util/path.js';
+import { dirname, isInNodeModules, join } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 import { toProductionEntryPattern } from '../../util/protocols.js';
@@ -33,11 +33,11 @@ const findEleventyDependencies = async (configFilePath, options) => {
         if (isDir) {
             copiedEntries.add(join(path, `**/*.{${exts}}`));
         }
-        else if (isInternal(path)) {
-            copiedEntries.add(path);
+        else if (isInNodeModules(path)) {
+            copiedPackages.add(path);
         }
         else {
-            copiedPackages.add(path);
+            copiedEntries.add(path);
         }
     }
     return [

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

@@ -1,7 +1,7 @@
-import type { PackageJsonWithPlugins } from '../../types/package-json.js';
+import type { PackageJson } from '../../types/package-json.js';
 type GetDependenciesDeep = (configFilePath: string, options: {
     cwd: string;
-    manifest: PackageJsonWithPlugins;
+    manifest: PackageJson;
 }, dependencies?: Set<string>) => Promise<Set<string>>;
 export declare const getDependenciesDeep: GetDependenciesDeep;
 export {};

package/dist/plugins/github-actions/index.js

@@ -11,7 +11,7 @@ const ENABLERS = 'This plugin is enabled when a `.yml` or `.yaml` file is found
 const isEnabled = async ({ cwd }) => Boolean(await _firstGlob({ cwd, patterns: ['.github/workflows/*.{yml,yaml}'] }));
 const CONFIG_FILE_PATTERNS = ['.github/workflows/*.{yml,yaml}', '.github/**/action.{yml,yaml}'];
 const findGithubActionsDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { isProduction } = options;
     const configFileName = basename(configFilePath);
     if (isProduction)
         return [];
@@ -19,22 +19,14 @@ const findGithubActionsDependencies = async (configFilePath, options) => {
     if (!config)
         return [];
     const scripts = getValuesByKeyDeep(config, 'run').filter(isString);
-    return [
-        ...getActionDependencies(),
-        ...getDependenciesFromScripts(scripts, {
-            cwd,
-            manifest,
-            knownGlobalsOnly: true,
-        }),
-    ];
-    function getActionDependencies() {
+    const getActionDependencies = () => {
         const isActionManifest = configFileName === 'action.yml' || configFileName === 'action.yaml';
-        if (!isActionManifest || !config?.runs?.using?.startsWith('node')) {
+        if (!isActionManifest || !config?.runs?.using?.startsWith('node'))
             return [];
-        }
         const scripts = [config.runs.pre, config.runs.main, config.runs.post].filter(isString);
         return scripts.map(script => join(dirname(configFilePath), script));
-    }
+    };
+    return [...getActionDependencies(), ...getDependenciesFromScripts(scripts, { ...options, knownGlobalsOnly: true })];
 };
 const findDependencies = timerify(findGithubActionsDependencies);
 export default {

package/dist/plugins/husky/index.js

@@ -8,17 +8,13 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const gitHookPaths = getGitHookPaths('.husky');
 const CONFIG_FILE_PATTERNS = [...gitHookPaths];
 const findHuskyDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { isProduction } = options;
     if (isProduction || configFilePath === FAKE_PATH)
         return [];
     const script = await loadFile(configFilePath);
     if (!script)
         return [];
-    return getDependenciesFromScripts(String(script), {
-        cwd,
-        manifest,
-        knownGlobalsOnly: true,
-    });
+    return getDependenciesFromScripts(String(script), { ...options, knownGlobalsOnly: true });
 };
 const findDependencies = timerify(findHuskyDependencies);
 export default {

package/dist/plugins/index.d.ts

@@ -21,6 +21,7 @@ export { default as lintStaged } from './lint-staged/index.js';
 export { default as linthtml } from './linthtml/index.js';
 export { default as markdownlint } from './markdownlint/index.js';
 export { default as mocha } from './mocha/index.js';
+export { default as netlify } from './netlify/index.js';
 export { default as next } from './next/index.js';
 export { default as nodeTestRunner } from './node-test-runner/index.js';
 export { default as npmPackageJsonLint } from './npm-package-json-lint/index.js';

package/dist/plugins/index.js

@@ -21,6 +21,7 @@ export { default as lintStaged } from './lint-staged/index.js';
 export { default as linthtml } from './linthtml/index.js';
 export { default as markdownlint } from './markdownlint/index.js';
 export { default as mocha } from './mocha/index.js';
+export { default as netlify } from './netlify/index.js';
 export { default as next } from './next/index.js';
 export { default as nodeTestRunner } from './node-test-runner/index.js';
 export { default as npmPackageJsonLint } from './npm-package-json-lint/index.js';

package/dist/plugins/lefthook/index.js

@@ -10,7 +10,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const gitHookPaths = getGitHookPaths();
 const CONFIG_FILE_PATTERNS = ['lefthook.yml', ...gitHookPaths];
 const findLefthookDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { manifest, isProduction } = options;
     if (isProduction)
         return [];
     const dependencies = manifest.devDependencies ? Object.keys(manifest.devDependencies) : [];
@@ -20,12 +20,12 @@ const findLefthookDependencies = async (configFilePath, options) => {
             return [];
         const scripts = getValuesByKeyDeep(localConfig, 'run').filter((run) => typeof run === 'string');
         const lefthook = process.env.CI ? ENABLERS.filter(dependency => dependencies.includes(dependency)) : [];
-        return [...lefthook, ...getDependenciesFromScripts(scripts, { cwd, manifest, knownGlobalsOnly: true })];
+        return [...lefthook, ...getDependenciesFromScripts(scripts, { ...options, knownGlobalsOnly: true })];
     }
     const script = await loadFile(configFilePath);
     if (!script)
         return [];
-    const scriptDependencies = getDependenciesFromScripts([script], { cwd, manifest, knownGlobalsOnly: false });
+    const scriptDependencies = getDependenciesFromScripts([script], options);
     const matches = scriptDependencies.find(dep => dependencies.includes(fromBinary(dep)));
     return matches ? [matches] : [];
 };

package/dist/plugins/lint-staged/index.js

@@ -14,7 +14,7 @@ const CONFIG_FILE_PATTERNS = [
     'package.json',
 ];
 const findLintStagedDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { manifest, isProduction } = options;
     if (isProduction)
         return [];
     let localConfig = basename(configFilePath) === 'package.json' ? manifest['lint-staged'] : await load(configFilePath);
@@ -25,7 +25,6 @@ const findLintStagedDependencies = async (configFilePath, options) => {
     const dependencies = new Set();
     for (const entry of Object.values(localConfig).flat()) {
         const scripts = [typeof entry === 'function' ? await entry([]) : entry].flat();
-        const options = { cwd, manifest };
         getDependenciesFromScripts(scripts, options).forEach(identifier => dependencies.add(identifier));
     }
     return Array.from(dependencies);

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

@@ -0,0 +1,2 @@
+import type { FunctionsConfig } from './types.js';
+export declare const extractFunctionsConfigProperty: (config: FunctionsConfig, property: keyof FunctionsConfig) => string[];

package/dist/plugins/netlify/helpers.js

@@ -0,0 +1,4 @@
+export const extractFunctionsConfigProperty = (config, property) => [
+    ...(config[property] ?? []),
+    ...Object.values(config).filter(x => typeof x === 'object' && property in x).flatMap(x => x[property] || []),
+];

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

@@ -0,0 +1,10 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+declare const _default: {
+    NAME: string;
+    ENABLERS: (string | RegExp)[];
+    isEnabled: IsPluginEnabledCallback;
+    CONFIG_FILE_PATTERNS: string[];
+    PRODUCTION_ENTRY_FILE_PATTERNS: string[];
+    findDependencies: GenericPluginCallback;
+};
+export default _default;

package/dist/plugins/netlify/index.js

@@ -0,0 +1,38 @@
+import { join } from '../../util/path.js';
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { toProductionEntryPattern } from '../../util/protocols.js';
+import { extractFunctionsConfigProperty } from './helpers.js';
+const NAME = 'Netlify';
+const ENABLERS = [/^@netlify\/plugin-/, 'netlify-cli', '@netlify/functions'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+const CONFIG_FILE_PATTERNS = ['netlify.toml'];
+const NETLIFY_FUNCTIONS_DIR = 'netlify/functions';
+const NETLIFY_FUNCTIONS_EXTS = 'js,mjs,cjs,ts,mts,cts';
+const PRODUCTION_ENTRY_FILE_PATTERNS = [`${NETLIFY_FUNCTIONS_DIR}/**/*.{${NETLIFY_FUNCTIONS_EXTS}}`];
+const findPluginDependencies = async (configFilePath, options) => {
+    const { config } = options;
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return config.entry
+            ? config.entry.map(toProductionEntryPattern)
+            : PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
+    const dependencies = [
+        ...(localConfig?.plugins?.map(plugin => plugin.package) ?? []),
+        ...extractFunctionsConfigProperty(localConfig.functions || {}, 'external_node_modules'),
+    ];
+    const entryFiles = [
+        ...extractFunctionsConfigProperty(localConfig.functions || {}, 'included_files'),
+        join(localConfig.functions?.directory ?? NETLIFY_FUNCTIONS_DIR, `**/*.{${NETLIFY_FUNCTIONS_EXTS}}`),
+    ].filter(file => !file.startsWith('!'));
+    return [...dependencies, ...entryFiles.map(toProductionEntryPattern)];
+};
+const findDependencies = timerify(findPluginDependencies);
+export default {
+    NAME,
+    ENABLERS,
+    isEnabled,
+    CONFIG_FILE_PATTERNS,
+    PRODUCTION_ENTRY_FILE_PATTERNS,
+    findDependencies,
+};

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

@@ -0,0 +1,11 @@
+export type NetlifyConfig = {
+    plugins?: {
+        package: string;
+    }[];
+    functions?: FunctionsConfig;
+};
+export type FunctionsConfig = {
+    directory?: string;
+    external_node_modules?: string[];
+    included_files?: string[];
+};

package/dist/plugins/netlify/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/nx/index.js

@@ -6,7 +6,7 @@ const ENABLERS = ['nx', /^@nrwl\//, /^@nx\//];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const CONFIG_FILE_PATTERNS = ['project.json', '{apps,libs}/**/project.json'];
 const findNxDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { isProduction } = options;
     if (isProduction)
         return [];
     const localConfig = await load(configFilePath);
@@ -20,7 +20,7 @@ const findNxDependencies = async (configFilePath, options) => {
     const scripts = targets
         .filter(target => target.executor === 'nx:run-commands')
         .flatMap(target => target.options?.commands ?? (target.options?.command ? [target.options.command] : []));
-    const dependencies = getDependenciesFromScripts(scripts, { cwd, manifest });
+    const dependencies = getDependenciesFromScripts(scripts, options);
     return compact([...executors, ...dependencies]);
 };
 const findDependencies = timerify(findNxDependencies);

package/dist/plugins/release-it/index.js

@@ -7,7 +7,7 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const PACKAGE_JSON_PATH = 'release-it';
 const CONFIG_FILE_PATTERNS = ['.release-it.json', '.release-it.{js,cjs}', '.release-it.{yml,yaml}', 'package.json'];
 const findReleaseItDependencies = async (configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { manifest, isProduction } = options;
     if (isProduction)
         return [];
     const localConfig = basename(configFilePath) === 'package.json' ? manifest[PACKAGE_JSON_PATH] : await load(configFilePath);
@@ -21,7 +21,7 @@ const findReleaseItDependencies = async (configFilePath, options) => {
     if (typeof localConfig.gitlab?.releaseNotes === 'string') {
         scripts.push(localConfig.gitlab.releaseNotes);
     }
-    const dependencies = getDependenciesFromScripts(scripts, { cwd, manifest });
+    const dependencies = getDependenciesFromScripts(scripts, options);
     return [...plugins, ...dependencies];
 };
 const findDependencies = timerify(findReleaseItDependencies);

package/dist/plugins/vitest/index.js

@@ -16,12 +16,12 @@ const resolveEntry = (containingFilePath, specifier) => {
         return toEntryPattern(relative(dir, resolvedPath));
     return specifier;
 };
-const enablesCoverageInScript = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
-const hasScriptWithCoverage = (scripts) => {
-    return Object.values(scripts).some(script => {
-        return enablesCoverageInScript.test(script);
-    });
-};
+const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
+const hasScriptWithCoverage = (scripts) => scripts
+    ? Object.values(scripts).some(script => {
+        return isVitestCoverageCommand.test(script);
+    })
+    : false;
 const findConfigDependencies = (configFilePath, localConfig, options) => {
     const { isProduction, config, manifest } = options;
     const testConfig = localConfig.test;
@@ -30,8 +30,7 @@ const findConfigDependencies = (configFilePath, localConfig, options) => {
         return entryPatterns;
     const environments = testConfig.environment ? [getEnvPackageName(testConfig.environment)] : [];
     const reporters = getExternalReporters(testConfig.reporters);
-    const hasCoverageEnabled = (testConfig.coverage && testConfig.coverage.enabled !== false) ||
-        (manifest.scripts !== undefined && hasScriptWithCoverage(manifest.scripts));
+    const hasCoverageEnabled = (testConfig.coverage && testConfig.coverage.enabled !== false) || hasScriptWithCoverage(manifest.scripts);
     const coverage = hasCoverageEnabled ? [`@vitest/coverage-${testConfig.coverage?.provider ?? 'v8'}`] : [];
     const setupFiles = [testConfig.setupFiles ?? []].flat().map(v => resolveEntry(configFilePath, v));
     const globalSetup = [testConfig.globalSetup ?? []].flat().map(v => resolveEntry(configFilePath, v));

package/dist/plugins/wireit/index.js

@@ -6,14 +6,14 @@ const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const PACKAGE_JSON_PATH = 'wireit';
 const CONFIG_FILE_PATTERNS = ['package.json'];
 const findWireItDependencies = async (_configFilePath, options) => {
-    const { cwd, manifest, isProduction } = options;
+    const { manifest, isProduction } = options;
     if (isProduction)
         return [];
     const localConfig = manifest[PACKAGE_JSON_PATH];
     if (!localConfig)
         return [];
     const scripts = Object.values(localConfig).flatMap(({ command: script }) => (script ? [script] : []));
-    const scriptDependencies = getDependenciesFromScripts(scripts, { cwd, manifest });
+    const scriptDependencies = getDependenciesFromScripts(scripts, options);
     return scriptDependencies;
 };
 const findDependencies = timerify(findWireItDependencies);

package/dist/types/config.d.ts

@@ -21,8 +21,6 @@ interface BaseWorkspaceConfiguration {
     project: NormalizedGlob;
     paths: Record<string, string[]>;
     ignore: NormalizedGlob;
-    ignoreBinaries: IgnorePatterns;
-    ignoreDependencies: IgnorePatterns;
     isIncludeEntryExports: boolean;
 }
 export interface WorkspaceConfiguration extends BaseWorkspaceConfiguration, Partial<PluginsConfiguration> {

package/dist/types/package-json.d.ts

@@ -20,7 +20,8 @@ type PluginKeys = {
     [K in keyof PluginMap]: ExtractKeys<PluginMap[K], K>;
 };
 type Plugins = MergeUnion<PluginKeys[keyof PluginMap]>;
-export type PackageJsonWithPlugins = {
+export type Scripts = Record<string, string>;
+export type PackageJson = {
     name?: string;
     main?: string;
     bin?: string | Record<string, string>;
@@ -29,7 +30,7 @@ export type PackageJsonWithPlugins = {
         packages?: string[];
     };
     exports?: Exports;
-    scripts?: Record<string, string>;
+    scripts?: Scripts;
     dependencies?: Dependency;
     devDependencies?: Dependency;
     peerDependencies?: Dependency;

package/dist/types/plugins.d.ts

@@ -1,19 +1,24 @@
 import type { EnsuredPluginConfiguration, WorkspaceConfiguration } from './config.js';
-import type { PackageJsonWithPlugins } from './package-json.js';
+import type { PackageJson } from './package-json.js';
+import type { DependencySet } from './workspace.js';
+export interface BaseOptions {
+    cwd: string;
+    manifestScriptNames: Set<string>;
+    dependencies: DependencySet;
+}
 type IsPluginEnabledCallbackOptions = {
     cwd: string;
-    manifest: PackageJsonWithPlugins;
+    manifest: PackageJson;
     dependencies: Set<string>;
     config: WorkspaceConfiguration;
 };
 export type IsPluginEnabledCallback = (options: IsPluginEnabledCallbackOptions) => boolean | Promise<boolean>;
-export type GenericPluginCallbackOptions = {
-    cwd: string;
-    manifest: PackageJsonWithPlugins;
+export interface GenericPluginCallbackOptions extends BaseOptions {
+    manifest: PackageJson;
     config: EnsuredPluginConfiguration;
     isProduction: boolean;
     enabledPlugins: string[];
-};
+}
 export type GenericPluginCallback = (configFilePath: string, options: GenericPluginCallbackOptions) => Promise<string[]> | string[];
 export interface Plugin {
     NAME: string;