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

package/src/builders/karma/coverage.js

@@ -0,0 +1,31 @@
+"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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstrumentationFilter = createInstrumentationFilter;
+exports.getInstrumentationExcludedPaths = getInstrumentationExcludedPaths;
+const node_path_1 = __importDefault(require("node:path"));
+const tinyglobby_1 = require("tinyglobby");
+function createInstrumentationFilter(includedBasePath, excludedPaths) {
+    return (request) => {
+        return (!excludedPaths.has(request) &&
+            !/\.(e2e|spec)\.tsx?$|[\\/]node_modules[\\/]/.test(request) &&
+            request.startsWith(includedBasePath));
+    };
+}
+function getInstrumentationExcludedPaths(root, excludedPaths) {
+    const excluded = new Set();
+    for (const excludeGlob of excludedPaths) {
+        const excludePath = excludeGlob[0] === '/' ? excludeGlob.slice(1) : excludeGlob;
+        (0, tinyglobby_1.globSync)(excludePath, { cwd: root }).forEach((p) => excluded.add(node_path_1.default.join(root, p)));
+    }
+    return excluded;
+}

package/src/builders/karma/karma-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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 } from '@angular-devkit/architect';
+import type { ConfigOptions } from 'karma';
+import type { NormalizedKarmaBuilderOptions } from './options';
+export declare function getBaseKarmaOptions(options: NormalizedKarmaBuilderOptions, context: BuilderContext): ConfigOptions;

package/src/builders/karma/karma-config.js

@@ -0,0 +1,79 @@
+"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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseKarmaOptions = getBaseKarmaOptions;
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+function getBaseKarmaOptions(options, context) {
+    // Determine project name from builder context target
+    const projectName = context.target?.project;
+    if (!projectName) {
+        throw new Error(`The 'karma' builder requires a target to be specified.`);
+    }
+    const karmaOptions = options.karmaConfig
+        ? {}
+        : getBuiltInKarmaConfig(context.workspaceRoot, projectName);
+    const singleRun = !options.watch;
+    karmaOptions.singleRun = singleRun;
+    // Workaround https://github.com/angular/angular-cli/issues/28271, by clearing context by default
+    // for single run executions. Not clearing context for multi-run (watched) builds allows the
+    // Jasmine Spec Runner to be visible in the browser after test execution.
+    karmaOptions.client ??= {};
+    karmaOptions.client.clearContext ??= singleRun;
+    // Convert browsers from a string to an array
+    if (options.browsers) {
+        karmaOptions.browsers = options.browsers;
+    }
+    if (options.reporters) {
+        karmaOptions.reporters = options.reporters;
+    }
+    return karmaOptions;
+}
+function getBuiltInKarmaConfig(workspaceRoot, projectName) {
+    let coverageFolderName = projectName.charAt(0) === '@' ? projectName.slice(1) : projectName;
+    coverageFolderName = coverageFolderName.toLowerCase();
+    const workspaceRootRequire = (0, node_module_1.createRequire)(workspaceRoot + '/');
+    // Any changes to the config here need to be synced to: packages/schematics/angular/config/files/karma.conf.js.template
+    return {
+        basePath: '',
+        frameworks: ['jasmine'],
+        plugins: [
+            'karma-jasmine',
+            'karma-chrome-launcher',
+            'karma-jasmine-html-reporter',
+            'karma-coverage',
+        ].map((p) => workspaceRootRequire(p)),
+        jasmineHtmlReporter: {
+            suppressAll: true, // removes the duplicated traces
+        },
+        coverageReporter: {
+            dir: node_path_1.default.join(workspaceRoot, 'coverage', coverageFolderName),
+            subdir: '.',
+            reporters: [{ type: 'html' }, { type: 'text-summary' }],
+        },
+        reporters: ['progress', 'kjhtml'],
+        browsers: ['Chrome'],
+        customLaunchers: {
+            // Chrome configured to run in a bazel sandbox.
+            // Disable the use of the gpu and `/dev/shm` because it causes Chrome to
+            // crash on some environments.
+            // See:
+            //   https://github.com/puppeteer/puppeteer/blob/v1.0.0/docs/troubleshooting.md#tips
+            //   https://stackoverflow.com/questions/50642308/webdriverexception-unknown-error-devtoolsactiveport-file-doesnt-exist-while-t
+            ChromeHeadlessNoSandbox: {
+                base: 'ChromeHeadless',
+                flags: ['--no-sandbox', '--headless', '--disable-gpu', '--disable-dev-shm-usage'],
+            },
+        },
+        restartOnFileChange: true,
+    };
+}

