knip 0.0.0-graph.3 → 0.0.0-node-types.0

package/dist/plugins/remark/index.js

@@ -2,6 +2,7 @@ import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'Remark';
 export const ENABLERS = ['remark-cli'];
+export const PACKAGE_JSON_PATH = 'remarkConfig';
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
     'package.json',
@@ -10,9 +11,24 @@ export const CONFIG_FILE_PATTERNS = [
     '.remarkrc.{js,cjs,mjs}',
     '.remarkrc.{yml,yaml}',
 ];
-const findRemarkDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json') ? manifest.remarkConfig : await load(configFilePath);
-    const plugins = config?.plugins?.map(plugin => `remark-${plugin}`) ?? [];
-    return [...plugins];
+const findRemarkDependencies = async (configFilePath, options) => {
+    const { manifest, isProduction } = options;
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
+        ? manifest[PACKAGE_JSON_PATH]
+        : await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const plugins = localConfig.plugins
+        ?.flatMap(plugin => {
+        if (typeof plugin === 'string')
+            return plugin;
+        if (Array.isArray(plugin) && typeof plugin[0] === 'string')
+            return plugin[0];
+        return [];
+    })
+        .map(plugin => (plugin.startsWith('remark-') ? plugin : `remark-${plugin}`)) ?? [];
+    return plugins;
 };
 export const findDependencies = timerify(findRemarkDependencies);

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

@@ -0,0 +1,3 @@
+export type RemarkConfig = {
+    plugins?: (string | [string, boolean] | unknown)[];
+};

package/dist/plugins/remark/types.js

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

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

@@ -1,6 +1,7 @@
-import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
 export declare const NAME = "Remix";
 export declare const ENABLERS: RegExp[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const ENTRY_FILE_PATTERNS: string[];
 export declare const PRODUCTION_ENTRY_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/remix/index.js

@@ -1,4 +1,6 @@
+import { timerify } from '../../util/Performance.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Remix';
 export const ENABLERS = [/^@remix-run\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
@@ -9,3 +11,10 @@ export const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'app/routes/**/*.{js,ts,tsx}',
     'server.{js,ts}',
 ];
+const findRemixDependencies = async (configFilePath, options) => {
+    const { config } = options;
+    return config.entry
+        ? config.entry.map(toProductionEntryPattern)
+        : [...ENTRY_FILE_PATTERNS.map(toEntryPattern), ...PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern)];
+};
+export const findDependencies = timerify(findRemixDependencies);

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

@@ -1,5 +1,6 @@
-import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
 export declare const NAME = "Rollup";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/rollup/index.js

