knip 5.52.0 → 5.54.0

package/dist/ConfigurationChief.d.ts

@@ -150,6 +150,7 @@ export declare class ConfigurationChief {
         stryker?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        svgo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         travis?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/IssueFixer.d.ts

@@ -18,7 +18,7 @@ export declare class IssueFixer {
     constructor({ isEnabled, cwd, fixTypes, isRemoveFiles }: Fixer);
     addUnusedTypeNode(filePath: string, fixes: Fixes | undefined): void;
     addUnusedExportNode(filePath: string, fixes: Fixes | undefined): void;
-    fixIssues(issues: Issues): Promise<void>;
+    fixIssues(issues: Issues): Promise<Set<string>>;
     private markExportFixed;
     private removeUnusedFiles;
     private removeUnusedExports;

package/dist/IssueFixer.js

@@ -38,9 +38,13 @@ export class IssueFixer {
             this.unusedExportNodes.set(filePath, new Set(fixes));
     }
     async fixIssues(issues) {
+        const touchedFiles = new Set();
         await this.removeUnusedFiles(issues);
-        await this.removeUnusedExports(issues);
-        await this.removeUnusedDependencies(issues);
+        for (const filePath of await this.removeUnusedExports(issues))
+            touchedFiles.add(filePath);
+        for (const filePath of await this.removeUnusedDependencies(issues))
+            touchedFiles.add(filePath);
+        return touchedFiles;
     }
     markExportFixed(issues, filePath) {
         const relPath = relative(filePath);
@@ -63,6 +67,7 @@ export class IssueFixer {
         }
     }
     async removeUnusedExports(issues) {
+        const touchedFiles = new Set();
         const filePaths = new Set([...this.unusedTypeNodes.keys(), ...this.unusedExportNodes.keys()]);
         for (const filePath of filePaths) {
             const types = (this.isFixUnusedTypes && this.unusedTypeNodes.get(filePath)) || [];
@@ -71,13 +76,16 @@ export class IssueFixer {
             if (exportPositions.length > 0) {
                 const sourceFileText = exportPositions.reduce((text, [start, end, flags]) => removeExport({ text, start, end, flags }), await readFile(filePath, 'utf-8'));
                 await writeFile(filePath, sourceFileText);
+                touchedFiles.add(filePath);
                 this.markExportFixed(issues, filePath);
             }
         }
+        return touchedFiles;
     }
     async removeUnusedDependencies(issues) {
+        const touchedFiles = new Set();
         if (!this.isFixDependencies)
-            return;
+            return touchedFiles;
         const filePaths = new Set([...Object.keys(issues.dependencies), ...Object.keys(issues.devDependencies)]);
         for (const filePath of filePaths) {
             const absFilePath = join(this.cwd, filePath);
@@ -99,6 +107,8 @@ export class IssueFixer {
                 }
             }
             await save(absFilePath, pkg);
+            touchedFiles.add(filePath);
         }
+        return touchedFiles;
     }
 }

package/dist/PrincipalFactory.js

@@ -1,25 +1,11 @@
 import ts from 'typescript';
 import { ProjectPrincipal } from './ProjectPrincipal.js';
 import { debugLog } from './util/debug.js';
-import { toAbsolute, toRelative } from './util/path.js';
-const mapToAbsolutePaths = (paths, cwd) => Object.keys(paths).reduce((result, key) => {
-    result[key] = paths[key].map(entry => toAbsolute(entry, cwd));
-    return result;
-}, {});
-const mergePaths = (cwd, compilerOptions, paths = {}) => {
-    const basePath = typeof compilerOptions.pathsBasePath === 'string' ? compilerOptions.pathsBasePath : cwd;
-    const compilerPaths = !compilerOptions.baseUrl && compilerOptions.paths
-        ? mapToAbsolutePaths(compilerOptions.paths, basePath)
-        : compilerOptions.paths;
-    const extraPaths = mapToAbsolutePaths(paths, cwd);
-    compilerOptions.paths = { ...compilerPaths, ...extraPaths };
-    return compilerOptions;
-};
+import { toRelative } from './util/path.js';
 export class PrincipalFactory {
     principals = new Set();
     createPrincipal(options) {
-        const { cwd, compilerOptions, isFile, paths, pkgName, isIsolateWorkspaces, compilers } = options;
-        options.compilerOptions = mergePaths(cwd, compilerOptions, paths);
+        const { cwd, compilerOptions, isFile, pkgName, isIsolateWorkspaces, compilers } = options;
         if (isFile && compilerOptions.module !== ts.ModuleKind.CommonJS)
             compilerOptions.moduleResolution ??= ts.ModuleResolutionKind.Bundler;
         const principal = this.findReusablePrincipal(compilerOptions);
@@ -48,7 +34,7 @@ export class PrincipalFactory {
         principal.principal.compilerOptions.moduleResolution ??= compilerOptions.moduleResolution;
         for (const p of Object.keys(paths ?? {}))
             principal.pathKeys.add(p);
-        principal.principal.addPaths(paths);
+        principal.principal.addPaths(paths, cwd);
         principal.principal.addCompilers(compilers);
         principal.wsDirs.add(cwd);
         principal.pkgNames.add(pkgName);

package/dist/ProjectPrincipal.d.ts

@@ -3,7 +3,7 @@ import { CacheConsultant } from './CacheConsultant.js';
 import type { AsyncCompilers, SyncCompilers } from './compilers/types.js';
 import type { GetImportsAndExportsOptions } from './types/config.js';
 import type { Export, ExportMember, FileNode, ModuleGraph } from './types/module-graph.js';
-import type { PrincipalOptions } from './types/project.js';
+import type { Paths, PrincipalOptions } from './types/project.js';
 import { SourceFileManager } from './typescript/SourceFileManager.js';
 import type { ResolveModuleNames } from './typescript/resolve-module-names.js';
 import type { ToSourceFilePath } from './util/to-source-path.js';
@@ -32,7 +32,7 @@ export declare class ProjectPrincipal {
     findReferences?: ts.LanguageService['findReferences'];
     constructor({ compilerOptions, cwd, compilers, isSkipLibs, isWatch, pkgName, toSourceFilePath, isCache, cacheLocation, }: PrincipalOptions);
     init(): void;
-    addPaths(paths: ts.CompilerOptions['paths']): void;
+    addPaths(paths: Paths, basePath: string): void;
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
     private createProgram;
     private hasAcceptedExtension;

package/dist/ProjectPrincipal.js

@@ -8,7 +8,7 @@ import { _getImportsAndExports } from './typescript/get-imports-and-exports.js';
 import { timerify } from './util/Performance.js';
 import { compact } from './util/array.js';
 import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpecifier } from './util/modules.js';
-import { dirname, extname, isInNodeModules, join } from './util/path.js';
+import { dirname, extname, isInNodeModules, join, toAbsolute } from './util/path.js';
 const baseCompilerOptions = {
     allowJs: true,
     allowSyntheticDefaultImports: true,
@@ -78,8 +78,19 @@ export class ProjectPrincipal {
         this.backend.resolveModuleNames = resolveModuleNames;
         this.backend.languageServiceHost = languageServiceHost;
     }
-    addPaths(paths) {
-        this.compilerOptions.paths = { ...this.compilerOptions.paths, ...paths };
+    addPaths(paths, basePath) {
+        if (!paths)
+            return;
+        this.compilerOptions.paths ??= {};
+        for (const key in paths) {
+            const prefixes = paths[key].map(prefix => toAbsolute(prefix, basePath));
+            if (key in this.compilerOptions.paths) {
+                this.compilerOptions.paths[key] = compact([...this.compilerOptions.paths[key], ...prefixes]);
+            }
+            else {
+                this.compilerOptions.paths[key] = prefixes;
+            }
+        }
     }
     addCompilers(compilers) {
         this.syncCompilers = new Map([...this.syncCompilers, ...compilers[0]]);

package/dist/WorkspaceWorker.d.ts

@@ -26,7 +26,6 @@ type WorkspaceManagerOptions = {
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
 };
 type CacheItem = {
-    resolveEntryPaths?: Input[];
     resolveConfig?: Input[];
     resolveFromAST?: Input[];
 };

package/dist/WorkspaceWorker.js

@@ -235,7 +235,7 @@ export class WorkspaceWorker {
                 for (const id of config.entry)
                     addInput(toInput(id));
             }
-            else if ((!plugin.resolveEntryPaths && !plugin.resolveFromAST) ||
+            else if ((!plugin.resolveConfig && !plugin.resolveFromAST) ||
                 (configFilePaths.filter(path => basename(path) !== 'package.json').length === 0 &&
                     (!this.configFilesMap.get(wsName)?.get(pluginName) ||
                         this.configFilesMap.get(wsName)?.get(pluginName)?.size === 0))) {
@@ -251,9 +251,6 @@ export class WorkspaceWorker {
                 const fd = isManifest ? undefined : this.cache.getFileDescriptor(configFilePath);
                 if (fd?.meta?.data && !fd.changed) {
                     const data = fd.meta.data;
-                    if (data.resolveEntryPaths)
-                        for (const id of data.resolveEntryPaths)
-                            addInput(id, configFilePath);
                     if (data.resolveConfig)
                         for (const id of data.resolveConfig)
                             addInput(id, configFilePath);
@@ -270,22 +267,10 @@ export class WorkspaceWorker {
                     configFileName: basename(configFilePath),
                 };
                 const cache = {};
-                let loadedConfig;
-                if (plugin.resolveEntryPaths && !seen.get(wsName)?.has(configFilePath)) {
-                    if (!loadedConfig)
-                        loadedConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
-                    if (loadedConfig) {
-                        const inputs = await plugin.resolveEntryPaths(loadedConfig, resolveOpts);
-                        for (const input of inputs)
-                            addInput(input, configFilePath);
-                        cache.resolveEntryPaths = inputs;
-                    }
-                }
                 if (plugin.resolveConfig && !seen.get(wsName)?.has(configFilePath)) {
-                    if (!loadedConfig)
-                        loadedConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
-                    if (loadedConfig) {
-                        const inputs = await plugin.resolveConfig(loadedConfig, resolveOpts);
+                    const localConfig = await loadConfigForPlugin(configFilePath, plugin, resolveOpts, pluginName);
+                    if (localConfig) {
+                        const inputs = await plugin.resolveConfig(localConfig, resolveOpts);
                         for (const input of inputs)
                             addInput(input, configFilePath);
                         cache.resolveConfig = inputs;

package/dist/cli.js

@@ -1,4 +1,3 @@
-import prettyMilliseconds from 'pretty-ms';
 import { main } from './index.js';
 import { perfObserver } from './util/Performance.js';
 import parsedArgValues, { helpText } from './util/cli-arguments.js';
@@ -6,11 +5,12 @@ import { getKnownError, isConfigurationError, isDisplayReason, isKnownError } fr
 import { logError, logWarning } from './util/log.js';
 import { cwd, join, toPosix } from './util/path.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
+import { prettyMilliseconds } from './util/string.js';
 import { splitTags } from './util/tag.js';
 import { isTrace } from './util/trace.js';
 import { version } from './version.js';
 const defaultCacheLocation = join(cwd, 'node_modules', '.cache', 'knip');
-const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'no-config-hints': isDisableConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': treatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
+const { 'allow-remove-files': isRemoveFiles = false, cache: isCache = false, 'cache-location': cacheLocation = defaultCacheLocation, debug: isDebug = false, dependencies: isDependenciesShorthand = false, exclude: excludedIssueTypes = [], 'experimental-tags': experimentalTags = [], exports: isExportsShorthand = false, files: isFilesShorthand = false, fix: isFix = false, format: isFormat = false, 'fix-type': fixTypes = [], help: isHelp, include: includedIssueTypes = [], 'include-entry-exports': isIncludeEntryExports = false, 'include-libs': isIncludeLibs = false, 'isolate-workspaces': isIsolateWorkspaces = false, 'max-issues': maxIssues = '0', 'no-config-hints': isDisableConfigHints = false, 'no-exit-code': noExitCode = false, 'no-gitignore': isNoGitIgnore = false, 'no-progress': isNoProgress = isDebug || isTrace, preprocessor = [], 'preprocessor-options': preprocessorOptions = '', production: isProduction = false, reporter = ['symbols'], 'reporter-options': reporterOptions = '', strict: isStrict = false, tags = [], 'treat-config-hints-as-errors': treatConfigHintsAsErrors = false, tsConfig, version: isVersion, watch: isWatch = false, workspace: rawWorkspaceArg, } = parsedArgValues;
 if (isHelp) {
     console.log(helpText);
     process.exit(0);
@@ -36,6 +36,7 @@ const run = async () => {
             isExportsShorthand,
             isFilesShorthand,
             isFix: isFix || fixTypes.length > 0,
+            isFormat,
             isDisableConfigHints,
             isIncludeEntryExports,
             isIncludeLibs,
@@ -70,12 +71,15 @@ const run = async () => {
         const totalErrorCount = Object.keys(finalData.report)
             .filter(reportGroup => finalData.report[reportGroup] && rules[reportGroup] === 'error')
             .reduce((errorCount, reportGroup) => errorCount + finalData.counters[reportGroup], 0);
-        if (perfObserver.isEnabled) {
+        if (perfObserver.isEnabled)
             await perfObserver.finalize();
-            console.log(`\n${perfObserver.getTable()}`);
-            const mem = perfObserver.getCurrentMemUsageInMb();
+        if (perfObserver.isPerformanceEnabled)
+            console.log(`\n${perfObserver.getPerformanceTable()}`);
+        if (perfObserver.isMemoryEnabled)
+            console.log(`\n${perfObserver.getMemoryTable()}`);
+        if (perfObserver.isEnabled) {
             const duration = perfObserver.getCurrentDurationInMs();
-            console.log('\nTotal running time:', prettyMilliseconds(duration), `(mem: ${mem}MB)`);
+            console.log('\nTotal running time:', prettyMilliseconds(duration));
             perfObserver.reset();
         }
         if (experimentalTags.length > 0) {

package/dist/compilers/index.d.ts

@@ -399,6 +399,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    svgo?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     syncpack?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -915,6 +920,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgo?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/build.js

@@ -2,13 +2,14 @@ import { WorkspaceWorker } from '../WorkspaceWorker.js';
 import { _getInputsFromScripts } from '../binaries/index.js';
 import { getCompilerExtensions, getIncludedCompilers } from '../compilers/index.js';
 import { DEFAULT_EXTENSIONS } from '../constants.js';
+import { perfObserver } from '../util/Performance.js';
 import { debugLog, debugLogArray } from '../util/debug.js';
 import { getReferencedInputsHandler } from '../util/get-referenced-inputs.js';
 import { _glob, negate } from '../util/glob.js';
-import { isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
+import { isAlias, isConfig, isDeferResolveEntry, isDeferResolveProductionEntry, isEntry, isProductionEntry, isProject, toProductionEntry, } from '../util/input.js';
 import { getOrCreateFileNode, updateImportMap } from '../util/module-graph.js';
 import { getEntryPathsFromManifest } from '../util/package-json.js';
-import { dirname, isAbsolute, join, relative } from '../util/path.js';
+import { dirname, isAbsolute, join, relative, toRelative } from '../util/path.js';
 import {} from '../util/tag.js';
 import { augmentWorkspace, getToSourcePathHandler, getToSourcePathsHandler } from '../util/to-source-path.js';
 import { loadTSConfig } from '../util/tsconfig-loader.js';
@@ -28,7 +29,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
     }
     for (const workspace of workspaces) {
         const { name, dir, ancestors, pkgName } = workspace;
-        streamer.cast(`Analyzing workspace ${name}...`);
+        streamer.cast(`Analyzing workspace (${name})...`);
         const manifest = chief.getManifestForWorkspace(name);
         if (!manifest) {
             continue;
@@ -78,7 +79,6 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         }
         const principal = factory.createPrincipal({
             cwd: dir,
-            paths: config.paths,
             isFile,
             compilerOptions,
             compilers,
@@ -90,6 +90,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             isCache,
             cacheLocation,
         });
+        principal.addPaths(config.paths, dir);
         const inputsFromPlugins = await worker.runPlugins();
         for (const id of inputsFromPlugins)
             inputs.add(Object.assign(id, { skipExportsAnalysis: !id.allowIncludeExports }));
@@ -122,6 +123,9 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             else if (isProject(input)) {
                 projectFilePatterns.add(isAbsolute(specifier) ? relative(dir, specifier) : specifier);
             }
+            else if (isAlias(input)) {
+                principal.addPaths({ [input.specifier]: input.prefixes }, input.dir ?? dir);
+            }
             else if (!isConfig(input)) {
                 const ws = (input.containingFilePath && chief.findWorkspaceByFilePath(input.containingFilePath)) || workspace;
                 const resolvedFilePath = getReferencedInternalFilePath(input, ws);
@@ -275,7 +279,7 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
             streamer.cast('Running async compilers...');
             await principal.runAsyncCompilers();
         }
-        streamer.cast('Analyzing source files...');
+        streamer.cast(`Analyzing source files (${toRelative(principal.cwd) || '.'})...`);
         let size = principal.entryPaths.size;
         let round = 0;
         do {
@@ -291,12 +295,13 @@ export async function build({ cacheLocation, chief, collector, cwd, deputy, fact
         for (const filePath of principal.entryPaths)
             entryPaths.add(filePath);
         principal.reconcileCache(graph);
-        if (!isIsolateWorkspaces && isSkipLibs && !isWatch) {
+        if (isIsolateWorkspaces || (isSkipLibs && !isWatch)) {
             factory.deletePrincipal(principal);
             principals[i] = undefined;
         }
+        perfObserver.addMemoryMark(factory.principals.size);
     }
-    if (isIsolateWorkspaces) {
+    if (!isWatch && isSkipLibs && !isIsolateWorkspaces) {
         for (const principal of principals) {
             if (principal)
                 factory.deletePrincipal(principal);

package/dist/index.js

@@ -1,4 +1,5 @@
 import { watch } from 'node:fs';
+import { formatly } from 'formatly';
 import { ConfigurationChief } from './ConfigurationChief.js';
 import { ConsoleStreamer } from './ConsoleStreamer.js';
 import { DependencyDeputy } from './DependencyDeputy.js';
@@ -7,11 +8,11 @@ import { IssueFixer } from './IssueFixer.js';
 import { PrincipalFactory } from './PrincipalFactory.js';
 import { analyze } from './graph/analyze.js';
 import { build } from './graph/build.js';
-import { debugLogObject } from './util/debug.js';
+import { debugLogArray, debugLogObject } from './util/debug.js';
 import { getGitIgnoredHandler } from './util/glob-core.js';
 import { getWatchHandler } from './util/watch.js';
 export const main = async (unresolvedConfiguration) => {
-    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isDisableConfigHints, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
+    const { cacheLocation, cwd, excludedIssueTypes, fixTypes, gitignore, includedIssueTypes, isCache, isDebug, isDependenciesShorthand, isExportsShorthand, isFilesShorthand, isFix, isFormat, isDisableConfigHints, isIncludeEntryExports, isIncludeLibs, isIsolateWorkspaces, isProduction, isRemoveFiles, isShowProgress, isStrict, isWatch, tags, tsConfigFile, workspace, } = unresolvedConfiguration;
     debugLogObject('*', 'Unresolved configuration (from CLI arguments)', unresolvedConfiguration);
     const chief = new ConfigurationChief({ cwd, isProduction, isStrict, isIncludeEntryExports, workspace });
     const deputy = new DependencyDeputy({ isProduction, isStrict });
@@ -101,8 +102,18 @@ export const main = async (unresolvedConfiguration) => {
         });
         watch('.', { recursive: true }, watchHandler);
     }
-    if (isFix)
-        await fixer.fixIssues(issues);
+    if (isFix) {
+        const touchedFiles = await fixer.fixIssues(issues);
+        if (isFormat) {
+            const report = await formatly(Array.from(touchedFiles), { cwd });
+            if (report.ran && report.result.code === 0) {
+                debugLogArray('*', `Formatted files using ${report.formatter.name} (${report.formatter.runner})`, touchedFiles);
+            }
+            else {
+                debugLogObject('*', 'Formatting files failed', report);
+            }
+        }
+    }
     if (!isWatch)
         streamer.clear();
     return {

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { AvaConfig } from './types.js';
 declare const _default: {
     title: string;
@@ -6,7 +6,6 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: ResolveEntryPaths<AvaConfig>;
     resolveConfig: ResolveConfig<AvaConfig>;
 };
 export default _default;

package/dist/plugins/ava/index.js

@@ -16,18 +16,14 @@ const entry = [
     '!**/__tests__/**/__{helper,fixture}?(s)__/**/*',
     '!**/test?(s)/**/{helper,fixture}?(s)/**/*',
 ];
-const resolveEntryPaths = localConfig => {
-    if (typeof localConfig === 'function')
-        localConfig = localConfig();
-    return (localConfig?.files ?? entry).map(id => toEntry(id));
-};
 const resolveConfig = async (localConfig, options) => {
     if (typeof localConfig === 'function')
         localConfig = localConfig();
+    const files = (localConfig?.files ?? entry).map(id => toEntry(id));
     const nodeArgs = localConfig.nodeArguments ?? [];
     const requireArgs = (localConfig.require ?? []).map(require => `--require ${require}`);
     const fakeCommand = `node ${nodeArgs.join(' ')} ${requireArgs.join(' ')}`;
-    return options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true });
+    return files.concat(options.getInputsFromScripts(fakeCommand, { knownBinsOnly: true }));
 };
 export default {
     title,
@@ -35,6 +31,5 @@ export default {
     isEnabled,
     config,
     entry,
-    resolveEntryPaths,
     resolveConfig,
 };

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

@@ -1,4 +1,4 @@
-import type { ResolveEntryPaths } from '../../types/config.js';
+import type { ResolveConfig } from '../../types/config.js';
 import type { PackageJson } from '../../types/package-json.js';
 declare const _default: {
     title: string;
@@ -6,6 +6,6 @@ declare const _default: {
     isEnabled: () => boolean;
     config: string[];
     packageJsonPath: (id: PackageJson) => PackageJson;
-    resolveEntryPaths: ResolveEntryPaths<PackageJson>;
+    resolveConfig: ResolveConfig<PackageJson>;
 };
 export default _default;

package/dist/plugins/bun/index.js

@@ -5,7 +5,7 @@ const enablers = ['bun'];
 const isEnabled = () => true;
 const config = ['package.json'];
 const packageJsonPath = (id) => id;
-const resolveEntryPaths = localConfig => {
+const resolveConfig = localConfig => {
     const scripts = localConfig.scripts;
     if (scripts) {
         const testScripts = Object.keys(scripts).filter(script => /(?<=^|\s)bun test/.test(scripts[script]));
@@ -24,5 +24,5 @@ export default {
     isEnabled,
     config,
     packageJsonPath,
-    resolveEntryPaths,
+    resolveConfig,
 };

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CucumberConfig } from './types.js';
 declare const _default: {
     title: string;
@@ -6,7 +6,6 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: ResolveEntryPaths<CucumberConfig>;
     resolveConfig: ResolveConfig<CucumberConfig>;
 };
 export default _default;

package/dist/plugins/cucumber/index.js

@@ -5,13 +5,11 @@ const enablers = ['@cucumber/cucumber'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const config = ['cucumber.{json,yaml,yml,js,cjs,mjs}'];
 const entry = ['features/**/*.@(js|cjs|mjs)'];
-const resolveEntryPaths = config => {
-    return (config?.import ? config.import : []).map(id => toEntry(id));
-};
 const resolveConfig = config => {
+    const imports = (config?.import ? config.import : entry).map(id => toEntry(id));
     const formatters = config?.format ? config.format : [];
     const requires = config?.require ? config.require : [];
-    return [...formatters, ...requires].map(toDeferResolve);
+    return imports.concat([...formatters, ...requires].map(toDeferResolve));
 };
 export default {
     title,
@@ -19,6 +17,5 @@ export default {
     isEnabled,
     config,
     entry,
-    resolveEntryPaths,
     resolveConfig,
 };

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

@@ -1,4 +1,4 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
 import type { CypressConfig } from './types.js';
 declare const _default: {
     title: string;
@@ -6,7 +6,6 @@ declare const _default: {
     isEnabled: IsPluginEnabled;
     config: string[];
     entry: string[];
-    resolveEntryPaths: ResolveEntryPaths;
     resolveConfig: ResolveConfig<CypressConfig>;
 };
 export default _default;

package/dist/plugins/cypress/index.js

@@ -13,17 +13,15 @@ const SUPPORT_FILE_PATTERNS = [
     'cypress/plugins/index.js',
 ];
 const entry = [...TEST_FILE_PATTERNS, ...SUPPORT_FILE_PATTERNS];
-const resolveEntryPaths = async (localConfig) => {
+const resolveConfig = async (localConfig, options) => {
     const specPatterns = [localConfig.e2e?.specPattern ?? [], localConfig.component?.specPattern ?? []].flat();
     const supportFiles = [localConfig.e2e?.supportFile || [], localConfig.component?.supportFile || []].flat();
+    const inputs = await resolveDependencies(localConfig, options);
     return [
-        ...(specPatterns.length > 0 ? specPatterns : TEST_FILE_PATTERNS),
-        ...(supportFiles.length > 0 ? supportFiles : SUPPORT_FILE_PATTERNS),
-    ].map(id => toEntry(id));
-};
-const resolveConfig = async (config, options) => {
-    const inputs = await resolveDependencies(config, options);
-    return inputs.map(toDeferResolve);
+        ...inputs.map(toDeferResolve),
+        ...(specPatterns.length > 0 ? specPatterns : TEST_FILE_PATTERNS).map(id => toEntry(id)),
+        ...(supportFiles.length > 0 ? supportFiles : SUPPORT_FILE_PATTERNS).map(id => toEntry(id)),
+    ];
 };
 export default {
     title,
@@ -31,6 +29,5 @@ export default {
     isEnabled,
     config,
     entry,
-    resolveEntryPaths,
     resolveConfig,
 };

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

@@ -3,4 +3,12 @@ export interface CypressConfig {
     reporterOptions?: {
         configFile?: string;
     };
+    component?: {
+        specPattern?: string[];
+        supportFile?: string;
+    };
+    e2e?: {
+        specPattern?: string[];
+        supportFile?: string;
+    };
 }

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

@@ -1,4 +1,3 @@
-import type { EleventyConfig } from './types.js';
 export declare class DummyEleventyConfig {
     _getUniqueId(): void;
     reset(): void;
@@ -135,4 +134,13 @@ export declare class DummyEleventyConfig {
     };
     templateFormatsAdded: {};
 }
-export declare const defaultEleventyConfig: EleventyConfig;
+export declare const defaultEleventyConfig: {
+    dir: {
+        input: string;
+        output: string;
+        includes: string;
+        layouts: string;
+        data: string;
+    };
+    templateFormats: string;
+};

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

@@ -1,14 +1,11 @@
-import type { IsPluginEnabled, ResolveConfig, ResolveEntryPaths } from '../../types/config.js';
-import { DummyEleventyConfig } from './helpers.js';
-import type { EleventyConfig } from './types.js';
-type T = Partial<EleventyConfig> | ((arg: DummyEleventyConfig) => Promise<Partial<EleventyConfig>>);
+import type { IsPluginEnabled, ResolveConfig } from '../../types/config.js';
+import type { EleventyConfigOrFn } from './types.js';
 declare const _default: {
     title: string;
     enablers: string[];
     isEnabled: IsPluginEnabled;
     config: string[];
     production: string[];
-    resolveEntryPaths: ResolveEntryPaths<T>;
-    resolveConfig: ResolveConfig<T>;
+    resolveConfig: ResolveConfig<EleventyConfigOrFn>;
 };
 export default _default;