@angular/build 21.0.0-next.3 → 21.0.0-next.4

package/src/builders/unit-test/options.js

@@ -17,6 +17,11 @@ const node_path_1 = __importDefault(require("node:path"));
 const normalize_cache_1 = require("../../utils/normalize-cache");
 const project_metadata_1 = require("../../utils/project-metadata");
 const tty_1 = require("../../utils/tty");
+function normalizeReporterOption(reporters) {
+    return reporters?.map((entry) => typeof entry === 'string'
+        ? [entry, {}]
+        : entry);
+}
 async function normalizeOptions(context, projectName, options) {
     // Setup base paths based on workspace root and project information
     const workspaceRoot = context.workspaceRoot;
@@ -28,7 +33,7 @@ async function normalizeOptions(context, projectName, options) {
     // Target specifier defaults to the current project's build target using a development configuration
     const buildTargetSpecifier = options.buildTarget ?? `::development`;
     const buildTarget = (0, architect_1.targetFromTargetString)(buildTargetSpecifier, projectName, 'build');
-    const { tsConfig, runner, reporters, browsers, progress } = options;
+    const { tsConfig, runner, browsers, progress, filter } = options;
     return {
         // Project/workspace information
         workspaceRoot,
@@ -39,18 +44,18 @@ async function normalizeOptions(context, projectName, options) {
         buildTarget,
         include: options.include ?? ['**/*.spec.ts'],
         exclude: options.exclude,
+        filter,
         runnerName: runner,
         codeCoverage: options.codeCoverage
             ? {
                 exclude: options.codeCoverageExclude,
-                reporters: options.codeCoverageReporters?.map((entry) => typeof entry === 'string'
-                    ? [entry, {}]
-                    : entry),
+                reporters: normalizeReporterOption(options.codeCoverageReporters),
             }
             : undefined,
         tsConfig,
         buildProgress: progress,
-        reporters,
+        reporters: normalizeReporterOption(options.reporters),
+        outputFile: options.outputFile,
         browsers,
         watch: options.watch ?? (0, tty_1.isTTY)(),
         debug: options.debug ?? false,
@@ -58,6 +63,7 @@ async function normalizeOptions(context, projectName, options) {
         setupFiles: options.setupFiles
             ? options.setupFiles.map((setupFile) => node_path_1.default.join(workspaceRoot, setupFile))
             : [],
+        dumpVirtualFiles: options.dumpVirtualFiles,
     };
 }
 function injectTestingPolyfills(polyfills = []) {

package/src/builders/unit-test/runners/api.d.ts

@@ -9,9 +9,25 @@ import type { BuilderContext, BuilderOutput } from '@angular-devkit/architect';
 import type { ApplicationBuilderInternalOptions } from '../../application/options';
 import type { FullResult, IncrementalResult } from '../../application/results';
 import type { NormalizedUnitTestBuilderOptions } from '../options';
+/**
+ * Represents the options for a test runner.
+ */
 export interface RunnerOptions {
+    /**
+     * Partial options for the application builder.
+     * These will be merged with the options from the build target.
+     */
     buildOptions: Partial<ApplicationBuilderInternalOptions>;
+    /**
+     * A record of virtual files to be added to the build.
+     * The key is the file path and the value is the file content.
+     */
     virtualFiles?: Record<string, string>;
+    /**
+     * A map of test entry points to their corresponding test files.
+     * This is used to avoid re-discovering the test files in the executor.
+     */
+    testEntryPointMappings?: Map<string, string>;
 }
 /**
  * Represents a stateful test execution session.
@@ -34,6 +50,7 @@ export interface TestExecutor {
 export interface TestRunner {
     readonly name: string;
     readonly isStandalone?: boolean;
+    validateDependencies?(options: NormalizedUnitTestBuilderOptions): void | Promise<void>;
     getBuildOptions(options: NormalizedUnitTestBuilderOptions, baseBuildOptions: Partial<ApplicationBuilderInternalOptions>): RunnerOptions | Promise<RunnerOptions>;
     /**
      * Creates a stateful executor for a test session.
@@ -41,7 +58,8 @@ export interface TestRunner {
      *
      * @param context The Architect builder context.
      * @param options The normalized unit test options.
+     * @param testEntryPointMappings A map of test entry points to their corresponding test files.
      * @returns A TestExecutor instance that will handle the test runs.
      */
-    createExecutor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions): Promise<TestExecutor>;
+    createExecutor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions, testEntryPointMappings: Map<string, string> | undefined): Promise<TestExecutor>;
 }

package/src/builders/unit-test/runners/dependency-checker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * A custom error class to represent missing dependency errors.
+ * This is used to avoid printing a stack trace for this expected error.
+ */
+export declare class MissingDependenciesError extends Error {
+    constructor(message: string);
+}
+export declare class DependencyChecker {
+    private readonly resolver;
+    private readonly missingDependencies;
+    constructor(projectSourceRoot: string);
+    /**
+     * Checks if a package is installed.
+     * @param packageName The name of the package to check.
+     * @returns True if the package is found, false otherwise.
+     */
+    private isInstalled;
+    /**
+     * Verifies that a package is installed and adds it to a list of missing
+     * dependencies if it is not.
+     * @param packageName The name of the package to check.
+     */
+    check(packageName: string): void;
+    /**
+     * Verifies that at least one of a list of packages is installed. If none are
+     * installed, a custom error message is added to the list of errors.
+     * @param packageNames An array of package names to check.
+     * @param customErrorMessage The error message to use if none of the packages are found.
+     */
+    checkAny(packageNames: string[], customErrorMessage: string): void;
+    /**
+     * Throws a `MissingDependenciesError` if any dependencies were found to be missing.
+     * The error message is a formatted list of all missing packages.
+     */
+    report(): void;
+}

package/src/builders/unit-test/runners/dependency-checker.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyChecker = exports.MissingDependenciesError = void 0;
+const node_module_1 = require("node:module");
+/**
+ * A custom error class to represent missing dependency errors.
+ * This is used to avoid printing a stack trace for this expected error.
+ */
+class MissingDependenciesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MissingDependenciesError';
+    }
+}
+exports.MissingDependenciesError = MissingDependenciesError;
+class DependencyChecker {
+    resolver;
+    missingDependencies = new Set();
+    constructor(projectSourceRoot) {
+        this.resolver = (0, node_module_1.createRequire)(projectSourceRoot + '/').resolve;
+    }
+    /**
+     * Checks if a package is installed.
+     * @param packageName The name of the package to check.
+     * @returns True if the package is found, false otherwise.
+     */
+    isInstalled(packageName) {
+        try {
+            this.resolver(packageName);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Verifies that a package is installed and adds it to a list of missing
+     * dependencies if it is not.
+     * @param packageName The name of the package to check.
+     */
+    check(packageName) {
+        if (!this.isInstalled(packageName)) {
+            this.missingDependencies.add(packageName);
+        }
+    }
+    /**
+     * Verifies that at least one of a list of packages is installed. If none are
+     * installed, a custom error message is added to the list of errors.
+     * @param packageNames An array of package names to check.
+     * @param customErrorMessage The error message to use if none of the packages are found.
+     */
+    checkAny(packageNames, customErrorMessage) {
+        if (packageNames.every((name) => !this.isInstalled(name))) {
+            // This is a custom error, so we add it directly.
+            // Using a Set avoids duplicate custom messages.
+            this.missingDependencies.add(customErrorMessage);
+        }
+    }
+    /**
+     * Throws a `MissingDependenciesError` if any dependencies were found to be missing.
+     * The error message is a formatted list of all missing packages.
+     */
+    report() {
+        if (this.missingDependencies.size === 0) {
+            return;
+        }
+        let message = 'The following packages are required but were not found:\n';
+        for (const name of this.missingDependencies) {
+            message += `  - ${name}\n`;
+        }
+        message += 'Please install the missing packages and rerun the test command.';
+        throw new MissingDependenciesError(message);
+    }
+}
+exports.DependencyChecker = DependencyChecker;

package/src/builders/unit-test/runners/karma/executor.js

@@ -79,12 +79,36 @@ class KarmaExecutor {
             codeCoverage: !!unitTestOptions.codeCoverage,
             codeCoverageExclude: unitTestOptions.codeCoverage?.exclude,
             fileReplacements: buildTargetOptions.fileReplacements,
-            reporters: unitTestOptions.reporters,
+            reporters: unitTestOptions.reporters?.map((reporter) => {
+                // Karma only supports string reporters.
+                if (Object.keys(reporter[1]).length > 0) {
+                    context.logger.warn(`The "karma" test runner does not support options for the "${reporter[0]}" reporter. The options will be ignored.`);
+                }
+                return reporter[0];
+            }),
             webWorkerTsConfig: buildTargetOptions.webWorkerTsConfig,
             aot: buildTargetOptions.aot,
         };
+        const transformOptions = {
+            karmaOptions: (options) => {
+                if (unitTestOptions.filter) {
+                    let filter = unitTestOptions.filter;
+                    if (filter[0] === '/' && filter.at(-1) === '/') {
+                        this.context.logger.warn('The `--filter` option is always a regular expression.' +
+                            'Leading and trailing `/` are not required and will be ignored.');
+                    }
+                    else {
+                        filter = `/${filter}/`;
+                    }
+                    options.client ??= {};
+                    options.client.args ??= [];
+                    options.client.args.push('--grep', filter);
+                }
+                return options;
+            },
+        };
         const { execute } = await Promise.resolve().then(() => __importStar(require('../../../karma')));
-        yield* execute(karmaOptions, context);
+        yield* execute(karmaOptions, context, transformOptions);
     }
     async [Symbol.asyncDispose]() {
         // The Karma builder handles its own teardown

package/src/builders/unit-test/runners/karma/index.js

@@ -7,6 +7,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const dependency_checker_1 = require("../dependency-checker");
 const executor_1 = require("./executor");
 /**
  * A declarative definition of the Karma test runner.
@@ -14,6 +15,22 @@ const executor_1 = require("./executor");
 const KarmaTestRunner = {
     name: 'karma',
     isStandalone: true,
+    validateDependencies(options) {
+        const checker = new dependency_checker_1.DependencyChecker(options.projectSourceRoot);
+        checker.check('karma');
+        checker.check('karma-jasmine');
+        // Check for browser launchers
+        if (options.browsers?.length) {
+            for (const browser of options.browsers) {
+                const launcherName = `karma-${browser.toLowerCase().split('headless')[0]}-launcher`;
+                checker.check(launcherName);
+            }
+        }
+        if (options.codeCoverage) {
+            checker.check('karma-coverage');
+        }
+        checker.report();
+    },
     getBuildOptions() {
         return {
             buildOptions: {},

package/src/builders/unit-test/runners/vitest/browser-provider.d.ts

@@ -5,7 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-export declare function setupBrowserConfiguration(browsers: string[] | undefined, debug: boolean, projectSourceRoot: string): {
+export interface BrowserConfiguration {
     browser?: import('vitest/node').BrowserConfigOptions;
     errors?: string[];
-};
+}
+export declare function setupBrowserConfiguration(browsers: string[] | undefined, debug: boolean, projectSourceRoot: string): BrowserConfiguration;

package/src/builders/unit-test/runners/vitest/build-options.js

@@ -97,5 +97,6 @@ async function getVitestBuildOptions(options, baseBuildOptions) {
         virtualFiles: {
             'angular:test-bed-init': testBedInitContents,
         },
+        testEntryPointMappings: entryPoints,
     };
 }

package/src/builders/unit-test/runners/vitest/executor.d.ts

@@ -13,13 +13,12 @@ export declare class VitestExecutor implements TestExecutor {
     private vitest;
     private readonly projectName;
     private readonly options;
-    private buildResultFiles;
-    private testFileToEntryPoint;
-    private entryPointToTestFile;
-    constructor(projectName: string, options: NormalizedUnitTestBuilderOptions);
+    private readonly buildResultFiles;
+    private readonly testFileToEntryPoint;
+    private readonly entryPointToTestFile;
+    constructor(projectName: string, options: NormalizedUnitTestBuilderOptions, testEntryPointMappings: Map<string, string> | undefined);
     execute(buildResult: FullResult | IncrementalResult): AsyncIterable<BuilderOutput>;
     [Symbol.asyncDispose](): Promise<void>;
     private prepareSetupFiles;
-    private createVitestPlugins;
     private initializeVitest;
 }

package/src/builders/unit-test/runners/vitest/executor.js

@@ -12,14 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VitestExecutor = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
-const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const error_1 = require("../../../../utils/error");
 const load_esm_1 = require("../../../../utils/load-esm");
 const path_1 = require("../../../../utils/path");
 const results_1 = require("../../../application/results");
-const test_discovery_1 = require("../../test-discovery");
 const browser_provider_1 = require("./browser-provider");
+const plugins_1 = require("./plugins");
 class VitestExecutor {
     vitest;
     projectName;
@@ -31,9 +30,15 @@ class VitestExecutor {
     // Example: `Map<'/path/to/src/app.spec.ts', 'spec-src-app-spec'>`
     testFileToEntryPoint = new Map();
     entryPointToTestFile = new Map();
-    constructor(projectName, options) {
+    constructor(projectName, options, testEntryPointMappings) {
         this.projectName = projectName;
         this.options = options;
+        if (testEntryPointMappings) {
+            for (const [entryPoint, testFile] of testEntryPointMappings) {
+                this.testFileToEntryPoint.set(testFile, entryPoint);
+                this.entryPointToTestFile.set(entryPoint + '.js', testFile);
+            }
+        }
     }
     async *execute(buildResult) {
         if (buildResult.kind === results_1.ResultKind.Full) {
@@ -50,24 +55,6 @@ class VitestExecutor {
                 this.buildResultFiles.set(path, file);
             }
         }
-        // The `getTestEntrypoints` function is used here to create the same mapping
-        // that was used in `build-options.ts` to generate the build entry points.
-        // This is a deliberate duplication to avoid a larger refactoring of the
-        // builder's core interfaces to pass the entry points from the build setup
-        // phase to the execution phase.
-        if (this.testFileToEntryPoint.size === 0) {
-            const { include, exclude = [], workspaceRoot, projectSourceRoot } = this.options;
-            const testFiles = await (0, test_discovery_1.findTests)(include, exclude, workspaceRoot, projectSourceRoot);
-            const entryPoints = (0, test_discovery_1.getTestEntrypoints)(testFiles, {
-                projectSourceRoot,
-                workspaceRoot,
-                removeTestExtension: true,
-            });
-            for (const [entryPoint, testFile] of entryPoints) {
-                this.testFileToEntryPoint.set(testFile, entryPoint);
-                this.entryPointToTestFile.set(entryPoint + '.js', testFile);
-            }
-        }
         // Initialize Vitest if not already present.
         this.vitest ??= await this.initializeVitest();
         const vitest = this.vitest;
@@ -113,118 +100,8 @@ class VitestExecutor {
         }
         return testSetupFiles;
     }
-    createVitestPlugins(testSetupFiles, browserOptions) {
-        const { workspaceRoot } = this.options;
-        return [
-            {
-                name: 'angular:project-init',
-                // Type is incorrect. This allows a Promise<void>.
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                configureVitest: async (context) => {
-                    // Create a subproject that can be configured with plugins for browser mode.
-                    // Plugins defined directly in the vite overrides will not be present in the
-                    // browser specific Vite instance.
-                    await context.injectTestProjects({
-                        test: {
-                            name: this.projectName,
-                            root: workspaceRoot,
-                            globals: true,
-                            setupFiles: testSetupFiles,
-                            // Use `jsdom` if no browsers are explicitly configured.
-                            // `node` is effectively no "environment" and the default.
-                            environment: browserOptions.browser ? 'node' : 'jsdom',
-                            browser: browserOptions.browser,
-                            include: this.options.include,
-                            ...(this.options.exclude ? { exclude: this.options.exclude } : {}),
-                        },
-                        plugins: [
-                            {
-                                name: 'angular:test-in-memory-provider',
-                                enforce: 'pre',
-                                resolveId: (id, importer) => {
-                                    if (importer && (id[0] === '.' || id[0] === '/')) {
-                                        let fullPath;
-                                        if (this.testFileToEntryPoint.has(importer)) {
-                                            fullPath = (0, path_1.toPosixPath)(node_path_1.default.join(this.options.workspaceRoot, id));
-                                        }
-                                        else {
-                                            fullPath = (0, path_1.toPosixPath)(node_path_1.default.join(node_path_1.default.dirname(importer), id));
-                                        }
-                                        const relativePath = node_path_1.default.relative(this.options.workspaceRoot, fullPath);
-                                        if (this.buildResultFiles.has((0, path_1.toPosixPath)(relativePath))) {
-                                            return fullPath;
-                                        }
-                                    }
-                                    if (this.testFileToEntryPoint.has(id)) {
-                                        return id;
-                                    }
-                                    (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available for resolving.');
-                                    const relativePath = node_path_1.default.relative(this.options.workspaceRoot, id);
-                                    if (this.buildResultFiles.has((0, path_1.toPosixPath)(relativePath))) {
-                                        return id;
-                                    }
-                                },
-                                load: async (id) => {
-                                    (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available for in-memory loading.');
-                                    // Attempt to load as a source test file.
-                                    const entryPoint = this.testFileToEntryPoint.get(id);
-                                    let outputPath;
-                                    if (entryPoint) {
-                                        outputPath = entryPoint + '.js';
-                                        // To support coverage exclusion of the actual test file, the virtual
-                                        // test entry point only references the built and bundled intermediate file.
-                                        return {
-                                            code: `import "./${outputPath}";`,
-                                        };
-                                    }
-                                    else {
-                                        // Attempt to load as a built artifact.
-                                        const relativePath = node_path_1.default.relative(this.options.workspaceRoot, id);
-                                        outputPath = (0, path_1.toPosixPath)(relativePath);
-                                    }
-                                    const outputFile = this.buildResultFiles.get(outputPath);
-                                    if (outputFile) {
-                                        const sourceMapPath = outputPath + '.map';
-                                        const sourceMapFile = this.buildResultFiles.get(sourceMapPath);
-                                        const code = outputFile.origin === 'memory'
-                                            ? Buffer.from(outputFile.contents).toString('utf-8')
-                                            : await (0, promises_1.readFile)(outputFile.inputPath, 'utf-8');
-                                        const map = sourceMapFile
-                                            ? sourceMapFile.origin === 'memory'
-                                                ? Buffer.from(sourceMapFile.contents).toString('utf-8')
-                                                : await (0, promises_1.readFile)(sourceMapFile.inputPath, 'utf-8')
-                                            : undefined;
-                                        return {
-                                            code,
-                                            map: map ? JSON.parse(map) : undefined,
-                                        };
-                                    }
-                                },
-                            },
-                            {
-                                name: 'angular:html-index',
-                                transformIndexHtml: () => {
-                                    // Add all global stylesheets
-                                    if (this.buildResultFiles.has('styles.css')) {
-                                        return [
-                                            {
-                                                tag: 'link',
-                                                attrs: { href: 'styles.css', rel: 'stylesheet' },
-                                                injectTo: 'head',
-                                            },
-                                        ];
-                                    }
-                                    return [];
-                                },
-                            },
-                        ],
-                    });
-                },
-            },
-        ];
-    }
     async initializeVitest() {
-        const { codeCoverage, reporters, workspaceRoot, browsers, debug, watch } = this.options;
+        const { codeCoverage, reporters, outputFile, workspaceRoot, browsers, debug, watch } = this.options;
         let vitestNodeModule;
         try {
             vitestNodeModule = await (0, load_esm_1.loadEsmModule)('vitest/node');
@@ -244,7 +121,15 @@ class VitestExecutor {
         }
         (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available before initializing vitest');
         const testSetupFiles = this.prepareSetupFiles();
-        const plugins = this.createVitestPlugins(testSetupFiles, browserOptions);
+        const plugins = (0, plugins_1.createVitestPlugins)(this.options, testSetupFiles, browserOptions, {
+            workspaceRoot,
+            projectSourceRoot: this.options.projectSourceRoot,
+            projectName: this.projectName,
+            include: this.options.include,
+            exclude: this.options.exclude,
+            buildResultFiles: this.buildResultFiles,
+            testFileToEntryPoint: this.testFileToEntryPoint,
+        });
         const debugOptions = debug
             ? {
                 inspectBrk: true,
@@ -259,7 +144,9 @@ class VitestExecutor {
             project: ['base', this.projectName],
             name: 'base',
             include: [],
+            testNamePattern: this.options.filter,
             reporters: reporters ?? ['default'],
+            outputFile,
             watch,
             coverage: generateCoverageOption(codeCoverage),
             ...debugOptions,

package/src/builders/unit-test/runners/vitest/index.js

@@ -11,6 +11,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
+const dependency_checker_1 = require("../dependency-checker");
 const build_options_1 = require("./build-options");
 const executor_1 = require("./executor");
 /**
@@ -18,13 +19,29 @@ const executor_1 = require("./executor");
  */
 const VitestTestRunner = {
     name: 'vitest',
+    validateDependencies(options) {
+        const checker = new dependency_checker_1.DependencyChecker(options.projectSourceRoot);
+        checker.check('vitest');
+        if (options.browsers?.length) {
+            checker.check('@vitest/browser');
+            checker.checkAny(['playwright', 'webdriverio'], 'The "browsers" option requires either "playwright" or "webdriverio" to be installed.');
+        }
+        else {
+            // JSDOM is used when no browsers are specified
+            checker.check('jsdom');
+        }
+        if (options.codeCoverage) {
+            checker.check('@vitest/coverage-v8');
+        }
+        checker.report();
+    },
     getBuildOptions(options, baseBuildOptions) {
         return (0, build_options_1.getVitestBuildOptions)(options, baseBuildOptions);
     },
-    async createExecutor(context, options) {
+    async createExecutor(context, options, testEntryPointMappings) {
         const projectName = context.target?.project;
         (0, node_assert_1.default)(projectName, 'The builder requires a target.');
-        return new executor_1.VitestExecutor(projectName, options);
+        return new executor_1.VitestExecutor(projectName, options, testEntryPointMappings);
     },
 };
 exports.default = VitestTestRunner;

package/src/builders/unit-test/runners/vitest/plugins.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type { VitestPlugin } from 'vitest/node';
+import type { ResultFile } from '../../../application/results';
+import type { NormalizedUnitTestBuilderOptions } from '../../options';
+import type { BrowserConfiguration } from './browser-provider';
+type VitestPlugins = Awaited<ReturnType<typeof VitestPlugin>>;
+interface PluginOptions {
+    workspaceRoot: string;
+    projectSourceRoot: string;
+    projectName: string;
+    include?: string[];
+    exclude?: string[];
+    buildResultFiles: ReadonlyMap<string, ResultFile>;
+    testFileToEntryPoint: ReadonlyMap<string, string>;
+}
+export declare function createVitestPlugins(options: NormalizedUnitTestBuilderOptions, testSetupFiles: string[], browserOptions: BrowserConfiguration, pluginOptions: PluginOptions): VitestPlugins;
+export {};