@@ -1,5 +1,12 @@
+import { timerify } from '../../util/Performance.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Rollup';
 export const ENABLERS = ['rollup'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const ENTRY_FILE_PATTERNS = ['rollup.config.{js,mjs,ts}'];
+export const ENTRY_FILE_PATTERNS = ['rollup.config.{js,cjs,mjs,ts}'];
+const findRollupDependencies = async () => {
+    const entryPatterns = ENTRY_FILE_PATTERNS.map(toEntryPattern);
+    return entryPatterns;
+};
+export const findDependencies = timerify(findRollupDependencies);

package/dist/plugins/semantic-release/index.d.ts

@@ -1,6 +1,7 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "Semantic Release";
 export declare const ENABLERS: string[];
+export declare const PACKAGE_JSON_PATH = "release";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

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

@@ -2,6 +2,7 @@ import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'Semantic Release';
 export const ENABLERS = ['semantic-release'];
+export const PACKAGE_JSON_PATH = 'release';
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
     '.releaserc',
@@ -9,9 +10,14 @@ export const CONFIG_FILE_PATTERNS = [
     'release.config.{js,cjs}',
     'package.json',
 ];
-const findSemanticReleaseDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json') ? manifest.release : await load(configFilePath);
-    const plugins = config?.plugins ?? [];
-    return plugins.map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
+const findSemanticReleaseDependencies = async (configFilePath, options) => {
+    const { manifest, isProduction } = options;
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
+        ? manifest[PACKAGE_JSON_PATH]
+        : await load(configFilePath);
+    const plugins = (localConfig?.plugins ?? []).map(plugin => (Array.isArray(plugin) ? plugin[0] : plugin));
+    return plugins;
 };
 export const findDependencies = timerify(findSemanticReleaseDependencies);

package/dist/plugins/semantic-release/types.d.ts

@@ -1,3 +1,3 @@
-export type PluginConfig = {
+export type SemanticReleaseConfig = {
     plugins?: (string | [string, Record<string, unknown>])[];
 };

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

@@ -1,5 +1,6 @@
-import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
 export declare const NAME = "Sentry";
 export declare const ENABLERS: RegExp[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/sentry/index.js

@@ -1,5 +1,12 @@
+import { timerify } from '../../util/Performance.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Sentry';
 export const ENABLERS = [/^@sentry\//];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const ENTRY_FILE_PATTERNS = ['sentry.{client,server,edge}.config.{js,ts}'];
+const findSentryDependencies = async () => {
+    const entryPatterns = ENTRY_FILE_PATTERNS.map(toEntryPattern);
+    return entryPatterns;
+};
+export const findDependencies = timerify(findSentryDependencies);

package/dist/plugins/storybook/index.js

@@ -1,19 +1,37 @@
+import { dirname, join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Storybook';
 export const ENABLERS = [/^@storybook\//, '@nrwl/storybook'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['.storybook/{main,manager,test-runner}.{js,ts}'];
-export const ENTRY_FILE_PATTERNS = ['.storybook/preview.{js,jsx,ts,tsx}', '**/*.stories.{js,jsx,ts,tsx}'];
+export const CONFIG_FILE_PATTERNS = ['.storybook/{main,test-runner}.{js,ts}'];
+const STORIES_FILE_PATTERNS = ['**/*.@(mdx|stories.@(mdx|js|jsx|mjs|ts|tsx))'];
+const REST_ENTRY_FILE_PATTERNS = ['.storybook/{manager,preview}.{js,jsx,ts,tsx}'];
+export const ENTRY_FILE_PATTERNS = [...REST_ENTRY_FILE_PATTERNS, ...STORIES_FILE_PATTERNS];
 export const PROJECT_FILE_PATTERNS = ['.storybook/**/*.{js,jsx,ts,tsx}'];
-const findStorybookDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    if (!config)
-        return [];
-    const addons = config.addons?.map(addon => (typeof addon === 'string' ? addon : addon.name)) ?? [];
-    const builder = config?.core?.builder;
+const findStorybookDependencies = async (configFilePath, options) => {
+    const { isProduction, cwd, config } = options;
+    const localConfig = await load(configFilePath);
+    const stories = typeof localConfig?.stories === 'function'
+        ? await localConfig.stories(STORIES_FILE_PATTERNS)
+        : localConfig?.stories;
+    const relativePatterns = stories?.map(pattern => {
+        if (typeof pattern === 'string')
+            return relative(cwd, join(dirname(configFilePath), pattern));
+        return relative(cwd, join(dirname(configFilePath), pattern.directory, pattern.files ?? STORIES_FILE_PATTERNS[0]));
+    });
+    const patterns = [
+        ...(config?.entry ?? REST_ENTRY_FILE_PATTERNS),
+        ...(relativePatterns && relativePatterns.length > 0 ? relativePatterns : STORIES_FILE_PATTERNS),
+    ];
+    const entryPatterns = patterns.map(toEntryPattern);
+    if (!localConfig || isProduction)
+        return entryPatterns;
+    const addons = localConfig.addons?.map(addon => (typeof addon === 'string' ? addon : addon.name)) ?? [];
+    const builder = localConfig?.core?.builder;
     const builderPackages = builder && /webpack/.test(builder) ? [`@storybook/builder-${builder}`, `@storybook/manager-${builder}`] : [];
-    const frameworks = config.framework?.name ? [config.framework.name] : [];
-    return [...addons, ...builderPackages, ...frameworks];
+    const frameworks = localConfig.framework?.name ? [localConfig.framework.name] : [];
+    return [...entryPatterns, ...addons, ...builderPackages, ...frameworks];
 };
 export const findDependencies = timerify(findStorybookDependencies);

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

@@ -1,4 +1,10 @@
+type Stories = (string | {
+    directory: string;
+    files?: string;
+    titlePrefix?: string;
+})[];
 export type StorybookConfig = {
+    stories?: Stories | ((patterns: string[]) => Promise<string[]>);
     addons?: (string | {
         name: string;
     })[];
@@ -9,3 +15,4 @@ export type StorybookConfig = {
         name?: string;
     };
 };
+export {};

package/dist/plugins/stryker/index.js

@@ -4,14 +4,18 @@ export const NAME = 'Stryker';
 export const ENABLERS = ['@stryker-mutator/core'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['?(.)stryker.{conf,config}.{js,mjs,cjs,json}'];
-const findStrykerDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    if (config) {
-        const runners = config.testRunner ? [`@stryker-mutator/${config.testRunner}-runner`] : [];
-        const checkers = config.checkers ? config.checkers.map(checker => `@stryker-mutator/${checker}-checker`) : [];
-        const plugins = config.plugins ?? [];
-        return [...runners, ...checkers, ...plugins];
-    }
-    return [];
+const findStrykerDependencies = async (configFilePath, options) => {
+    const { isProduction } = options;
+    if (isProduction)
+        return [];
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    const runners = localConfig.testRunner ? [`@stryker-mutator/${localConfig.testRunner}-runner`] : [];
+    const checkers = localConfig.checkers
+        ? localConfig.checkers.map(checker => `@stryker-mutator/${checker}-checker`)
+        : [];
+    const plugins = localConfig.plugins ?? [];
+    return [...runners, ...checkers, ...plugins];
 };
 export const findDependencies = timerify(findStrykerDependencies);

package/dist/plugins/stylelint/index.js

@@ -9,14 +9,17 @@ export const CONFIG_FILE_PATTERNS = [
     '.stylelintrc.{cjs,js,json,yaml,yml}',
     'stylelint.config.{cjs,mjs,js}',
 ];
-const findPluginDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json')
+const findPluginDependencies = async (configFilePath, options) => {
+    const { manifest, isProduction } = options;
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
         ? manifest.stylelint
         : await load(configFilePath);
-    if (!config)
+    if (!localConfig)
         return [];
-    const extend = config.extends ? [config.extends].flat().filter(extend => !isInternal(extend)) : [];
-    const plugins = config.plugins ? [config.plugins].flat().filter(plugin => !isInternal(plugin)) : [];
+    const extend = localConfig.extends ? [localConfig.extends].flat().filter(extend => !isInternal(extend)) : [];
+    const plugins = localConfig.plugins ? [localConfig.plugins].flat().filter(plugin => !isInternal(plugin)) : [];
     return [...extend, ...plugins];
 };
 export const findDependencies = timerify(findPluginDependencies);

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

@@ -1,7 +1,8 @@
-import type { IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
 export declare const NAME = "Svelte";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const ENTRY_FILE_PATTERNS: string[];
 export declare const PRODUCTION_ENTRY_FILE_PATTERNS: string[];
 export declare const PROJECT_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/svelte/index.js

@@ -1,4 +1,6 @@
+import { timerify } from '../../util/Performance.js';
 import { hasDependency } from '../../util/plugin.js';
+import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
 export const NAME = 'Svelte';
 export const ENABLERS = ['svelte'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
@@ -7,3 +9,7 @@ export const PRODUCTION_ENTRY_FILE_PATTERNS = [
     'src/routes/**/+{page,server,page.server,error,layout,layout.server}{,@*}.{js,ts,svelte}',
 ];
 export const PROJECT_FILE_PATTERNS = ['src/**/*.{js,ts,svelte}'];
+const findSvelteDependencies = async () => {
+    return [...PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern), ...ENTRY_FILE_PATTERNS.map(toEntryPattern)];
+};
+export const findDependencies = timerify(findSvelteDependencies);

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

@@ -0,0 +1,6 @@
+import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+export declare const NAME = "tsup";
+export declare const ENABLERS: string[];
+export declare const isEnabled: IsPluginEnabledCallback;
+export declare const CONFIG_FILE_PATTERNS: string[];
+export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/tsup/index.js

@@ -0,0 +1,23 @@
+import { timerify } from '../../util/Performance.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
+export const NAME = 'tsup';
+export const ENABLERS = ['tsup'];
+export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
+export const CONFIG_FILE_PATTERNS = ['tsup.config.js'];
+const findTsupDependencies = async (configFilePath) => {
+    let localConfig = await load(configFilePath);
+    if (typeof localConfig === 'function')
+        localConfig = await localConfig({});
+    if (!localConfig)
+        return [];
+    const entryPatterns = [localConfig].flat().flatMap(config => {
+        if (!config.entry)
+            return [];
+        if (Array.isArray(config.entry))
+            return config.entry.map(toEntryPattern);
+        return Object.values(config.entry).map(toEntryPattern);
+    });
+    return entryPatterns;
+};
+export const findDependencies = timerify(findTsupDependencies);

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

@@ -0,0 +1,7 @@
+type Entry = string[] | Record<string, string>;
+type Options = {
+    entry?: Entry;
+};
+type MaybePromise<T> = T | Promise<T>;
+export type TsupConfig = Options | Options[] | ((overrideOptions: Options) => MaybePromise<Options | Options[]>);
+export {};

package/dist/plugins/tsup/types.js

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

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

@@ -1,6 +1,7 @@
 import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
 export declare const NAME = "TypeDoc";
 export declare const ENABLERS: string[];
+export declare const PACKAGE_JSON_PATH = "typedocOptions";
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/typedoc/index.js

@@ -2,6 +2,7 @@ import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 export const NAME = 'TypeDoc';
 export const ENABLERS = ['typedoc'];
+export const PACKAGE_JSON_PATH = 'typedocOptions';
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = [
     'typedoc.{js,cjs,json,jsonc}',
@@ -11,12 +12,15 @@ export const CONFIG_FILE_PATTERNS = [
     'package.json',
     'tsconfig.json',
 ];
-const findTypeDocDependencies = async (configFilePath, { manifest }) => {
-    const config = configFilePath.endsWith('package.json')
-        ? manifest.typedocOptions
+const findTypeDocDependencies = async (configFilePath, options) => {
+    const { manifest, isProduction } = options;
+    if (isProduction)
+        return [];
+    const localConfig = configFilePath.endsWith('package.json')
+        ? manifest[PACKAGE_JSON_PATH]
         : configFilePath.endsWith('tsconfig.json')
             ? (await load(configFilePath)).typedocOptions
             : await load(configFilePath);
-    return config?.plugin ?? [];
+    return localConfig?.plugin ?? [];
 };
 export const findDependencies = timerify(findTypeDocDependencies);

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

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

package/dist/plugins/typescript/index.js

@@ -8,31 +8,36 @@ export const ENABLERS = ['typescript'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 export const CONFIG_FILE_PATTERNS = ['tsconfig.json', 'tsconfig.*.json'];
 const resolveExtensibleConfig = async (configFilePath) => {
-    const config = await load(configFilePath);
-    config.extends = config.extends ? [config.extends].flat() : [];
-    if (config?.extends) {
-        for (const extend of [config.extends].flat()) {
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return;
+    localConfig.extends = localConfig.extends ? [localConfig.extends].flat() : [];
+    if (localConfig?.extends) {
+        for (const extend of [localConfig.extends].flat()) {
             if (isInternal(extend)) {
                 const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
                 const presetConfig = await resolveExtensibleConfig(presetConfigPath);
-                config.extends.push(...(presetConfig.extends ? [presetConfig.extends].flat() : []));
+                localConfig.extends.push(...(presetConfig?.extends ? [presetConfig.extends].flat() : []));
             }
         }
     }
-    return config;
+    return localConfig;
 };
-export const findTypeScriptDependencies = async (configFilePath) => {
+export const findTypeScriptDependencies = async (configFilePath, options) => {
+    const { isProduction } = options;
     const { compilerOptions } = await loadTSConfig(configFilePath);
-    const config = await resolveExtensibleConfig(configFilePath);
-    if (!compilerOptions || !config)
+    const localConfig = await resolveExtensibleConfig(configFilePath);
+    if (!compilerOptions || !localConfig)
         return [];
-    const extend = config.extends ? [config.extends].flat().filter(extend => !isInternal(extend)) : [];
+    const jsx = compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : [];
+    if (isProduction)
+        return [...jsx];
+    const extend = localConfig.extends ? [localConfig.extends].flat().filter(extend => !isInternal(extend)) : [];
     const types = compilerOptions.types ?? [];
     const plugins = Array.isArray(compilerOptions?.plugins)
         ? compilerOptions.plugins.map(plugin => (typeof plugin === 'object' && 'name' in plugin ? plugin.name : ''))
         : [];
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
-    const jsx = compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : [];
     return compact([...extend, ...types, ...plugins, ...importHelpers, ...jsx]);
 };
 export const findDependencies = timerify(findTypeScriptDependencies);

package/dist/plugins/vite/index.js

@@ -1,12 +1,14 @@
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
-import { findVitestDeps } from '../vitest/index.js';
+import { findVitestDependencies } from '../vitest/index.js';
 export const NAME = 'Vite';
 export const ENABLERS = ['vite'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['vite.config.{js,ts}'];
-const findViteDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    return findVitestDeps(config);
+export const CONFIG_FILE_PATTERNS = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
+const findViteDependencies = async (configFilePath, options) => {
+    const localConfig = await load(configFilePath);
+    if (!localConfig)
+        return [];
+    return findVitestDependencies(configFilePath, localConfig, options);
 };
 export const findDependencies = timerify(findViteDependencies);

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

@@ -1,6 +1,6 @@
-import type { VitestConfig } from './types.js';
+import type { ViteConfig } from './types.js';
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 export declare const getEnvPackageName: (env: VitestEnvironment) => any;
-export declare const getExternalReporters: (reporters?: VitestConfig['test']['reporters']) => unknown[];
+export declare const getExternalReporters: (reporters?: ViteConfig['test']['reporters']) => unknown[];
 export {};

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

@@ -1,9 +1,9 @@
-import type { VitestConfig } from './types.js';
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ViteConfigOrFn } from './types.js';
+import type { IsPluginEnabledCallback, GenericPluginCallback, GenericPluginCallbackOptions } from '../../types/plugins.js';
 export declare const NAME = "Vitest";
 export declare const ENABLERS: string[];
 export declare const isEnabled: IsPluginEnabledCallback;
 export declare const CONFIG_FILE_PATTERNS: string[];
-export declare const ENTRY_FILE_PATTERNS: never[];
-export declare const findVitestDeps: (config: VitestConfig) => any[];
+export declare const ENTRY_FILE_PATTERNS: string[];
+export declare const findVitestDependencies: (configFilePath: string, localConfig: ViteConfigOrFn, options: GenericPluginCallbackOptions) => Promise<any[]>;
 export declare const findDependencies: GenericPluginCallback;

package/dist/plugins/vitest/index.js

@@ -1,37 +1,66 @@
 import { compact } from '../../util/array.js';
+import { dirname, isAbsolute, join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
+import { hasDependency, load, tryResolve } from '../../util/plugin.js';
+import { toEntryPattern } from '../../util/protocols.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
 export const NAME = 'Vitest';
 export const ENABLERS = ['vitest'];
 export const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-export const CONFIG_FILE_PATTERNS = ['vitest.config.ts', 'vitest.{workspace,projects}.{ts,js,json}'];
-export const ENTRY_FILE_PATTERNS = [];
-export const findVitestDeps = (config) => {
-    if (!config || !config.test)
-        return [];
-    const cfg = config.test;
-    const environments = cfg.environment ? [getEnvPackageName(cfg.environment)] : [];
-    const reporters = getExternalReporters(cfg.reporters);
-    const coverage = cfg.coverage ? [`@vitest/coverage-${cfg.coverage.provider ?? 'v8'}`] : [];
-    const setupFiles = cfg.setupFiles ? [cfg.setupFiles].flat() : [];
-    const globalSetup = cfg.globalSetup ? [cfg.globalSetup].flat() : [];
-    return compact([...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup]);
+export const CONFIG_FILE_PATTERNS = [
+    'vitest.config.{js,mjs,ts,cjs,mts,cts}',
+    'vitest.{workspace,projects}.{ts,js,json}',
+];
+export const ENTRY_FILE_PATTERNS = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
+const resolveEntry = (containingFilePath, specifier) => {
+    const dir = dirname(containingFilePath);
+    const resolvedPath = isAbsolute(specifier) ? specifier : tryResolve(join(dir, specifier), containingFilePath);
+    if (resolvedPath)
+        return toEntryPattern(relative(dir, resolvedPath));
+    return specifier;
+};
+const findConfigDependencies = (configFilePath, localConfig, options) => {
+    const { isProduction, config } = options;
+    const testConfig = localConfig.test;
+    const entryPatterns = (config?.entry ?? testConfig?.include ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
+    if (!testConfig || isProduction)
+        return entryPatterns;
+    const environments = testConfig.environment ? [getEnvPackageName(testConfig.environment)] : [];
+    const reporters = getExternalReporters(testConfig.reporters);
+    const coverage = testConfig.coverage && testConfig.coverage.enabled !== false
+        ? [`@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));
+    return [...entryPatterns, ...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
 };
-const findVitestWorkspaceDeps = (config) => {
-    let deps = [];
-    for (const cfg of config) {
-        if (typeof cfg === 'string')
-            continue;
-        deps = [...deps, ...findVitestDeps(cfg)];
+export const findVitestDependencies = async (configFilePath, localConfig, options) => {
+    if (!localConfig)
+        return [];
+    if (typeof localConfig === 'function') {
+        const dependencies = new Set();
+        for (const command of ['dev', 'serve', 'build']) {
+            for (const mode of ['development', 'production']) {
+                const config = await localConfig({ command, mode, ssrBuild: undefined });
+                findConfigDependencies(configFilePath, config, options).forEach(dependency => dependencies.add(dependency));
+            }
+        }
+        return Array.from(dependencies);
     }
-    return compact(deps);
+    const entry = localConfig.build?.lib?.entry ?? [];
+    const dependencies = (typeof entry === 'string' ? [entry] : Object.values(entry)).map(specifier => resolveEntry(configFilePath, specifier));
+    if (!localConfig.test)
+        return dependencies;
+    return [...dependencies, ...findConfigDependencies(configFilePath, localConfig, options)];
 };
-const findVitestDependencies = async (configFilePath) => {
-    const config = await load(configFilePath);
-    if (Array.isArray(config)) {
-        return findVitestWorkspaceDeps(config);
+const findVitestWorkspaceDependencies = async (configFilePath, options) => {
+    const localConfig = await load(configFilePath);
+    const dependencies = new Set();
+    for (const config of [localConfig].flat()) {
+        if (config && typeof config !== 'string') {
+            (await findVitestDependencies(configFilePath, config, options)).forEach(dependency => dependencies.add(dependency));
+        }
     }
-    return findVitestDeps(config);
+    return compact(dependencies);
 };
-export const findDependencies = timerify(findVitestDependencies);
+export const findDependencies = timerify(findVitestWorkspaceDependencies);

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

@@ -1,6 +1,8 @@
-export interface VitestConfig {
+interface VitestConfig {
     test: {
+        include: string[];
         coverage?: {
+            enabled?: boolean;
             provider: string;
         };
         environment?: string;
@@ -9,4 +11,23 @@ export interface VitestConfig {
         setupFiles?: string | string[];
     };
 }
-export type VitestWorkspaceConfig = (string | VitestConfig)[];
+export interface ViteConfig extends VitestConfig {
+    plugins?: unknown[];
+    build?: {
+        lib?: {
+            entry: string | string[] | {
+                [entryAlias: string]: string;
+            };
+        };
+    };
+}
+export type COMMAND = 'dev' | 'serve' | 'build';
+export type MODE = 'development' | 'production';
+interface Options {
+    command: COMMAND;
+    mode: MODE;
+    ssrBuild?: boolean | undefined;
+}
+export type ViteConfigOrFn = ViteConfig | ((options: Options) => ViteConfig) | ((options: Options) => Promise<ViteConfig>);
+export type VitestWorkspaceConfig = (string | ViteConfig)[];
+export {};