package/src/builders/karma/polyfills-plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { FilePattern, InlinePluginDef } from 'karma';
+export declare class AngularPolyfillsPlugin {
+    static readonly $inject: string[];
+    static readonly NAME = "angular-polyfills";
+    static createPlugin(polyfillsFile: FilePattern, jasmineCleanupFiles: FilePattern, scriptsFiles: FilePattern[]): InlinePluginDef;
+}

package/src/builders/karma/polyfills-plugin.js

@@ -0,0 +1,74 @@
+"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.AngularPolyfillsPlugin = void 0;
+const node_module_1 = require("node:module");
+const localResolve = (0, node_module_1.createRequire)(__filename).resolve;
+class AngularPolyfillsPlugin {
+    static $inject = ['config.files'];
+    static NAME = 'angular-polyfills';
+    static createPlugin(polyfillsFile, jasmineCleanupFiles, scriptsFiles) {
+        return {
+            // This has to be a "reporter" because reporters run _after_ frameworks
+            // and karma-jasmine-html-reporter injects additional scripts that may
+            // depend on Jasmine but aren't modules - which means that they would run
+            // _before_ all module code (including jasmine).
+            [`reporter:${AngularPolyfillsPlugin.NAME}`]: [
+                'factory',
+                Object.assign((files) => {
+                    // The correct order is zone.js -> jasmine -> zone.js/testing.
+                    // Jasmine has to see the patched version of the global `setTimeout`
+                    // function so it doesn't cache the unpatched version. And /testing
+                    // needs to see the global `jasmine` object so it can patch it.
+                    const polyfillsIndex = 0;
+                    files.splice(polyfillsIndex, 0, polyfillsFile);
+                    // Insert just before test_main.js.
+                    const zoneTestingIndex = files.findIndex((f) => {
+                        if (typeof f === 'string') {
+                            return false;
+                        }
+                        return f.pattern.endsWith('/test_main.js');
+                    });
+                    if (zoneTestingIndex === -1) {
+                        throw new Error('Could not find test entrypoint file.');
+                    }
+                    files.splice(zoneTestingIndex, 0, jasmineCleanupFiles);
+                    // We need to ensure that all files are served as modules, otherwise
+                    // the order in the files list gets really confusing: Karma doesn't
+                    // set defer on scripts, so all scripts with type=js will run first,
+                    // even if type=module files appeared earlier in `files`.
+                    for (const f of files) {
+                        if (typeof f === 'string') {
+                            throw new Error(`Unexpected string-based file: "${f}"`);
+                        }
+                        if (f.included === false) {
+                            // Don't worry about files that aren't included on the initial
+                            // page load. `type` won't affect them.
+                            continue;
+                        }
+                        if (f.pattern.endsWith('.js') && 'js' === (f.type ?? 'js')) {
+                            f.type = 'module';
+                        }
+                    }
+                    // Add "scripts" option files as classic scripts
+                    files.unshift(...scriptsFiles);
+                    // Add browser sourcemap support as a classic script
+                    files.unshift({
+                        pattern: localResolve('source-map-support/browser-source-map-support.js'),
+                        included: true,
+                        watched: false,
+                    });
+                    // Karma needs a return value for a factory and Karma's multi-reporter expects an `adapters` array
+                    return { adapters: [] };
+                }, AngularPolyfillsPlugin),
+            ],
+        };
+    }
+}
+exports.AngularPolyfillsPlugin = AngularPolyfillsPlugin;

package/src/builders/karma/progress-reporter.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 { BuilderOutput } from '@angular-devkit/architect';
+import type { Config, ConfigOptions } from 'karma';
+import type { ReadableStreamController } from 'node:stream/web';
+import type { ApplicationBuilderInternalOptions } from '../application/options';
+import type { Result } from '../application/results';
+interface BuildOptions extends ApplicationBuilderInternalOptions {
+    outputPath: string;
+}
+export declare function injectKarmaReporter(buildOptions: BuildOptions, buildIterator: AsyncIterator<Result>, karmaConfig: Config & ConfigOptions, controller: ReadableStreamController<BuilderOutput>): void;
+export {};

