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

package/builders.json

@@ -41,6 +41,11 @@
       "schema": "./src/builders/karma/schema.json",
       "description": "Run Karma unit tests."
     },
+    "web-test-runner": {
+      "implementation": "./src/builders/web-test-runner",
+      "schema": "./src/builders/web-test-runner/schema.json",
+      "description": "Run unit tests with Web Test Runner."
+    },
     "protractor": {
       "implementation": "./src/builders/protractor",
       "schema": "./src/builders/protractor/schema.json",

package/package.json

@@ -1,26 +1,26 @@
 {
   "name": "@angular-devkit/build-angular",
-  "version": "17.1.0-next.3",
+  "version": "17.1.0-rc.0",
   "description": "Angular Webpack Build Facade",
   "main": "src/index.js",
   "typings": "src/index.d.ts",
   "builders": "builders.json",
   "dependencies": {
     "@ampproject/remapping": "2.2.1",
-    "@angular-devkit/architect": "0.1701.0-next.3",
-    "@angular-devkit/build-webpack": "0.1701.0-next.3",
-    "@angular-devkit/core": "17.1.0-next.3",
-    "@babel/core": "7.23.6",
+    "@angular-devkit/architect": "0.1701.0-rc.0",
+    "@angular-devkit/build-webpack": "0.1701.0-rc.0",
+    "@angular-devkit/core": "17.1.0-rc.0",
+    "@babel/core": "7.23.7",
     "@babel/generator": "7.23.6",
     "@babel/helper-annotate-as-pure": "7.22.5",
     "@babel/helper-split-export-declaration": "7.22.6",
-    "@babel/plugin-transform-async-generator-functions": "7.23.4",
+    "@babel/plugin-transform-async-generator-functions": "7.23.7",
     "@babel/plugin-transform-async-to-generator": "7.23.3",
-    "@babel/plugin-transform-runtime": "7.23.6",
-    "@babel/preset-env": "7.23.6",
-    "@babel/runtime": "7.23.6",
+    "@babel/plugin-transform-runtime": "7.23.7",
+    "@babel/preset-env": "7.23.7",
+    "@babel/runtime": "7.23.7",
     "@discoveryjs/json-ext": "0.5.7",
-    "@ngtools/webpack": "17.1.0-next.3",
+    "@ngtools/webpack": "17.1.0-rc.0",
     "@vitejs/plugin-basic-ssl": "1.0.2",
     "ansi-colors": "4.1.3",
     "autoprefixer": "10.4.16",
@@ -30,7 +30,7 @@
     "copy-webpack-plugin": "11.0.0",
     "critters": "0.0.20",
     "css-loader": "6.8.1",
-    "esbuild-wasm": "0.19.10",
+    "esbuild-wasm": "0.19.11",
     "fast-glob": "3.3.2",
     "https-proxy-agent": "7.0.2",
     "http-proxy-middleware": "2.0.6",
@@ -50,19 +50,19 @@
     "picomatch": "3.0.1",
     "piscina": "4.2.1",
     "postcss": "8.4.32",
-    "postcss-loader": "7.3.3",
+    "postcss-loader": "7.3.4",
     "resolve-url-loader": "5.0.0",
     "rxjs": "7.8.1",
-    "sass": "1.69.5",
-    "sass-loader": "13.3.2",
+    "sass": "1.69.7",
+    "sass-loader": "13.3.3",
     "semver": "7.5.4",
-    "source-map-loader": "4.0.1",
+    "source-map-loader": "4.0.2",
     "source-map-support": "0.5.21",
     "terser": "5.26.0",
     "text-table": "0.2.0",
     "tree-kill": "1.2.2",
     "tslib": "2.6.2",
-    "undici": "6.2.0",
+    "undici": "6.2.1",
     "vite": "5.0.10",
     "watchpack": "2.4.0",
     "webpack": "5.89.0",
@@ -72,14 +72,15 @@
     "webpack-subresource-integrity": "5.1.0"
   },
   "optionalDependencies": {
-    "esbuild": "0.19.10"
+    "esbuild": "0.19.11"
   },
   "peerDependencies": {
     "@angular/compiler-cli": "^17.0.0 || ^17.1.0-next.0",
     "@angular/localize": "^17.0.0 || ^17.1.0-next.0",
     "@angular/platform-server": "^17.0.0 || ^17.1.0-next.0",
     "@angular/service-worker": "^17.0.0 || ^17.1.0-next.0",
-    "browser-sync": "^2.29.3",
+    "@web/test-runner": "^0.17.3",
+    "browser-sync": "^3.0.2",
     "jest": "^29.5.0",
     "jest-environment-jsdom": "^29.5.0",
     "karma": "^6.3.0",
@@ -98,6 +99,9 @@
     "@angular/service-worker": {
       "optional": true
     },
+    "@web/test-runner": {
+      "optional": true
+    },
     "browser-sync": {
       "optional": true
     },

package/src/builders/app-shell/index.js

@@ -139,6 +139,13 @@ async function _appShellBuilder(options, context) {
         serviceWorker: false,
         optimization: optimization,
     });
+    if (browserTargetRun.info.builderName === '@angular-devkit/build-angular:application') {
+        return {
+            success: false,
+            error: '"@angular-devkit/build-angular:application" has built-in app-shell generation capabilities. ' +
+                'The "appShell" option should be used instead.',
+        };
+    }
     const serverTargetRun = await context.scheduleTarget(serverTarget, {
         watch: false,
     });

package/src/builders/application/execute-build.js

@@ -93,9 +93,15 @@ async function executeBuild(options, context, rebuildState) {
     }
     // Analyze external imports if external options are enabled
     if (options.externalPackages || bundlingResult.externalConfiguration) {
-        const { browser = new Set(), server = new Set() } = bundlingResult.externalImports;
-        // TODO: Filter externalImports to generate third argument to support wildcard externalConfiguration values
-        executionResult.setExternalMetadata([...browser], [...server], bundlingResult.externalConfiguration);
+        const { externalConfiguration, externalImports: { browser, server }, } = bundlingResult;
+        const implicitBrowser = browser ? [...browser] : [];
+        const implicitServer = server ? [...server] : [];
+        // TODO: Implement wildcard externalConfiguration filtering
+        executionResult.setExternalMetadata(externalConfiguration
+            ? implicitBrowser.filter((value) => !externalConfiguration.includes(value))
+            : implicitBrowser, externalConfiguration
+            ? implicitServer.filter((value) => !externalConfiguration.includes(value))
+            : implicitServer, externalConfiguration);
     }
     const { metafile, initialFiles, outputFiles } = bundlingResult;
     executionResult.outputFiles.push(...outputFiles);

package/src/builders/application/options.js

@@ -284,10 +284,9 @@ function normalizeEntryPoints(workspaceRoot, browser, entryPoints = new Set()) {
             const entryPointName = node_path_1.default.isAbsolute(entryPoint)
                 ? parsedEntryPoint.name
                 : node_path_1.default.join(parsedEntryPoint.dir, parsedEntryPoint.name);
-            // Get the full file path to the entry point input.
-            const entryPointPath = node_path_1.default.isAbsolute(entryPoint)
-                ? entryPoint
-                : node_path_1.default.join(workspaceRoot, entryPoint);
+            // Get the full file path to a relative entry point input. Leave bare specifiers alone so they are resolved as modules.
+            const isRelativePath = entryPoint.startsWith('.');
+            const entryPointPath = isRelativePath ? node_path_1.default.join(workspaceRoot, entryPoint) : entryPoint;
             // Check for conflicts with previous entry points.
             const existingEntryPointPath = entryPointPaths[entryPointName];
             if (existingEntryPointPath) {

package/src/builders/application/schema.d.ts

@@ -291,7 +291,7 @@ export interface IndexObject {
      */
     output?: string;
     /**
-     * Generates 'preload', `modulepreload', and 'preconnect' link elements for initial
+     * Generates 'preload', 'modulepreload', and 'preconnect' link elements for initial
      * application files and resources.
      */
     preloadInitial?: boolean;

package/src/builders/application/schema.json

@@ -420,7 +420,7 @@
             "preloadInitial": {
               "type": "boolean",
               "default": true,
-              "description": "Generates 'preload', `modulepreload', and 'preconnect' link elements for initial application files and resources."
+              "description": "Generates 'preload', 'modulepreload', and 'preconnect' link elements for initial application files and resources."
             }
           },
           "required": ["input"]

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

@@ -96,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
@@ -615,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/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;