knip 4.1.0 → 4.2.0

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;

package/dist/types/workspace.d.ts

@@ -1,20 +1,22 @@
+export type DependencySet = Set<string>;
+export type DependencyArray = Array<string>;
 type WorkspaceManifest = {
     workspaceDir: string;
     manifestPath: string;
-    scripts: string[];
-    dependencies: string[];
-    peerDependencies: string[];
-    optionalPeerDependencies: string[];
-    optionalDependencies: string[];
-    devDependencies: string[];
-    allDependencies: string[];
+    dependencies: DependencyArray;
+    devDependencies: DependencyArray;
+    peerDependencies: DependencySet;
+    optionalPeerDependencies: DependencyArray;
+    allDependencies: DependencySet;
     ignoreDependencies: (string | RegExp)[];
     ignoreBinaries: (string | RegExp)[];
 };
 export type WorkspaceManifests = Map<string, WorkspaceManifest>;
-export type HostDependencies = Map<string, Set<{
+export type HostDependencies = Map<string, Array<{
     name: string;
     isPeerOptional: boolean;
 }>>;
-export type InstalledBinaries = Map<string, Set<string>>;
+type PackageName = string;
+type BinaryName = string;
+export type InstalledBinaries = Map<PackageName, Set<BinaryName>>;
 export {};

package/dist/typescript/createHosts.js

@@ -1,7 +1,7 @@
 import { EOL } from 'node:os';
 import path from 'node:path';
 import ts from 'typescript';
-import { getExtensions } from '../compilers/index.js';
+import { getCompilerExtensions } from '../compilers/index.js';
 import { createCustomModuleResolver } from './resolveModuleNames.js';
 import { SourceFileManager } from './SourceFileManager.js';
 import { createCustomSys } from './sys.js';
@@ -9,7 +9,7 @@ const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
 const fileManager = new SourceFileManager();
 export const createHosts = ({ cwd, compilerOptions, entryPaths, compilers }) => {
     fileManager.installCompilers(compilers);
-    const virtualFileExtensions = getExtensions(compilers);
+    const virtualFileExtensions = getCompilerExtensions(compilers);
     const sys = createCustomSys(cwd, virtualFileExtensions);
     const resolveModuleNames = createCustomModuleResolver(sys, compilerOptions, virtualFileExtensions);
     const languageServiceHost = {

package/dist/util/fs.d.ts

@@ -4,6 +4,7 @@ export declare const findFile: (workingDir: string, fileName: string) => string
 export declare const loadFile: (filePath: string) => Promise<string>;
 export declare const loadJSON: (filePath: string) => Promise<any>;
 export declare const loadYAML: (filePath: string) => Promise<unknown>;
+export declare const loadTOML: (filePath: string) => Promise<Record<string, import("smol-toml").TomlPrimitive>>;
 export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
 export declare const parseYAML: (contents: string) => Promise<unknown>;
 export declare function isTypeModule(path: string): boolean;

package/dist/util/fs.js

@@ -1,6 +1,7 @@
 import { readFileSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import yaml from 'js-yaml';
+import { parse as parseTOML } from 'smol-toml';
 import stripJsonComments from 'strip-json-comments';
 import { LoaderError } from './errors.js';
 import { FAKE_PATH } from './loader.js';
@@ -37,6 +38,10 @@ export const loadYAML = async (filePath) => {
     const contents = await loadFile(filePath);
     return parseYAML(contents);
 };
+export const loadTOML = async (filePath) => {
+    const contents = await loadFile(filePath);
+    return parseTOML(contents);
+};
 export const parseJSON = async (filePath, contents) => {
     try {
         return JSON.parse(stripJsonComments(contents, { trailingCommas: true }));

package/dist/util/loader.js

@@ -1,6 +1,6 @@
 import { pathToFileURL } from 'node:url';
 import { LoaderError } from './errors.js';
-import { loadJSON, loadYAML, loadFile, parseJSON, parseYAML } from './fs.js';
+import { loadJSON, loadYAML, loadTOML, loadFile, parseJSON, parseYAML } from './fs.js';
 import { isTypeModule } from './fs.js';
 import { extname } from './path.js';
 import { timerify } from './Performance.js';
@@ -21,6 +21,9 @@ const load = async (filePath) => {
         if (ext === '.yaml' || ext === '.yml') {
             return loadYAML(filePath);
         }
+        if (ext === '.toml') {
+            return loadTOML(filePath);
+        }
         if (ext === '.mjs' || (ext === '.js' && isTypeModule(filePath))) {
             const fileUrl = pathToFileURL(filePath);
             const imported = await import(fileUrl.href);

package/dist/util/modules.d.ts

@@ -1,4 +1,4 @@
-import type { PackageJson } from '@npmcli/package-json';
+import type { PackageJson } from '../types/package-json.js';
 export declare const getPackageNameFromModuleSpecifier: (moduleSpecifier: string) => string | undefined;
 export declare const getPackageNameFromFilePath: (value: string) => string;
 export declare const normalizeSpecifierFromFilePath: (value: string) => string;

package/dist/util/regex.d.ts

@@ -1,5 +1,4 @@
 export declare const toRegexOrString: (value: string | RegExp) => string | RegExp;
 export declare const hasMatch: (haystack: undefined | (string | RegExp)[], needle: string) => boolean | undefined;
 export declare const hasMatchInSet: (haystack: undefined | Set<string>, needle: string | RegExp) => boolean | undefined;
-export declare const hasMatchInArray: (haystack: string[], needle: string | RegExp) => boolean;
 export declare const findKey: (map: Map<string | RegExp, unknown>, key: RegExp) => string | RegExp | undefined;