package/src/builders/karma/progress-reporter.js

@@ -0,0 +1,73 @@
+"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.injectKarmaReporter = injectKarmaReporter;
+const test_files_1 = require("../../utils/test-files");
+const results_1 = require("../application/results");
+const LATEST_BUILD_FILES_TOKEN = 'angularLatestBuildFiles';
+function injectKarmaReporter(buildOptions, buildIterator, karmaConfig, controller) {
+    const reporterName = 'angular-progress-notifier';
+    class ProgressNotifierReporter {
+        emitter;
+        latestBuildFiles;
+        static $inject = ['emitter', LATEST_BUILD_FILES_TOKEN];
+        constructor(emitter, latestBuildFiles) {
+            this.emitter = emitter;
+            this.latestBuildFiles = latestBuildFiles;
+            this.startWatchingBuild();
+        }
+        startWatchingBuild() {
+            void (async () => {
+                // This is effectively "for await of but skip what's already consumed".
+                let isDone = false; // to mark the loop condition as "not constant".
+                while (!isDone) {
+                    const { done, value: buildOutput } = await buildIterator.next();
+                    if (done) {
+                        isDone = true;
+                        break;
+                    }
+                    if (buildOutput.kind === results_1.ResultKind.Failure) {
+                        controller.enqueue({ success: false, message: 'Build failed' });
+                    }
+                    else if (buildOutput.kind === results_1.ResultKind.Incremental ||
+                        buildOutput.kind === results_1.ResultKind.Full) {
+                        if (buildOutput.kind === results_1.ResultKind.Full) {
+                            this.latestBuildFiles.files = buildOutput.files;
+                        }
+                        else {
+                            this.latestBuildFiles.files = {
+                                ...this.latestBuildFiles.files,
+                                ...buildOutput.files,
+                            };
+                        }
+                        await (0, test_files_1.writeTestFiles)(buildOutput.files, buildOptions.outputPath);
+                        this.emitter.refreshFiles();
+                    }
+                }
+            })();
+        }
+        onRunComplete = function (_browsers, results) {
+            if (results.exitCode === 0) {
+                controller.enqueue({ success: true });
+            }
+            else {
+                controller.enqueue({ success: false });
+            }
+        };
+    }
+    karmaConfig.reporters ??= [];
+    karmaConfig.reporters.push(reporterName);
+    karmaConfig.plugins ??= [];
+    karmaConfig.plugins.push({
+        [`reporter:${reporterName}`]: [
+            'factory',
+            Object.assign((...args) => new ProgressNotifierReporter(...args), ProgressNotifierReporter),
+        ],
+    });
+}

package/src/builders/karma/utils.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 } from '@angular-devkit/architect';
+import type { NormalizedKarmaBuilderOptions } from './options';
+export declare function getProjectSourceRoot(context: BuilderContext): Promise<string>;
+export declare function normalizePolyfills(polyfills?: string[]): [polyfills: string[], jasmineCleanup: string[]];
+export declare function collectEntrypoints(options: NormalizedKarmaBuilderOptions, context: BuilderContext, projectSourceRoot: string): Promise<Map<string, string>>;
+export declare function hasChunkOrWorkerFiles(files: Record<string, unknown>): boolean;
+/** Returns the first item yielded by the given generator and cancels the execution. */
+export declare function first<T>(generator: AsyncIterable<T>, { cancel }: {
+    cancel: boolean;
+}): Promise<[T, AsyncIterator<T> | null]>;

package/src/builders/karma/utils.js

