@angular/build 20.2.0 → 21.0.0-next.0

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

@@ -6,320 +6,218 @@
  * 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
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execute = execute;
+const architect_1 = require("@angular-devkit/architect");
 const node_assert_1 = __importDefault(require("node:assert"));
-const node_crypto_1 = require("node:crypto");
-const node_module_1 = require("node:module");
-const node_path_1 = __importDefault(require("node:path"));
 const virtual_module_plugin_1 = require("../../tools/esbuild/virtual-module-plugin");
 const error_1 = require("../../utils/error");
-const load_esm_1 = require("../../utils/load-esm");
-const path_1 = require("../../utils/path");
 const application_1 = require("../application");
 const results_1 = require("../application/results");
-const schema_1 = require("../application/schema");
-const application_builder_1 = require("../karma/application_builder");
-const find_tests_1 = require("../karma/find-tests");
-const karma_bridge_1 = require("./karma-bridge");
 const options_1 = require("./options");
-/**
- * @experimental Direct usage of this function is considered experimental.
- */
-// eslint-disable-next-line max-lines-per-function
-async function* execute(options, context, extensions = {}) {
-    // Determine project name from builder context target
-    const projectName = context.target?.project;
-    if (!projectName) {
-        context.logger.error(`The "${context.builder.builderName}" builder requires a target to be specified.`);
-        return;
-    }
-    context.logger.warn(`NOTE: The "${context.builder.builderName}" builder is currently EXPERIMENTAL and not ready for production use.`);
-    const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options);
-    const { projectSourceRoot, workspaceRoot, runnerName } = normalizedOptions;
-    // Translate options and use karma builder directly if specified
-    if (runnerName === 'karma') {
-        const karmaBridge = await (0, karma_bridge_1.useKarmaBuilder)(context, normalizedOptions);
-        yield* karmaBridge;
-        return;
-    }
-    if (runnerName !== 'vitest') {
-        context.logger.error('Unknown test runner: ' + runnerName);
-        return;
-    }
-    // Find test files
-    const testFiles = await (0, find_tests_1.findTests)(normalizedOptions.include, normalizedOptions.exclude, workspaceRoot, projectSourceRoot);
-    if (testFiles.length === 0) {
-        context.logger.error('No tests found.');
-        return { success: false };
+async function loadTestRunner(runnerName) {
+    // Harden against directory traversal
+    if (!/^[a-zA-Z0-9-]+$/.test(runnerName)) {
+        throw new Error(`Invalid runner name "${runnerName}". Runner names can only contain alphanumeric characters and hyphens.`);
     }
-    const entryPoints = (0, find_tests_1.getTestEntrypoints)(testFiles, { projectSourceRoot, workspaceRoot });
-    entryPoints.set('init-testbed', 'angular:test-bed-init');
-    let vitestNodeModule;
+    let runnerModule;
     try {
-        vitestNodeModule = await (0, load_esm_1.loadEsmModule)('vitest/node');
+        runnerModule = await Promise.resolve(`${`./runners/${runnerName}/index`}`).then(s => __importStar(require(s)));
     }
-    catch (error) {
-        (0, error_1.assertIsError)(error);
-        if (error.code !== 'ERR_MODULE_NOT_FOUND') {
-            throw error;
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        if (e.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new Error(`Unknown test runner "${runnerName}".`);
         }
-        context.logger.error('The `vitest` package was not found. Please install the package and rerun the test command.');
-        return;
+        throw new Error(`Failed to load the '${runnerName}' test runner. The package may be corrupted or improperly installed.\n` +
+            `Error: ${e.message}`);
     }
-    const { startVitest } = vitestNodeModule;
-    // Setup test file build options based on application build target options
-    const buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
-    buildTargetOptions.polyfills = (0, options_1.injectTestingPolyfills)(buildTargetOptions.polyfills);
-    const outputPath = (0, path_1.toPosixPath)(node_path_1.default.join(context.workspaceRoot, generateOutputPath()));
-    const buildOptions = {
-        ...buildTargetOptions,
-        watch: normalizedOptions.watch,
-        incrementalResults: normalizedOptions.watch,
-        outputPath,
-        index: false,
-        browser: undefined,
-        server: undefined,
-        outputMode: undefined,
-        localize: false,
-        budgets: [],
-        serviceWorker: false,
-        appShell: false,
-        ssr: false,
-        prerender: false,
-        sourceMap: { scripts: true, vendor: false, styles: false },
-        outputHashing: schema_1.OutputHashing.None,
-        optimization: false,
-        tsConfig: normalizedOptions.tsConfig,
-        entryPoints,
-        externalDependencies: [
-            'vitest',
-            '@vitest/browser/context',
-            ...(buildTargetOptions.externalDependencies ?? []),
-        ],
-    };
-    extensions ??= {};
-    extensions.codePlugins ??= [];
-    const virtualTestBedInit = (0, virtual_module_plugin_1.createVirtualModulePlugin)({
-        namespace: 'angular:test-bed-init',
-        loadContent: async () => {
-            const contents = [
-                // Initialize the Angular testing environment
-                `import { NgModule } from '@angular/core';`,
-                `import { getTestBed, ɵgetCleanupHook as getCleanupHook } from '@angular/core/testing';`,
-                `import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';`,
-                '',
-                normalizedOptions.providersFile
-                    ? `import providers from './${(0, path_1.toPosixPath)(node_path_1.default
-                        .relative(projectSourceRoot, normalizedOptions.providersFile)
-                        .replace(/.[mc]?ts$/, ''))}'`
-                    : 'const providers = [];',
-                '',
-                // Same as https://github.com/angular/angular/blob/05a03d3f975771bb59c7eefd37c01fa127ee2229/packages/core/testing/src/test_hooks.ts#L21-L29
-                `beforeEach(getCleanupHook(false));`,
-                `afterEach(getCleanupHook(true));`,
-                '',
-                `@NgModule({`,
-                `  providers,`,
-                `})`,
-                `export class TestModule {}`,
-                '',
-                `getTestBed().initTestEnvironment([BrowserTestingModule, TestModule], platformBrowserTesting(), {`,
-                `  errorOnUnknownElements: true,`,
-                `  errorOnUnknownProperties: true,`,
-                '});',
-            ];
-            return {
-                contents: contents.join('\n'),
-                loader: 'js',
-                resolveDir: projectSourceRoot,
-            };
-        },
-    });
-    extensions.codePlugins.unshift(virtualTestBedInit);
-    let instance;
-    // Setup vitest browser options if configured
-    const { browser, errors } = setupBrowserConfiguration(normalizedOptions.browsers, normalizedOptions.debug, projectSourceRoot);
-    if (errors?.length) {
-        errors.forEach((error) => context.logger.error(error));
-        return { success: false };
+    const runner = runnerModule.default;
+    if (!runner ||
+        typeof runner.getBuildOptions !== 'function' ||
+        typeof runner.createExecutor !== 'function') {
+        throw new Error(`The loaded test runner '${runnerName}' does not appear to be a valid TestRunner implementation.`);
     }
-    // Add setup file entries for TestBed initialization and project polyfills
-    const setupFiles = ['init-testbed.js', ...normalizedOptions.setupFiles];
-    if (buildTargetOptions?.polyfills?.length) {
-        // Placed first as polyfills may be required by the Testbed initialization
-        // or other project provided setup files (e.g., zone.js, ECMAScript polyfills).
-        setupFiles.unshift('polyfills.js');
+    return runner;
+}
+function prepareBuildExtensions(virtualFiles, projectSourceRoot, extensions) {
+    if (!virtualFiles) {
+        return extensions;
     }
-    const debugOptions = normalizedOptions.debug
-        ? {
-            inspectBrk: true,
-            isolate: false,
-            fileParallelism: false,
-        }
-        : {};
-    try {
-        for await (const result of (0, application_1.buildApplicationInternal)(buildOptions, context, extensions)) {
-            if (result.kind === results_1.ResultKind.Failure) {
-                continue;
-            }
-            else if (result.kind !== results_1.ResultKind.Full && result.kind !== results_1.ResultKind.Incremental) {
-                node_assert_1.default.fail('A full and/or incremental build result is required from the application builder.');
-            }
-            (0, node_assert_1.default)(result.files, 'Builder did not provide result files.');
-            await (0, application_builder_1.writeTestFiles)(result.files, outputPath);
-            instance ??= await startVitest('test', undefined /* cliFilters */, {
-                // Disable configuration file resolution/loading
-                config: false,
-                root: workspaceRoot,
-                project: ['base', projectName],
-                name: 'base',
-                include: [],
-                reporters: normalizedOptions.reporters ?? ['default'],
-                watch: normalizedOptions.watch,
-                coverage: generateCoverageOption(normalizedOptions.codeCoverage, workspaceRoot, outputPath),
-                ...debugOptions,
-            }, {
-                plugins: [
-                    {
-                        name: 'angular:project-init',
-                        async configureVitest(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.
-                            const [project] = await context.injectTestProjects({
-                                test: {
-                                    name: projectName,
-                                    root: outputPath,
-                                    globals: true,
-                                    setupFiles,
-                                    // Use `jsdom` if no browsers are explicitly configured.
-                                    // `node` is effectively no "environment" and the default.
-                                    environment: browser ? 'node' : 'jsdom',
-                                    browser,
-                                },
-                                plugins: [
-                                    {
-                                        name: 'angular:html-index',
-                                        transformIndexHtml() {
-                                            // Add all global stylesheets
-                                            return (Object.entries(result.files)
-                                                // TODO: Expand this to all configured global stylesheets
-                                                .filter(([file]) => file === 'styles.css')
-                                                .map(([styleUrl]) => ({
-                                                tag: 'link',
-                                                attrs: {
-                                                    'href': styleUrl,
-                                                    'rel': 'stylesheet',
-                                                },
-                                                injectTo: 'head',
-                                            })));
-                                        },
-                                    },
-                                ],
-                            });
-                            // Adjust coverage excludes to not include the otherwise automatically inserted included unit tests.
-                            // Vite does this as a convenience but is problematic for the bundling strategy employed by the
-                            // builder's test setup. To workaround this, the excludes are adjusted here to only automaticallyAdd commentMore actions
-                            // exclude the TypeScript source test files.
-                            project.config.coverage.exclude = [
-                                ...(normalizedOptions.codeCoverage?.exclude ?? []),
-                                '**/*.{test,spec}.?(c|m)ts',
-                            ];
-                        },
-                    },
-                ],
-            });
-            // Check if all the tests pass to calculate the result
-            const testModules = instance.state.getTestModules();
-            yield { success: testModules.every((testModule) => testModule.ok()) };
+    extensions ??= {};
+    extensions.codePlugins ??= [];
+    for (const [namespace, contents] of Object.entries(virtualFiles)) {
+        extensions.codePlugins.push((0, virtual_module_plugin_1.createVirtualModulePlugin)({
+            namespace,
+            loadContent: () => {
+                return {
+                    contents,
+                    loader: 'js',
+                    resolveDir: projectSourceRoot,
+                };
+            },
+        }));
+    }
+    return extensions;
+}
+async function* runBuildAndTest(executor, applicationBuildOptions, context, extensions) {
+    for await (const buildResult of (0, application_1.buildApplicationInternal)(applicationBuildOptions, context, extensions)) {
+        if (buildResult.kind === results_1.ResultKind.Failure) {
+            yield { success: false };
+            continue;
         }
-    }
-    finally {
-        if (normalizedOptions.watch) {
-            // Vitest will automatically close if not using watch mode
-            await instance?.close();
+        else if (buildResult.kind !== results_1.ResultKind.Full &&
+            buildResult.kind !== results_1.ResultKind.Incremental) {
+            node_assert_1.default.fail('A full and/or incremental build result is required from the application builder.');
         }
+        (0, node_assert_1.default)(buildResult.files, 'Builder did not provide result files.');
+        // Pass the build artifacts to the executor
+        yield* executor.execute(buildResult);
     }
 }
-function findBrowserProvider(projectResolver) {
-    // One of these must be installed in the project to use browser testing
-    const vitestBuiltinProviders = ['playwright', 'webdriverio'];
-    for (const providerName of vitestBuiltinProviders) {
+/**
+ * @experimental Direct usage of this function is considered experimental.
+ */
+async function* execute(options, context, extensions) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // Determine project name from builder context target
+        const projectName = context.target?.project;
+        if (!projectName) {
+            context.logger.error(`The builder requires a target to be specified.`);
+            return;
+        }
+        context.logger.warn(`NOTE: The "unit-test" builder is currently EXPERIMENTAL and not ready for production use.`);
+        const normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options);
+        const runner = await loadTestRunner(normalizedOptions.runnerName);
+        const executor = __addDisposableResource(env_1, await runner.createExecutor(context, normalizedOptions), true);
+        if (runner.isStandalone) {
+            yield* executor.execute({
+                kind: results_1.ResultKind.Full,
+                files: {},
+            });
+            return;
+        }
+        // Get base build options from the buildTarget
+        let buildTargetOptions;
         try {
-            projectResolver(providerName);
-            return providerName;
+            buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
         }
-        catch { }
-    }
-}
-function normalizeBrowserName(browserName) {
-    // Normalize browser names to match Vitest's expectations for headless but also supports karma's names
-    // e.g., 'ChromeHeadless' -> 'chrome', 'FirefoxHeadless'
-    // and 'Chrome' -> 'chrome', 'Firefox' -> 'firefox'.
-    const normalized = browserName.toLowerCase();
-    return normalized.replace(/headless$/, '');
-}
-function setupBrowserConfiguration(browsers, debug, projectSourceRoot) {
-    if (browsers === undefined) {
-        return {};
-    }
-    const projectResolver = (0, node_module_1.createRequire)(projectSourceRoot + '/').resolve;
-    let errors;
-    try {
-        projectResolver('@vitest/browser');
-    }
-    catch {
-        errors ??= [];
-        errors.push('The "browsers" option requires the "@vitest/browser" package to be installed within the project.' +
-            ' Please install this package and rerun the test command.');
-    }
-    const provider = findBrowserProvider(projectResolver);
-    if (!provider) {
-        errors ??= [];
-        errors.push('The "browsers" option requires either "playwright" or "webdriverio" to be installed within the project.' +
-            ' Please install one of these packages and rerun the test command.');
-    }
-    // Vitest current requires the playwright browser provider to use the inspect-brk option used by "debug"
-    if (debug && provider !== 'playwright') {
-        errors ??= [];
-        errors.push('Debugging browser mode tests currently requires the use of "playwright".' +
-            ' Please install this package and rerun the test command.');
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            context.logger.error(`Could not load build target options for "${(0, architect_1.targetStringFromTarget)(normalizedOptions.buildTarget)}".\n` +
+                `Please check your 'angular.json' configuration.\n` +
+                `Error: ${e.message}`);
+            return;
+        }
+        // Get runner-specific build options from the hook
+        const { buildOptions: runnerBuildOptions, virtualFiles } = await runner.getBuildOptions(normalizedOptions, buildTargetOptions);
+        const finalExtensions = prepareBuildExtensions(virtualFiles, normalizedOptions.projectSourceRoot, extensions);
+        // Prepare and run the application build
+        const applicationBuildOptions = {
+            ...buildTargetOptions,
+            ...runnerBuildOptions,
+            watch: normalizedOptions.watch,
+            tsConfig: normalizedOptions.tsConfig,
+            progress: normalizedOptions.buildProgress ?? buildTargetOptions.progress,
+        };
+        yield* runBuildAndTest(executor, applicationBuildOptions, context, finalExtensions);
     }
-    if (errors) {
-        return { errors };
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
-    const browser = {
-        enabled: true,
-        provider,
-        headless: browsers.some((name) => name.toLowerCase().includes('headless')),
-        instances: browsers.map((browserName) => ({
-            browser: normalizeBrowserName(browserName),
-        })),
-    };
-    return { browser };
-}
-function generateOutputPath() {
-    const datePrefix = new Date().toISOString().replaceAll(/[-:.]/g, '');
-    const uuidSuffix = (0, node_crypto_1.randomUUID)().slice(0, 8);
-    return node_path_1.default.join('dist', 'test-out', `${datePrefix}-${uuidSuffix}`);
-}
-function generateCoverageOption(codeCoverage, workspaceRoot, outputPath) {
-    if (!codeCoverage) {
-        return {
-            enabled: false,
-        };
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
-    return {
-        enabled: true,
-        excludeAfterRemap: true,
-        include: [`${(0, path_1.toPosixPath)(node_path_1.default.relative(workspaceRoot, outputPath))}/**`],
-        // Special handling for `reporter` due to an undefined value causing upstream failures
-        ...(codeCoverage.reporters
-            ? { reporter: codeCoverage.reporters }
-            : {}),
-    };
 }

package/src/builders/unit-test/options.d.ts

@@ -22,6 +22,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
         reporters: [string, Record<string, unknown>][] | undefined;
     } | undefined;
     tsConfig: string;
+    buildProgress: boolean | undefined;
     reporters: string[] | undefined;
     browsers: string[] | undefined;
     watch: boolean;

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

@@ -28,7 +28,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 } = options;
+    const { tsConfig, runner, reporters, browsers, progress } = options;
     return {
         // Project/workspace information
         workspaceRoot,
@@ -49,6 +49,7 @@ async function normalizeOptions(context, projectName, options) {
             }
             : undefined,
         tsConfig,
+        buildProgress: progress,
         reporters,
         browsers,
         watch: options.watch ?? (0, tty_1.isTTY)(),

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

@@ -0,0 +1,47 @@
+/**
+ * @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 { BuilderContext, BuilderOutput } from '@angular-devkit/architect';
+import type { ApplicationBuilderInternalOptions } from '../../application/options';
+import type { FullResult, IncrementalResult } from '../../application/results';
+import type { NormalizedUnitTestBuilderOptions } from '../options';
+export interface RunnerOptions {
+    buildOptions: Partial<ApplicationBuilderInternalOptions>;
+    virtualFiles?: Record<string, string>;
+}
+/**
+ * Represents a stateful test execution session.
+ * An instance of this is created for each `ng test` command.
+ */
+export interface TestExecutor {
+    /**
+     * Executes tests using the artifacts from a specific build.
+     * This method can be called multiple times in watch mode.
+     *
+     * @param buildResult The output from the application builder.
+     * @returns An async iterable builder output stream.
+     */
+    execute(buildResult: FullResult | IncrementalResult): AsyncIterable<BuilderOutput>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Represents the metadata and hooks for a specific test runner.
+ */
+export interface TestRunner {
+    readonly name: string;
+    readonly isStandalone?: boolean;
+    getBuildOptions(options: NormalizedUnitTestBuilderOptions, baseBuildOptions: Partial<ApplicationBuilderInternalOptions>): RunnerOptions | Promise<RunnerOptions>;
+    /**
+     * Creates a stateful executor for a test session.
+     * This is called once at the start of the `ng test` command.
+     *
+     * @param context The Architect builder context.
+     * @param options The normalized unit test options.
+     * @returns A TestExecutor instance that will handle the test runs.
+     */
+    createExecutor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions): Promise<TestExecutor>;
+}

package/src/builders/unit-test/runners/api.js

@@ -0,0 +1,9 @@
+"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 });

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

@@ -0,0 +1,17 @@
+/**
+ * @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 { BuilderContext, BuilderOutput } from '@angular-devkit/architect';
+import { NormalizedUnitTestBuilderOptions } from '../../options';
+import type { TestExecutor } from '../api';
+export declare class KarmaExecutor implements TestExecutor {
+    private context;
+    private options;
+    constructor(context: BuilderContext, options: NormalizedUnitTestBuilderOptions);
+    execute(): AsyncIterable<BuilderOutput>;
+    [Symbol.asyncDispose](): Promise<void>;
+}