@angular-devkit/build-angular 17.1.0-next.2 → 17.1.0-rc.0

package/src/builders/application/schema.json

@@ -220,8 +220,41 @@
       "default": []
     },
     "outputPath": {
-      "type": "string",
-      "description": "The full path for the new output directory, relative to the current workspace."
+      "description": "Specify the output path relative to workspace root.",
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "base": {
+              "type": "string",
+              "description": "Specify the output path relative to workspace root."
+            },
+            "browser": {
+              "type": "string",
+              "pattern": "^[-\\w\\.]*$",
+              "default": "browser",
+              "description": "The output directory name of your browser build within the output path base. Defaults to 'browser'."
+            },
+            "server": {
+              "type": "string",
+              "pattern": "^[-\\w\\.]*$",
+              "default": "server",
+              "description": "The output directory name of your server build within the output path base. Defaults to 'server'."
+            },
+            "media": {
+              "type": "string",
+              "pattern": "^[-\\w\\.]+$",
+              "default": "media",
+              "description": "The output directory name of your media files within the output browser directory. Defaults to 'media'."
+            }
+          },
+          "required": ["base"],
+          "additionalProperties": false
+        },
+        {
+          "type": "string"
+        }
+      ]
     },
     "aot": {
       "type": "boolean",
@@ -383,6 +416,11 @@
               "minLength": 1,
               "default": "index.html",
               "description": "The output path of the application's generated HTML index file. The full provided path will be used and will be considered relative to the application's configured output path."
+            },
+            "preloadInitial": {
+              "type": "boolean",
+              "default": true,
+              "description": "Generates 'preload', 'modulepreload', and 'preconnect' link elements for initial application files and resources."
             }
           },
           "required": ["input"]

package/src/builders/browser-esbuild/index.js