@@ -0,0 +1,66 @@
+"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.getProjectSourceRoot = getProjectSourceRoot;
+exports.normalizePolyfills = normalizePolyfills;
+exports.collectEntrypoints = collectEntrypoints;
+exports.hasChunkOrWorkerFiles = hasChunkOrWorkerFiles;
+exports.first = first;
+const node_module_1 = require("node:module");
+const project_metadata_1 = require("../../utils/project-metadata");
+const find_tests_1 = require("./find-tests");
+const localResolve = (0, node_module_1.createRequire)(__filename).resolve;
+async function getProjectSourceRoot(context) {
+    // We have already validated that the project name is set before calling this function.
+    const projectName = context.target?.project;
+    if (!projectName) {
+        return context.workspaceRoot;
+    }
+    const projectMetadata = await context.getProjectMetadata(projectName);
+    const { projectSourceRoot } = (0, project_metadata_1.getProjectRootPaths)(context.workspaceRoot, projectMetadata);
+    return projectSourceRoot;
+}
+function normalizePolyfills(polyfills = []) {
+    const jasmineGlobalEntryPoint = localResolve('./polyfills/jasmine_global.js');
+    const jasmineGlobalCleanupEntrypoint = localResolve('./polyfills/jasmine_global_cleanup.js');
+    const sourcemapEntrypoint = localResolve('./polyfills/init_sourcemaps.js');
+    const zoneTestingEntryPoint = 'zone.js/testing';
+    const polyfillsExludingZoneTesting = polyfills.filter((p) => p !== zoneTestingEntryPoint);
+    return [
+        polyfillsExludingZoneTesting.concat([jasmineGlobalEntryPoint, sourcemapEntrypoint]),
+        polyfillsExludingZoneTesting.length === polyfills.length
+            ? [jasmineGlobalCleanupEntrypoint]
+            : [jasmineGlobalCleanupEntrypoint, zoneTestingEntryPoint],
+    ];
+}
+async function collectEntrypoints(options, context, projectSourceRoot) {
+    // Glob for files to test.
+    const testFiles = await (0, find_tests_1.findTests)(options.include, options.exclude, context.workspaceRoot, projectSourceRoot);
+    return (0, find_tests_1.getTestEntrypoints)(testFiles, { projectSourceRoot, workspaceRoot: context.workspaceRoot });
+}
+function hasChunkOrWorkerFiles(files) {
+    return Object.keys(files).some((filename) => {
+        return /(?:^|\/)(?:worker|chunk)[^/]+\.js$/.test(filename);
+    });
+}
+/** Returns the first item yielded by the given generator and cancels the execution. */
+async function first(generator, { cancel }) {
+    if (!cancel) {
+        const iterator = generator[Symbol.asyncIterator]();
+        const firstValue = await iterator.next();
+        if (firstValue.done) {
+            throw new Error('Expected generator to emit at least once.');
+        }
+        return [firstValue.value, iterator];
+    }
+    for await (const value of generator) {
+        return [value, null];
+    }
+    throw new Error('Expected generator to emit at least once.');
+}

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

@@ -98,11 +98,15 @@ 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 promises_1 = require("node:fs/promises");
+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 test_files_1 = require("../../utils/test-files");
 const application_1 = require("../application");
 const results_1 = require("../application/results");
 const options_1 = require("./options");
