knip 5.1.2 → 5.1.3

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

@@ -1,9 +1,8 @@
-import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    ENTRY_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    entry: string[];
 };
 export default _default;

package/dist/plugins/tailwind/index.js

@@ -1,17 +1,11 @@
-import { hasDependency } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
-const NAME = 'Tailwind';
-const ENABLERS = ['tailwindcss'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const ENTRY_FILE_PATTERNS = ['tailwind.config.{js,cjs,mjs,ts}'];
-const findDependencies = async (configFilePath, options) => {
-    const { config } = options;
-    return config.entry ? config.entry.map(toEntryPattern) : ENTRY_FILE_PATTERNS.map(toEntryPattern);
-};
+import { hasDependency } from '#p/util/plugin.js';
+const title = 'Tailwind';
+const enablers = ['tailwindcss'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const entry = ['tailwind.config.{js,cjs,mjs,ts}'];
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    ENTRY_FILE_PATTERNS,
-    findDependencies,
+    entry,
 };

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

@@ -1,9 +1,10 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { TsupConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "tsup";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<TsupConfig>;
 };
 export default _default;

package/dist/plugins/tsup/index.js

@@ -1,19 +1,13 @@
-import { basename } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
-const NAME = 'tsup';
-const ENABLERS = ['tsup'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['tsup.config.{js,ts,cjs,json}', 'package.json'];
-const findTsupDependencies = async (configFilePath, options) => {
-    const { manifest } = options;
-    let localConfig = basename(configFilePath) === 'package.json' ? manifest.tsup : await load(configFilePath);
-    if (typeof localConfig === 'function')
-        localConfig = await localConfig({});
-    if (!localConfig)
-        return [];
-    const entryPatterns = [localConfig]
+import { hasDependency } from '#p/util/plugin.js';
+import { toEntryPattern } from '#p/util/protocols.js';
+const title = 'tsup';
+const enablers = ['tsup'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['tsup.config.{js,ts,cjs,json}', 'package.json'];
+const resolveConfig = async (config) => {
+    if (typeof config === 'function')
+        config = await config({});
+    const entryPatterns = [config]
         .flat()
         .flatMap(config => {
         if (!config.entry)
@@ -26,11 +20,10 @@ const findTsupDependencies = async (configFilePath, options) => {
         .map(toEntryPattern);
     return entryPatterns;
 };
-const findDependencies = timerify(findTsupDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };

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

@@ -1,10 +1,13 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+import type { TypeDocConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    PACKAGE_JSON_PATH: string;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "TypeDoc";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly packageJsonPath: "typedocOptions";
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<TypeDocConfig | {
+        typedocOptions: TypeDocConfig;
+    }>;
 };
 export default _default;

package/dist/plugins/typedoc/index.js

@@ -1,11 +1,9 @@
-import { basename } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-const NAME = 'TypeDoc';
-const ENABLERS = ['typedoc'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const PACKAGE_JSON_PATH = 'typedocOptions';
-const CONFIG_FILE_PATTERNS = [
+import { hasDependency } from '#p/util/plugin.js';
+const title = 'TypeDoc';
+const enablers = ['typedoc'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const packageJsonPath = 'typedocOptions';
+const config = [
     'typedoc.{js,cjs,json,jsonc}',
     'typedoc.config.{js,cjs}',
     '.config/typedoc.{js,cjs,json,jsonc}',
@@ -13,23 +11,15 @@ const CONFIG_FILE_PATTERNS = [
     'package.json',
     'tsconfig.json',
 ];
-const findTypeDocDependencies = async (configFilePath, options) => {
-    const { manifest, isProduction } = options;
-    if (isProduction)
-        return [];
-    const localConfig = basename(configFilePath) === 'package.json'
-        ? manifest[PACKAGE_JSON_PATH]
-        : basename(configFilePath) === 'tsconfig.json'
-            ? (await load(configFilePath)).typedocOptions
-            : await load(configFilePath);
-    return localConfig?.plugin ?? [];
+const resolveConfig = config => {
+    config = 'typedocOptions' in config ? config.typedocOptions : config;
+    return config?.plugin ?? [];
 };
-const findDependencies = timerify(findTypeDocDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PACKAGE_JSON_PATH,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    packageJsonPath,
+    config,
+    resolveConfig,
 };

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

@@ -1,10 +1,11 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
-export declare const findTypeScriptDependencies: GenericPluginCallback;
+import type { IsPluginEnabled, ResolveConfig } from '#p/types/plugins.js';
+export declare const resolveConfig: ResolveConfig;
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveConfig: ResolveConfig;
 };
 export default _default;

package/dist/plugins/typescript/index.js

@@ -1,33 +1,39 @@
-import { compact } from '../../util/array.js';
-import { dirname, isInternal, toAbsolute } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, loadJSON } from '../../util/plugin.js';
-import { loadTSConfig } from '../../util/tsconfig-loader.js';
-const NAME = 'TypeScript';
-const ENABLERS = ['typescript'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['tsconfig.json', 'tsconfig.*.json'];
+import { compact } from '#p/util/array.js';
+import { dirname, isInternal, join, toAbsolute } from '#p/util/path.js';
+import { hasDependency, loadJSON } from '#p/util/plugin.js';
+import { loadTSConfig } from '#p/util/tsconfig-loader.js';
+const title = 'TypeScript';
+const enablers = ['typescript'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['tsconfig.json', 'tsconfig.*.json'];
+const production = [];
 const resolveExtensibleConfig = async (configFilePath) => {
     const filePath = configFilePath.replace(/(\.json)?$/, '.json');
     const localConfig = await loadJSON(filePath);
     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);
-                localConfig.extends.push(...(presetConfig?.extends ? [presetConfig.extends].flat() : []));
-            }
+    const extends_ = (localConfig.extends = localConfig.extends ? [localConfig.extends].flat() : []);
+    for (const extend of extends_) {
+        if (isInternal(extend)) {
+            const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
+            const presetConfig = await resolveExtensibleConfig(presetConfigPath);
+            localConfig.extends.push(...(presetConfig?.extends ? [presetConfig.extends].flat() : []));
         }
     }
     return localConfig;
 };
-export const findTypeScriptDependencies = async (configFilePath, options) => {
-    const { isProduction } = options;
+export const resolveConfig = async (localConfig, options) => {
+    const { isProduction, configFileDir, configFileName } = options;
+    const configFilePath = join(configFileDir, configFileName);
     const { compilerOptions } = await loadTSConfig(configFilePath);
-    const localConfig = await resolveExtensibleConfig(configFilePath);
+    const extends_ = (localConfig.extends = localConfig.extends ? [localConfig.extends].flat() : []);
+    for (const extend of extends_) {
+        if (isInternal(extend)) {
+            const presetConfigPath = toAbsolute(extend, dirname(configFilePath));
+            const presetConfig = await resolveExtensibleConfig(presetConfigPath);
+            localConfig.extends.push(...(presetConfig?.extends ? [presetConfig.extends].flat() : []));
+        }
+    }
     if (!compilerOptions || !localConfig)
         return [];
     const jsx = compilerOptions?.jsxImportSource ? [compilerOptions.jsxImportSource] : [];
@@ -41,11 +47,11 @@ export const findTypeScriptDependencies = async (configFilePath, options) => {
     const importHelpers = compilerOptions?.importHelpers ? ['tslib'] : [];
     return compact([...extend, ...types, ...plugins, ...importHelpers, ...jsx]);
 };
-const findDependencies = timerify(findTypeScriptDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    production,
+    resolveConfig,
 };

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

@@ -1,9 +1,10 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { UnbuildConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "unbuild";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<UnbuildConfig>;
 };
 export default _default;

package/dist/plugins/unbuild/index.js

@@ -1,25 +1,20 @@
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
-const NAME = 'unbuild';
-const ENABLERS = ['unbuild'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['build.config.{js,cjs,mjs,ts,mts,cts,json}'];
-const findUnbuildDependencies = async (configFilePath) => {
-    const localConfig = await load(configFilePath);
-    if (!localConfig)
-        return [];
-    return [localConfig]
+import { hasDependency } from '#p/util/plugin.js';
+import { toEntryPattern } from '#p/util/protocols.js';
+const title = 'unbuild';
+const enablers = ['unbuild'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['build.config.{js,cjs,mjs,ts,mts,cts,json}'];
+const resolveConfig = config => {
+    return [config]
         .flat()
         .map(obj => obj.entries)
         .flatMap(entries => entries?.map(entry => (typeof entry === 'string' ? entry : entry.input)) ?? [])
         .map(toEntryPattern);
 };
-const findDependencies = timerify(findUnbuildDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    resolveConfig,
 };

package/dist/plugins/vercel-og/index.d.ts

@@ -1,9 +1,8 @@
-import type { GenericPluginCallback, IsPluginEnabledCallback } from '../../types/plugins.js';
+import type { IsPluginEnabled } from '#p/types/plugins.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    PRODUCTION_ENTRY_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    production: string[];
 };
 export default _default;

package/dist/plugins/vercel-og/index.js

@@ -1,22 +1,14 @@
-import { hasDependency } from '../../util/plugin.js';
-import { toProductionEntryPattern } from '../../util/protocols.js';
-const NAME = 'Vercel OG';
-const ENABLERS = ['next', '@vercel/og'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const PRODUCTION_ENTRY_FILE_PATTERNS = [
+import { hasDependency } from '#p/util/plugin.js';
+const title = 'Vercel OG';
+const enablers = ['next', '@vercel/og'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const production = [
     '{src/,}pages/api/og.{jsx,tsx}',
     '{src/,}app/api/og/route.{jsx,tsx}',
 ];
-const findDependencies = async (configFilePath, options) => {
-    const { config } = options;
-    return config.entry
-        ? config.entry.map(toProductionEntryPattern)
-        : PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
-};
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    PRODUCTION_ENTRY_FILE_PATTERNS,
-    findDependencies,
+    production,
 };

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

@@ -1,10 +1,12 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
-export declare const CONFIG_FILE_PATTERNS: string[];
+import type { IsPluginEnabled } from '#p/types/plugins.js';
+export declare const config: string[];
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    production: string[];
+    resolveEntryPaths: import("#p/types/plugins.js").ResolveEntryPaths<import("#p/plugins/vitest/types.ts").ViteConfigOrFn | import("#p/plugins/vitest/types.ts").VitestWorkspaceConfig>;
+    resolveConfig: import("#p/types/plugins.js").ResolveConfig<import("#p/plugins/vitest/types.ts").ViteConfigOrFn | import("#p/plugins/vitest/types.ts").VitestWorkspaceConfig>;
 };
 export default _default;

package/dist/plugins/vite/index.js

@@ -1,21 +1,16 @@
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load } from '../../util/plugin.js';
-import { findVitestDependencies } from '../vitest/index.js';
-const NAME = 'Vite';
-const ENABLERS = ['vite'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-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);
-};
-const findDependencies = timerify(findViteDependencies);
+import { hasDependency } from '#p/util/plugin.js';
+import { resolveEntryPaths, resolveConfig } from '../vitest/index.js';
+const title = 'Vite';
+const enablers = ['vite'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+export const config = ['vite*.config.{js,mjs,ts,cjs,mts,cts}'];
+const production = [];
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    findDependencies,
+    config,
+    production,
+    resolveEntryPaths,
+    resolveConfig,
 };

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

@@ -1,12 +1,14 @@
-import type { ViteConfigOrFn } from './types.js';
-import type { IsPluginEnabledCallback, GenericPluginCallback, GenericPluginCallbackOptions } from '../../types/plugins.js';
-export declare const findVitestDependencies: (configFilePath: string, localConfig: ViteConfigOrFn, options: GenericPluginCallbackOptions) => Promise<any[]>;
+import type { IsPluginEnabled, ResolveEntryPaths, ResolveConfig } from '#p/types/plugins.js';
+import type { ViteConfigOrFn, VitestWorkspaceConfig } from './types.js';
+export declare const resolveEntryPaths: ResolveEntryPaths<ViteConfigOrFn | VitestWorkspaceConfig>;
+export declare const resolveConfig: ResolveConfig<ViteConfigOrFn | VitestWorkspaceConfig>;
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    ENTRY_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    title: string;
+    enablers: string[];
+    isEnabled: IsPluginEnabled;
+    config: string[];
+    entry: string[];
+    resolveEntryPaths: ResolveEntryPaths<ViteConfigOrFn | VitestWorkspaceConfig>;
+    resolveConfig: ResolveConfig<ViteConfigOrFn | VitestWorkspaceConfig>;
 };
 export default _default;

package/dist/plugins/vitest/index.js

@@ -1,19 +1,19 @@
-import { compact } from '../../util/array.js';
-import { dirname, isAbsolute, join, relative } from '../../util/path.js';
-import { timerify } from '../../util/Performance.js';
-import { hasDependency, load, tryResolve } from '../../util/plugin.js';
-import { toEntryPattern } from '../../util/protocols.js';
+import { isAbsolute, join, relative } from '#p/util/path.js';
+import { hasDependency, tryResolve } from '#p/util/plugin.js';
+import { toEntryPattern } from '#p/util/protocols.js';
 import { getEnvPackageName, getExternalReporters } from './helpers.js';
-const NAME = 'Vitest';
-const ENABLERS = ['vitest'];
-const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const CONFIG_FILE_PATTERNS = ['vitest*.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{ts,js,json}'];
-const ENTRY_FILE_PATTERNS = ['**/*.{test,test-d,spec}.?(c|m)[jt]s?(x)'];
-const resolveEntry = (containingFilePath, specifier) => {
-    const dir = dirname(containingFilePath);
-    const resolvedPath = isAbsolute(specifier) ? specifier : tryResolve(join(dir, specifier), containingFilePath);
+const title = 'Vitest';
+const enablers = ['vitest'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['vitest*.config.{js,mjs,ts,cjs,mts,cts}', 'vitest.{workspace,projects}.{ts,js,json}'];
+const entry = ['**/*.{test,test-d,spec}.?(c|m)[jt]s?(x)'];
+const resolveEntry = (options, specifier) => {
+    const { configFileDir, configFileName } = options;
+    const resolvedPath = isAbsolute(specifier)
+        ? specifier
+        : tryResolve(join(configFileDir, specifier), join(configFileDir, configFileName));
     if (resolvedPath)
-        return toEntryPattern(relative(dir, resolvedPath));
+        return toEntryPattern(relative(configFileDir, resolvedPath));
     return specifier;
 };
 const isVitestCoverageCommand = /vitest(.+)--coverage(?:\.enabled(?:=true)?)?/;
@@ -22,55 +22,68 @@ const hasScriptWithCoverage = (scripts) => scripts
         return isVitestCoverageCommand.test(script);
     })
     : false;
-const findConfigDependencies = (configFilePath, localConfig, options) => {
-    const { isProduction, config, manifest } = options;
+const findConfigDependencies = (localConfig, options) => {
+    const { manifest } = options;
     const testConfig = localConfig.test;
-    const entryPatterns = (config?.entry ?? testConfig?.include ?? ENTRY_FILE_PATTERNS).map(toEntryPattern);
-    if (!testConfig || isProduction)
-        return entryPatterns;
+    if (!testConfig)
+        return [];
     const environments = testConfig.environment ? [getEnvPackageName(testConfig.environment)] : [];
     const reporters = getExternalReporters(testConfig.reporters);
     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));
-    return [...entryPatterns, ...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
+    const setupFiles = [testConfig.setupFiles ?? []].flat().map(v => resolveEntry(options, v));
+    const globalSetup = [testConfig.globalSetup ?? []].flat().map(v => resolveEntry(options, v));
+    return [...environments, ...reporters, ...coverage, ...setupFiles, ...globalSetup];
 };
-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));
+const getConfigs = async (localConfig) => {
+    const configs = [];
+    for (const config of [localConfig].flat()) {
+        if (config && typeof config !== 'string') {
+            if (typeof config === 'function') {
+                for (const command of ['dev', 'serve', 'build']) {
+                    for (const mode of ['development', 'production']) {
+                        const cfg = await config({ command, mode, ssrBuild: undefined });
+                        configs.push(cfg);
+                    }
+                }
+            }
+            else {
+                configs.push(config);
             }
         }
-        return Array.from(dependencies);
     }
-    const entry = localConfig.build?.lib?.entry ?? [];
-    const dependencies = (typeof entry === 'string' ? [entry] : Object.values(entry)).map(specifier => resolveEntry(configFilePath, specifier));
-    if (!options.enabledPlugins.includes('vitest'))
-        return dependencies;
-    return compact([...dependencies, ...findConfigDependencies(configFilePath, localConfig, options)]);
+    return configs;
 };
-const findVitestWorkspaceDependencies = async (configFilePath, options) => {
-    const localConfig = await load(configFilePath);
+export const resolveEntryPaths = async (localConfig, options) => {
     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));
+    const configs = await getConfigs(localConfig);
+    for (const cfg of configs) {
+        if (cfg.test?.include) {
+            cfg.test.include.forEach(dependency => dependencies.add(dependency));
+        }
+        else {
+            (options.config.entry ?? entry).forEach(dependency => dependencies.add(dependency));
         }
     }
-    return compact(dependencies);
+    return Array.from(dependencies).map(toEntryPattern);
+};
+export const resolveConfig = async (localConfig, options) => {
+    const dependencies = new Set();
+    const configs = await getConfigs(localConfig);
+    for (const cfg of configs) {
+        findConfigDependencies(cfg, options).forEach(dependency => dependencies.add(dependency));
+        const entry = cfg.build?.lib?.entry ?? [];
+        const deps = (typeof entry === 'string' ? [entry] : Object.values(entry)).map(specifier => resolveEntry(options, specifier));
+        deps.forEach(dependency => dependencies.add(dependency));
+    }
+    return Array.from(dependencies);
 };
-const findDependencies = timerify(findVitestWorkspaceDependencies);
 export default {
-    NAME,
-    ENABLERS,
+    title,
+    enablers,
     isEnabled,
-    CONFIG_FILE_PATTERNS,
-    ENTRY_FILE_PATTERNS,
-    findDependencies,
+    config,
+    entry,
+    resolveEntryPaths,
+    resolveConfig,
 };

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

@@ -1,9 +1,10 @@
-import type { IsPluginEnabledCallback, GenericPluginCallback } from '../../types/plugins.js';
+import type { ResolveConfig, IsPluginEnabled } from '#p/types/plugins.js';
+import type { VueConfig } from './types.js';
 declare const _default: {
-    NAME: string;
-    ENABLERS: string[];
-    isEnabled: IsPluginEnabledCallback;
-    CONFIG_FILE_PATTERNS: string[];
-    findDependencies: GenericPluginCallback;
+    readonly title: "Vue";
+    readonly enablers: string[];
+    readonly isEnabled: IsPluginEnabled;
+    readonly config: string[];
+    readonly resolveConfig: ResolveConfig<VueConfig>;
 };
 export default _default;