@@ -31,13 +31,13 @@ async function* buildEsbuildBrowser(userOptions, context, infrastructureSettings
     (0, builder_status_warnings_1.logBuilderStatusWarnings)(userOptions, context);
     const normalizedOptions = normalizeOptions(userOptions);
     const { deleteOutputPath, outputPath } = normalizedOptions;
-    const fullOutputPath = node_path_1.default.join(context.workspaceRoot, outputPath);
+    const fullOutputPath = node_path_1.default.join(context.workspaceRoot, outputPath.base);
     if (deleteOutputPath && infrastructureSettings?.write !== false) {
-        await (0, utils_2.deleteOutputDir)(context.workspaceRoot, outputPath);
+        await (0, utils_2.deleteOutputDir)(context.workspaceRoot, outputPath.base);
     }
     for await (const result of (0, application_1.buildApplicationInternal)(normalizedOptions, context, {
         write: false,
-    }, plugins)) {
+    }, plugins && { codePlugins: plugins })) {
         if (infrastructureSettings?.write !== false && result.outputFiles) {
             // Write output files
             await writeResultFiles(result.outputFiles, result.assetFiles, fullOutputPath);
@@ -55,11 +55,15 @@ async function* buildEsbuildBrowser(userOptions, context, infrastructureSettings
 }
 exports.buildEsbuildBrowser = buildEsbuildBrowser;
 function normalizeOptions(options) {
-    const { main: browser, ngswConfigPath, serviceWorker, polyfills, ...otherOptions } = options;
+    const { main: browser, outputPath, ngswConfigPath, serviceWorker, polyfills, ...otherOptions } = options;
     return {
         browser,
         serviceWorker: serviceWorker ? ngswConfigPath : false,
         polyfills: typeof polyfills === 'string' ? [polyfills] : polyfills,
+        outputPath: {
+            base: outputPath,
+            browser: '',
+        },
         ...otherOptions,
     };
 }

package/src/builders/dev-server/vite-server.js

@@ -51,7 +51,6 @@ const supported_browsers_1 = require("../../utils/supported-browsers");
 const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
 const application_1 = require("../application");
 const browser_esbuild_1 = require("../browser-esbuild");
-const load_proxy_config_1 = require("./load-proxy-config");
 // eslint-disable-next-line max-lines-per-function
 async function* serveWithVite(serverOptions, builderName, context, transformers, extensions) {
     // Get the browser configuration from the target name.
@@ -97,7 +96,7 @@ async function* serveWithVite(serverOptions, builderName, context, transformers,
     // Always enable JIT linking to support applications built with and without AOT.
     // In a development environment the additional scope information does not
     // have a negative effect unlike production where final output size is relevant.
-    { sourcemap: true, jit: true, thirdPartySourcemaps }, 1, true);
+    { sourcemap: true, jit: true, thirdPartySourcemaps }, 1);
     // Extract output index from options
     // TODO: Provide this info from the build results
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -122,14 +121,10 @@ async function* serveWithVite(serverOptions, builderName, context, transformers,
         deferred?.();
     });
     const build = builderName === '@angular-devkit/build-angular:browser-esbuild'
-        ? browser_esbuild_1.buildEsbuildBrowser
-        : application_1.buildApplicationInternal;
+        ? browser_esbuild_1.buildEsbuildBrowser.bind(undefined, browserOptions, context, { write: false }, extensions?.buildPlugins)
+        : application_1.buildApplicationInternal.bind(undefined, browserOptions, context, { write: false }, { codePlugins: extensions?.buildPlugins });
     // TODO: Switch this to an architect schedule call when infrastructure settings are supported
-    for await (const result of build(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    browserOptions, context, {
-        write: false,
-    }, extensions?.buildPlugins)) {
+    for await (const result of build()) {
         (0, node_assert_1.default)(result.outputFiles, 'Builder did not provide result files.');
         // If build failed, nothing to serve
         if (!result.success) {
@@ -331,7 +326,7 @@ function analyzeResultFiles(normalizePath, htmlIndexPath, resultFiles, generated
 }
 // eslint-disable-next-line max-lines-per-function
 async function setupServer(serverOptions, outputFiles, assets, preserveSymlinks, externalMetadata, ssr, prebundleTransformer, target, prebundleLoaderExtensions, extensionMiddleware, indexHtmlTransformer, thirdPartySourcemaps = false) {
-    const proxy = await (0, load_proxy_config_1.loadProxyConfiguration)(serverOptions.workspaceRoot, serverOptions.proxyConfig, true);
+    const proxy = await (0, utils_2.loadProxyConfiguration)(serverOptions.workspaceRoot, serverOptions.proxyConfig, true);
     // dynamically import Vite for ESM compatibility
     const { normalizePath } = await (0, load_esm_1.loadEsmModule)('vite');
     // Path will not exist on disk and only used to provide separate path for Vite requests
@@ -532,11 +527,9 @@ async function setupServer(serverOptions, outputFiles, assets, preserveSymlinks,
                                 return;
                             }
                             transformIndexHtmlAndAddHeaders(url, rawHtml, res, next, async (html) => {
-                                const protocol = serverOptions.ssl ? 'https' : 'http';
-                                const route = `${protocol}://${req.headers.host}${req.originalUrl}`;
                                 const { content } = await (0, render_page_1.renderPage)({
                                     document: html,
-                                    route,
+                                    route: new URL(req.originalUrl ?? '/', server.resolvedUrls?.local[0]).toString(),
                                     serverContext: 'ssr',
                                     loadBundle: (uri) => 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -622,6 +615,7 @@ async function setupServer(serverOptions, outputFiles, assets, preserveSymlinks,
         }
         else {
             const { default: basicSslPlugin } = await Promise.resolve().then(() => __importStar(require('@vitejs/plugin-basic-ssl')));
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             configuration.plugins ??= [];
             configuration.plugins.push(basicSslPlugin());
         }

package/src/builders/jest/index.js

@@ -35,10 +35,10 @@ const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const util_1 = require("util");
 const color_1 = require("../../utils/color");
+const test_files_1 = require("../../utils/test-files");
 const application_1 = require("../application");
 const schema_1 = require("../browser-esbuild/schema");
 const options_1 = require("./options");
-const test_files_1 = require("./test-files");
 const execFile = (0, util_1.promisify)(child_process_1.execFile);
 /** Main execution function for the Jest builder. */
 exports.default = (0, architect_1.createBuilder)(async (schema, context) => {
@@ -66,7 +66,7 @@ exports.default = (0, architect_1.createBuilder)(async (schema, context) => {
         };
     }
     // Build all the test files.
-    const testFiles = await (0, test_files_1.findTestFiles)(options, context.workspaceRoot);
+    const testFiles = await (0, test_files_1.findTestFiles)(options.include, options.exclude, context.workspaceRoot);
     const jestGlobal = path.join(__dirname, 'jest-global.mjs');
     const initTestBed = path.join(__dirname, 'init-test-bed.mjs');
     const buildResult = await build(context, {

package/src/builders/prerender/index.js

@@ -93,6 +93,13 @@ async function _scheduleBuilds(options, context) {
         serviceWorker: false,
         // todo: handle service worker augmentation
     });
+    if (browserTargetRun.info.builderName === '@angular-devkit/build-angular:application') {
+        return {
+            success: false,
+            error: '"@angular-devkit/build-angular:application" has built-in prerendering capabilities. ' +
+                'The "prerender" option should be used instead.',
+        };
+    }
     const serverTargetRun = await context.scheduleTarget(serverTarget, {
         watch: false,
     });

package/src/builders/ssr-dev-server/index.js

@@ -36,8 +36,8 @@ const core_1 = require("@angular-devkit/core");
 const path_1 = require("path");
 const rxjs_1 = require("rxjs");
 const url = __importStar(require("url"));
-const error_1 = require("../../utils/error");
-const utils_1 = require("./utils");
+const utils_1 = require("../../utils");
+const utils_2 = require("./utils");
 /** Log messages to ignore and not rely to the logger */
 const IGNORED_STDOUT_MESSAGES = [
     'server listening on',
@@ -78,7 +78,7 @@ function execute(options, context) {
   DON'T USE IT FOR PRODUCTION!
   ****************************************************************************************
  `);
-    return (0, rxjs_1.zip)(browserTargetRun, serverTargetRun, (0, utils_1.getAvailablePort)()).pipe((0, rxjs_1.switchMap)(([br, sr, nodeServerPort]) => {
+    return (0, rxjs_1.zip)(browserTargetRun, serverTargetRun, (0, utils_2.getAvailablePort)()).pipe((0, rxjs_1.switchMap)(([br, sr, nodeServerPort]) => {
         return (0, rxjs_1.combineLatest)([br.output, sr.output]).pipe(
         // This is needed so that if both server and browser emit close to each other
         // we only emit once. This typically happens on the first build.
@@ -101,7 +101,7 @@ function execute(options, context) {
                 context.logger.info('\nCompiled successfully.');
             }
         }), (0, rxjs_1.debounce)(([builderOutput]) => builderOutput.success && !options.inspect
-            ? (0, utils_1.waitUntilServerIsListening)(nodeServerPort)
+            ? (0, utils_2.waitUntilServerIsListening)(nodeServerPort)
             : rxjs_1.EMPTY), (0, rxjs_1.finalize)(() => {
             void br.stop();
             void sr.stop();
@@ -162,7 +162,7 @@ function startNodeServer(serverOutput, port, logger, inspectMode = false) {
         args.unshift('--inspect-brk');
     }
     return (0, rxjs_1.of)(null).pipe((0, rxjs_1.delay)(0), // Avoid EADDRINUSE error since it will cause the kill event to be finish.
-    (0, rxjs_1.switchMap)(() => (0, utils_1.spawnAsObservable)('node', args, { env, shell: true })), (0, rxjs_1.tap)((res) => log({ stderr: res.stderr, stdout: res.stdout }, logger)), (0, rxjs_1.ignoreElements)(), 
+    (0, rxjs_1.switchMap)(() => (0, utils_2.spawnAsObservable)('node', args, { env, shell: true })), (0, rxjs_1.tap)((res) => log({ stderr: res.stderr, stdout: res.stdout }, logger)), (0, rxjs_1.ignoreElements)(), 
     // Emit a signal after the process has been started
     (0, rxjs_1.startWith)(undefined));
 }
@@ -171,7 +171,7 @@ async function initBrowserSync(browserSyncInstance, nodeServerPort, options, con
         return browserSyncInstance;
     }
     const { port: browserSyncPort, open, host, publicHost, proxyConfig } = options;
-    const bsPort = browserSyncPort || (await (0, utils_1.getAvailablePort)());
+    const bsPort = browserSyncPort || (await (0, utils_2.getAvailablePort)());
     const bsOptions = {
         proxy: {
             target: `localhost:${nodeServerPort}`,
@@ -283,33 +283,19 @@ function getSslConfig(root, options) {
     return ssl;
 }
 async function getProxyConfig(root, proxyConfig) {
-    const proxyPath = (0, path_1.resolve)(root, proxyConfig);
-    let proxySettings;
-    try {
-        proxySettings = require(proxyPath);
-    }
-    catch (error) {
-        (0, error_1.assertIsError)(error);
-        if (error.code === 'MODULE_NOT_FOUND') {
-            throw new Error(`Proxy config file ${proxyPath} does not exist.`);
-        }
-        throw error;
-    }
-    const proxies = Array.isArray(proxySettings) ? proxySettings : [proxySettings];
+    const proxy = await (0, utils_1.loadProxyConfiguration)(root, proxyConfig, false);
     const createdProxies = [];
     const { createProxyMiddleware } = await Promise.resolve().then(() => __importStar(require('http-proxy-middleware')));
-    for (const proxy of proxies) {
-        for (const [key, context] of Object.entries(proxy)) {
-            if (typeof key === 'string') {
-                createdProxies.push(createProxyMiddleware(key.replace(/^\*$/, '**').replace(/\/\*$/, ''), 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                context));
-            }
-            else {
-                createdProxies.push(
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                createProxyMiddleware(key, context));
-            }
+    for (const [key, context] of Object.entries(proxy)) {
+        if (typeof key === 'string') {
+            createdProxies.push(createProxyMiddleware(key.replace(/^\*$/, '**').replace(/\/\*$/, ''), 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            context));
+        }
+        else {
+            createdProxies.push(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            createProxyMiddleware(key, context));
         }
     }
     return createdProxies;

package/src/builders/web-test-runner/builder-status-warnings.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.io/license
+ */
+import { BuilderContext } from '@angular-devkit/architect';
+import { Schema as WtrBuilderOptions } from './schema';
+/** Logs a warning for any unsupported options specified. */
+export declare function logBuilderStatusWarnings(options: WtrBuilderOptions, ctx: BuilderContext): void;

package/src/builders/web-test-runner/builder-status-warnings.js

@@ -0,0 +1,46 @@
+"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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logBuilderStatusWarnings = void 0;
+const UNSUPPORTED_OPTIONS = [
+    'main',
+    'assets',
+    'scripts',
+    'styles',
+    'inlineStyleLanguage',
+    'stylePreprocessorOptions',
+    'sourceMap',
+    'progress',
+    'poll',
+    'preserveSymlinks',
+    'browsers',
+    'codeCoverage',
+    'codeCoverageExclude',
+    'fileReplacements',
+    'webWorkerTsConfig',
+    'watch',
+];
+/** Logs a warning for any unsupported options specified. */
+function logBuilderStatusWarnings(options, ctx) {
+    // Validate supported options
+    for (const unsupportedOption of UNSUPPORTED_OPTIONS) {
+        const value = options[unsupportedOption];
+        if (value === undefined || value === false) {
+            continue;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+            continue;
+        }
+        if (typeof value === 'object' && Object.keys(value).length === 0) {
+            continue;
+        }
+        ctx.logger.warn(`The '${unsupportedOption}' option is not yet supported by this builder.`);
+    }
+}
+exports.logBuilderStatusWarnings = logBuilderStatusWarnings;

package/src/builders/web-test-runner/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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.io/license
+ */
+import { Schema } from './schema';
+declare const _default: import("../../../../architect/src/internal").Builder<Schema & import("../../../../core/src").JsonObject>;
+export default _default;

package/src/builders/web-test-runner/index.js

@@ -0,0 +1,151 @@
+"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.io/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const architect_1 = require("@angular-devkit/architect");
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const test_files_1 = require("../../utils/test-files");
+const application_1 = require("../application");
+const schema_1 = require("../browser-esbuild/schema");
+const builder_status_warnings_1 = require("./builder-status-warnings");
+const options_1 = require("./options");
+exports.default = (0, architect_1.createBuilder)(async (schema, ctx) => {
+    ctx.logger.warn('NOTE: The Web Test Runner builder is currently EXPERIMENTAL and not ready for production use.');
+    (0, builder_status_warnings_1.logBuilderStatusWarnings)(schema, ctx);
+    // Dynamic import `@web/test-runner` from the user's workspace. As an optional peer dep, it may not be installed
+    // and may not be resolvable from `@angular-devkit/build-angular`.
+    const require = (0, node_module_1.createRequire)(`${ctx.workspaceRoot}/`);
+    let wtr;
+    try {
+        wtr = require('@web/test-runner');
+    }
+    catch {
+        return {
+            success: false,
+            // TODO(dgp1130): Display a more accurate message for non-NPM users.
+            error: 'Web Test Runner is not installed, most likely you need to run `npm install @web/test-runner --save-dev` in your project.',
+        };
+    }
+    const options = (0, options_1.normalizeOptions)(schema);
+    const testDir = 'dist/test-out';
+    // Parallelize startup work.
+    const [testFiles] = await Promise.all([
+        // Glob for files to test.
+        (0, test_files_1.findTestFiles)(options.include, options.exclude, ctx.workspaceRoot).then((files) => Array.from(files).map((file) => node_path_1.default.relative(process.cwd(), file))),
+        // Clean build output path.
+        node_fs_1.promises.rm(testDir, { recursive: true, force: true }),
+    ]);
+    // Build the tests and abort on any build failure.
+    const buildOutput = await buildTests(testFiles, testDir, options, ctx);
+    if (!buildOutput.success) {
+        return buildOutput;
+    }
+    // Run the built tests.
+    return await runTests(wtr, `${testDir}/browser`, options);
+});
+/** Build all the given test files and write the result to the given output path. */
+async function buildTests(testFiles, outputPath, options, ctx) {
+    const entryPoints = new Set([
+        ...testFiles,
+        'jasmine-core/lib/jasmine-core/jasmine.js',
+        '@angular-devkit/build-angular/src/builders/web-test-runner/jasmine_runner.js',
+    ]);
+    // Extract `zone.js/testing` to a separate entry point because it needs to be loaded after Jasmine.
+    const [polyfills, hasZoneTesting] = extractZoneTesting(options.polyfills);
+    if (hasZoneTesting) {
+        entryPoints.add('zone.js/testing');
+    }
+    // Build tests with `application` builder, using test files as entry points.
+    // Also bundle in Jasmine and the Jasmine runner script, which need to share chunked dependencies.
+    const buildOutput = await first((0, application_1.buildApplicationInternal)({
+        entryPoints,
+        tsConfig: options.tsConfig,
+        outputPath,
+        aot: false,
+        index: false,
+        outputHashing: schema_1.OutputHashing.None,
+        optimization: false,
+        externalDependencies: [
+            // Resolved by `@web/test-runner` at runtime with dynamically generated code.
+            '@web/test-runner-core',
+        ],
+        sourceMap: {
+            scripts: true,
+            styles: true,
+            vendor: true,
+        },
+        polyfills,
+    }, ctx));
+    return buildOutput;
+}
+function extractZoneTesting(polyfills) {
+    const polyfillsWithoutZoneTesting = polyfills.filter((polyfill) => polyfill !== 'zone.js/testing');
+    const hasZoneTesting = polyfills.length !== polyfillsWithoutZoneTesting.length;
+    return [polyfillsWithoutZoneTesting, hasZoneTesting];
+}
+/** Run Web Test Runner on the given directory of bundled JavaScript tests. */
+async function runTests(wtr, testDir, options) {
+    const testPagePath = node_path_1.default.resolve(__dirname, 'test_page.html');
+    const testPage = await node_fs_1.promises.readFile(testPagePath, 'utf8');
+    const runner = await wtr.startTestRunner({
+        config: {
+            rootDir: testDir,
+            files: [
+                `${testDir}/**/*.js`,
+                `!${testDir}/polyfills.js`,
+                `!${testDir}/chunk-*.js`,
+                `!${testDir}/jasmine.js`,
+                `!${testDir}/jasmine_runner.js`,
+                `!${testDir}/testing.js`, // `zone.js/testing`
+            ],
+            testFramework: {
+                config: {
+                    defaultTimeoutInterval: 5000,
+                },
+            },
+            nodeResolve: true,
+            port: 9876,
+            watch: options.watch ?? false,
+            testRunnerHtml: (_testFramework, _config) => testPage,
+        },
+        readCliArgs: false,
+        readFileConfig: false,
+        autoExitProcess: false,
+    });
+    if (!runner) {
+        throw new Error('Failed to start Web Test Runner.');
+    }
+    // Wait for the tests to complete and stop the runner.
+    const passed = (await once(runner, 'finished'));
+    await runner.stop();
+    // No need to return error messages because Web Test Runner already printed them to the console.
+    return { success: passed };
+}
+/** Returns the first item yielded by the given generator and cancels the execution. */
+async function first(generator) {
+    for await (const value of generator) {
+        return value;
+    }
+    throw new Error('Expected generator to emit at least once.');
+}
+/** Listens for a single emission of an event and returns the value emitted. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function once(emitter, event) {
+    return new Promise((resolve) => {
+        const onEmit = (arg) => {
+            emitter.off(event, onEmit);
+            resolve(arg);
+        };
+        emitter.on(event, onEmit);
+    });
+}

package/src/builders/web-test-runner/jasmine_runner.js

@@ -0,0 +1,88 @@
+/**
+ * @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.io/license
+ */
+
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+import {
+  getConfig,
+  sessionFailed,
+  sessionFinished,
+  sessionStarted,
+} from '@web/test-runner-core/browser/session.js';
+
+/** Executes Angular Jasmine tests in the given environment and reports the results to Web Test Runner. */
+export async function runJasmineTests(jasmineEnv) {
+  const allSpecs = [];
+  const failedSpecs = [];
+
+  jasmineEnv.addReporter({
+    specDone(result) {
+      const expectations = [...result.passedExpectations, ...result.failedExpectations];
+      allSpecs.push(...expectations.map((e) => ({ name: e.fullName, passed: e.passed })));
+
+      for (const e of result.failedExpectations) {
+        const message = `${result.fullName}\n${e.message}\n${e.stack}`;
+        // eslint-disable-next-line no-console
+        console.error(message);
+        failedSpecs.push({
+          message,
+          name: e.fullName,
+          stack: e.stack,
+          expected: e.expected,
+          actual: e.actual,
+        });
+      }
+    },
+
+    async jasmineDone(result) {
+      // eslint-disable-next-line no-console
+      console.log(`Tests ${result.overallStatus}!`);
+      await sessionFinished({
+        passed: result.overallStatus === 'passed',
+        errors: failedSpecs,
+        testResults: {
+          name: '',
+          suites: [],
+          tests: allSpecs,
+        },
+      });
+    },
+  });
+
+  await sessionStarted();
+
+  // Web Test Runner uses a different HTML page for every test, so we only get one `testFile` for the single `*.js` file we need to execute.
+  const { testFile, testFrameworkConfig } = await getConfig();
+  const config = { defaultTimeoutInterval: 60_000, ...(testFrameworkConfig ?? {}) };
+
+  // eslint-disable-next-line no-undef
+  jasmine.DEFAULT_TIMEOUT_INTERVAL = config.defaultTimeoutInterval;
+
+  // Initialize `TestBed` automatically for users. This assumes we already evaluated `zone.js/testing`.
+  getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), {
+    errorOnUnknownElements: true,
+    errorOnUnknownProperties: true,
+  });
+
+  // Load the test file and evaluate it.
+  try {
+    // eslint-disable-next-line no-undef
+    await import(new URL(testFile, document.baseURI).href);
+
+    // Execute the test functions.
+    // eslint-disable-next-line no-undef
+    jasmineEnv.execute();
+  } catch (err) {
+    // eslint-disable-next-line no-console
+    console.error(err);
+    await sessionFailed(err);
+  }
+}

package/src/builders/web-test-runner/options.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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.io/license
+ */
+import { Schema as WtrBuilderSchema } from './schema';
+/**
+ * Options supported for the Web Test Runner builder. The schema is an approximate
+ * representation of the options type, but this is a more precise version.
+ */
+export type WtrBuilderOptions = Overwrite<WtrBuilderSchema, {
+    include: string[];
+    exclude: string[];
+    polyfills: string[];
+}>;
+type Overwrite<Obj extends {}, Overrides extends {}> = Omit<Obj, keyof Overrides> & Overrides;
+/**
+ * Normalizes input options validated by the schema to a more precise and useful
+ * options type in {@link WtrBuilderOptions}.
+ */
+export declare function normalizeOptions(schema: WtrBuilderSchema): WtrBuilderOptions;
+export {};

package/src/builders/web-test-runner/options.js

@@ -0,0 +1,26 @@
+"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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+/**
+ * Normalizes input options validated by the schema to a more precise and useful
+ * options type in {@link WtrBuilderOptions}.
+ */
+function normalizeOptions(schema) {
+    return {
+        ...schema,
+        // Options with default values can't actually be null, even if the types say so.
+        /* eslint-disable @typescript-eslint/no-non-null-assertion */
+        include: schema.include,
+        exclude: schema.exclude,
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+        polyfills: typeof schema.polyfills === 'string' ? [schema.polyfills] : schema.polyfills ?? [],
+    };
+}
+exports.normalizeOptions = normalizeOptions;