+const dependency_checker_1 = require("./runners/dependency-checker");
 async function loadTestRunner(runnerName) {
     // Harden against directory traversal
     if (!/^[a-zA-Z0-9-]+$/.test(runnerName)) {
@@ -148,7 +152,8 @@ function prepareBuildExtensions(virtualFiles, projectSourceRoot, extensions) {
     }
     return extensions;
 }
-async function* runBuildAndTest(executor, applicationBuildOptions, context, extensions) {
+async function* runBuildAndTest(executor, applicationBuildOptions, context, dumpDirectory, extensions) {
+    let consecutiveErrorCount = 0;
     for await (const buildResult of (0, application_1.buildApplicationInternal)(applicationBuildOptions, context, extensions)) {
         if (buildResult.kind === results_1.ResultKind.Failure) {
             yield { success: false };
@@ -159,65 +164,156 @@ async function* runBuildAndTest(executor, applicationBuildOptions, context, exte
             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.');
+        if (dumpDirectory) {
+            if (buildResult.kind === results_1.ResultKind.Full) {
+                // Full build, so clean the directory
+                await (0, promises_1.rm)(dumpDirectory, { recursive: true, force: true });
+            }
+            else {
+                // Incremental build, so delete removed files
+                for (const file of buildResult.removed) {
+                    await (0, promises_1.rm)(node_path_1.default.join(dumpDirectory, file.path), { force: true });
+                }
+            }
+            await (0, test_files_1.writeTestFiles)(buildResult.files, dumpDirectory);
+            context.logger.info(`Build output files successfully dumped to '${dumpDirectory}'.`);
+        }
         // Pass the build artifacts to the executor
-        yield* executor.execute(buildResult);
+        try {
+            yield* executor.execute(buildResult);
+            // Successful execution resets the failure counter
+            consecutiveErrorCount = 0;
+        }
+        catch (e) {
+            (0, error_1.assertIsError)(e);
+            context.logger.error(`An exception occurred during test execution:\n${e.stack ?? e.message}`);
+            yield { success: false };
+            consecutiveErrorCount++;
+        }
+        if (consecutiveErrorCount >= 3) {
+            context.logger.error('Test runner process has failed multiple times in a row. Please fix the configuration and restart the process.');
+            return;
+        }
     }
 }
 /**
  * @experimental Direct usage of this function is considered experimental.
  */
 async function* execute(options, context, extensions) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+    // 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.`);
+    // Initialize the test runner and normalize options
+    let runner;
+    let normalizedOptions;
     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;
+        normalizedOptions = await (0, options_1.normalizeOptions)(context, projectName, options);
+        runner = await loadTestRunner(normalizedOptions.runnerName);
+        await runner.validateDependencies?.(normalizedOptions);
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        if (e instanceof dependency_checker_1.MissingDependenciesError) {
+            context.logger.error(e.message);
         }
-        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;
+        else {
+            context.logger.error(`An exception occurred during initialization of the test runner:\n${e.stack ?? e.message}`);
         }
-        // Get base build options from the buildTarget
-        let buildTargetOptions;
+        yield { success: false };
+        return;
+    }
+    if (runner.isStandalone) {
         try {
-            buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const executor = __addDisposableResource(env_1, await runner.createExecutor(context, normalizedOptions, undefined), true);
+                yield* executor.execute({
+                    kind: results_1.ResultKind.Full,
+                    files: {},
+                });
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
         }
         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;
+            context.logger.error(`An exception occurred during standalone test execution:\n${e.stack ?? e.message}`);
+            yield { success: false };
         }
-        // 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);
+        return;
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    // Get base build options from the buildTarget
+    let buildTargetOptions;
+    try {
+        buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(normalizedOptions.buildTarget), await context.getBuilderNameForTarget(normalizedOptions.buildTarget)));
     }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
+    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}`);
+        yield { success: false };
+        return;
+    }
+    // Get runner-specific build options
+    let runnerBuildOptions;
+    let virtualFiles;
+    let testEntryPointMappings;
+    try {
+        ({
+            buildOptions: runnerBuildOptions,
+            virtualFiles,
+            testEntryPointMappings,
+        } = await runner.getBuildOptions(normalizedOptions, buildTargetOptions));
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error(`An exception occurred while getting runner-specific build options:\n${e.stack ?? e.message}`);
+        yield { success: false };
+        return;
+    }
+    try {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const executor = __addDisposableResource(env_2, await runner.createExecutor(context, normalizedOptions, testEntryPointMappings), true);
+            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,
+            };
+            const dumpDirectory = normalizedOptions.dumpVirtualFiles
+                ? node_path_1.default.join(normalizedOptions.cacheOptions.path, 'unit-test', 'output-files')
+                : undefined;
+            yield* runBuildAndTest(executor, applicationBuildOptions, context, dumpDirectory, finalExtensions);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    catch (e) {
+        (0, error_1.assertIsError)(e);
+        context.logger.error(`An exception occurred while creating the test executor:\n${e.stack ?? e.message}`);
+        yield { success: false };
     }
 }

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

@@ -16,6 +16,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     buildTarget: import("@angular-devkit/architect").Target;
     include: string[];
     exclude: string[] | undefined;
+    filter: string | undefined;
     runnerName: import("./schema").Runner;
     codeCoverage: {
         exclude: string[] | undefined;
@@ -23,11 +24,13 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     } | undefined;
     tsConfig: string;
     buildProgress: boolean | undefined;
-    reporters: string[] | undefined;
+    reporters: [string, Record<string, unknown>][] | undefined;
+    outputFile: string | undefined;
     browsers: string[] | undefined;
     watch: boolean;
     debug: boolean;
     providersFile: string | undefined;
     setupFiles: string[];
+    dumpVirtualFiles: boolean | undefined;
 }>;
 export declare function injectTestingPolyfills(polyfills?: string[]): string[];