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

package/src/builders/unit-test/schema.json

@@ -6,20 +6,20 @@
   "properties": {
     "buildTarget": {
       "type": "string",
-      "description": "A build builder target to serve in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.",
+      "description": "Specifies the build target to use for the unit test build in the format `project:target[:configuration]`. You can also pass a comma-separated list of configurations. Example: `project:target:production,staging`.",
       "pattern": "^[^:\\s]*:[^:\\s]*(:[^\\s]+)?$"
     },
     "tsConfig": {
       "type": "string",
-      "description": "The name of the TypeScript configuration file."
+      "description": "The path to the TypeScript configuration file, relative to the workspace root."
     },
     "runner": {
       "type": "string",
-      "description": "The name of the test runner to use for test execution.",
+      "description": "Specifies the test runner to use for test execution.",
       "enum": ["karma", "vitest"]
     },
     "browsers": {
-      "description": "A list of browsers to use for test execution. If undefined, jsdom on Node.js will be used instead of a browser. For Vitest and Karma, browser names ending with 'Headless' (e.g., 'ChromeHeadless') will enable headless mode for that browser.",
+      "description": "Specifies the browsers to use for test execution. When not specified, tests are run in a Node.js environment using jsdom. For both Vitest and Karma, browser names ending with 'Headless' (e.g., 'ChromeHeadless') will enable headless mode.",
       "type": "array",
       "items": {
         "type": "string"
@@ -32,39 +32,43 @@
         "type": "string"
       },
       "default": ["**/*.spec.ts"],
-      "description": "Globs of files to include, relative to project root. \nThere are 2 special cases:\n - when a path to directory is provided, all spec files ending \".spec.@(ts|tsx)\" will be included\n - when a path to a file is provided, and a matching spec file exists it will be included instead."
+      "description": "Specifies glob patterns of files to include for testing, relative to the project root. This option also has special handling for directory paths (includes all `.spec.ts` files within) and file paths (includes the corresponding `.spec` file if one exists)."
     },
     "exclude": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "Globs of files to exclude, relative to the project root."
+      "description": "Specifies glob patterns of files to exclude from testing, relative to the project root."
+    },
+    "filter": {
+      "type": "string",
+      "description": "Specifies a regular expression pattern to match against test suite and test names. Only tests with a name matching the pattern will be executed. For example, `^App` will run only tests in suites beginning with 'App'."
     },
     "watch": {
       "type": "boolean",
-      "description": "Re-run tests when source files change. Defaults to `true` in TTY environments and `false` otherwise."
+      "description": "Enables watch mode, which re-runs tests when source files change. Defaults to `true` in TTY environments and `false` otherwise."
     },
     "debug": {
       "type": "boolean",
-      "description": "Initialize the test runner to support using the Node Inspector for test debugging.",
+      "description": "Enables debugging mode for tests, allowing the use of the Node Inspector.",
       "default": false
     },
     "codeCoverage": {
       "type": "boolean",
-      "description": "Output a code coverage report.",
+      "description": "Enables code coverage reporting for tests.",
       "default": false
     },
     "codeCoverageExclude": {
       "type": "array",
-      "description": "Globs to exclude from code coverage.",
+      "description": "Specifies glob patterns of files to exclude from the code coverage report.",
       "items": {
         "type": "string"
       }
     },
     "codeCoverageReporters": {
       "type": "array",
-      "description": "Reporters to use for code coverage results.",
+      "description": "Specifies the reporters to use for code coverage results. Each reporter can be a string representing its name, or a tuple containing the name and an options object. Built-in reporters include 'html', 'lcov', 'lcovonly', 'text', 'text-summary', 'cobertura', 'json', and 'json-summary'.",
       "items": {
         "oneOf": [
           {
@@ -88,14 +92,49 @@
     },
     "reporters": {
       "type": "array",
-      "description": "Test runner reporters to use. Directly passed to the test runner.",
+      "description": "Specifies the reporters to use during test execution. Each reporter can be a string representing its name, or a tuple containing the name and an options object. Built-in reporters include 'default', 'verbose', 'dots', 'json', 'junit', 'tap', 'tap-flat', and 'html'. You can also provide a path to a custom reporter.",
       "items": {
-        "type": "string"
+        "oneOf": [
+          {
+            "anyOf": [
+              {
+                "$ref": "#/definitions/reporters-enum"
+              },
+              {
+                "type": "string"
+              }
+            ]
+          },
+          {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 2,
+            "items": [
+              {
+                "anyOf": [
+                  {
+                    "$ref": "#/definitions/reporters-enum"
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
+              },
+              {
+                "type": "object"
+              }
+            ]
+          }
+        ]
       }
     },
+    "outputFile": {
+      "type": "string",
+      "description": "Specifies a file path for the test report, applying only to the first reporter. To configure output files for multiple reporters, use the tuple format `['reporter-name', { outputFile: '...' }]` within the `reporters` option. When not provided, output is written to the console."
+    },
     "providersFile": {
       "type": "string",
-      "description": "TypeScript file that exports an array of Angular providers to use during test execution. The array must be a default export.",
+      "description": "Specifies the path to a TypeScript file that provides an array of Angular providers for the test environment. The file must contain a default export of the provider array.",
       "minLength": 1
     },
     "setupFiles": {
@@ -103,11 +142,22 @@
       "items": {
         "type": "string"
       },
-      "description": "A list of global setup and configuration files that are included before the test files. The application's polyfills are always included before these files. The Angular Testbed is also initialized prior to the execution of these files."
+      "description": "A list of paths to global setup files that are executed before the test files. The application's polyfills and the Angular TestBed are always initialized before these files."
     },
     "progress": {
       "type": "boolean",
-      "description": "Log progress to the console while building. Defaults to the build target's progress value."
+      "description": "Shows build progress information in the console. Defaults to the `progress` setting of the specified `buildTarget`."
+    },
+    "listTests": {
+      "type": "boolean",
+      "description": "Lists all discovered test files and exits the process without building or executing the tests.",
+      "default": false
+    },
+    "dumpVirtualFiles": {
+      "type": "boolean",
+      "description": "Dumps build output files to the `.angular/cache` directory for debugging purposes.",
+      "default": false,
+      "visible": false
     }
   },
   "additionalProperties": false,
@@ -124,6 +174,10 @@
         "json",
         "json-summary"
       ]
+    },
+    "reporters-enum": {
+      "type": "string",
+      "enum": ["default", "verbose", "dots", "json", "junit", "tap", "tap-flat", "html"]
     }
   }
 }

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

@@ -5,4 +5,28 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-export { findTests, getTestEntrypoints } from '../karma/find-tests';
+/**
+ * Finds all test files in the project.
+ *
+ * @param include Glob patterns of files to include.
+ * @param exclude Glob patterns of files to exclude.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A unique set of absolute paths to all test files.
+ */
+export declare function findTests(include: string[], exclude: string[], workspaceRoot: string, projectSourceRoot: string): Promise<string[]>;
+interface TestEntrypointsOptions {
+    projectSourceRoot: string;
+    workspaceRoot: string;
+    removeTestExtension?: boolean;
+}
+/**
+ * Generates unique, dash-delimited bundle names for a set of test files.
+ * This is used to create distinct output files for each test.
+ *
+ * @param testFiles An array of absolute paths to test files.
+ * @param options Configuration options for generating entry points.
+ * @returns A map where keys are the generated unique bundle names and values are the original file paths.
+ */
+export declare function getTestEntrypoints(testFiles: string[], { projectSourceRoot, workspaceRoot, removeTestExtension }: TestEntrypointsOptions): Map<string, string>;
+export {};

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

@@ -7,8 +7,197 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTestEntrypoints = exports.findTests = void 0;
-// TODO: This should eventually contain the implementations for these
-var find_tests_1 = require("../karma/find-tests");
-Object.defineProperty(exports, "findTests", { enumerable: true, get: function () { return find_tests_1.findTests; } });
-Object.defineProperty(exports, "getTestEntrypoints", { enumerable: true, get: function () { return find_tests_1.getTestEntrypoints; } });
+exports.findTests = findTests;
+exports.getTestEntrypoints = getTestEntrypoints;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const tinyglobby_1 = require("tinyglobby");
+const path_1 = require("../../utils/path");
+/**
+ * Finds all test files in the project.
+ *
+ * @param include Glob patterns of files to include.
+ * @param exclude Glob patterns of files to exclude.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A unique set of absolute paths to all test files.
+ */
+async function findTests(include, exclude, workspaceRoot, projectSourceRoot) {
+    const staticMatches = new Set();
+    const dynamicPatterns = [];
+    const normalizedExcludes = exclude.map((p) => normalizePattern(p, workspaceRoot, projectSourceRoot));
+    // 1. Separate static and dynamic patterns
+    for (const pattern of include) {
+        const normalized = normalizePattern(pattern, workspaceRoot, projectSourceRoot);
+        if ((0, tinyglobby_1.isDynamicPattern)(normalized)) {
+            dynamicPatterns.push(normalized);
+        }
+        else {
+            const result = await handleStaticPattern(normalized, projectSourceRoot);
+            if (Array.isArray(result)) {
+                result.forEach((file) => staticMatches.add(file));
+            }
+            else {
+                // It was a static path that didn't resolve to a spec, treat as dynamic
+                dynamicPatterns.push(result);
+            }
+        }
+    }
+    // 2. Execute a single glob for all dynamic patterns
+    if (dynamicPatterns.length > 0) {
+        const globMatches = await (0, tinyglobby_1.glob)(dynamicPatterns, {
+            cwd: projectSourceRoot,
+            absolute: true,
+            ignore: ['**/node_modules/**', ...normalizedExcludes],
+        });
+        for (const match of globMatches) {
+            staticMatches.add(match);
+        }
+    }
+    // 3. Combine and de-duplicate results
+    return [...staticMatches];
+}
+/**
+ * Generates unique, dash-delimited bundle names for a set of test files.
+ * This is used to create distinct output files for each test.
+ *
+ * @param testFiles An array of absolute paths to test files.
+ * @param options Configuration options for generating entry points.
+ * @returns A map where keys are the generated unique bundle names and values are the original file paths.
+ */
+function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot, removeTestExtension }) {
+    const seen = new Set();
+    const roots = [projectSourceRoot, workspaceRoot];
+    return new Map(Array.from(testFiles, (testFile) => {
+        const fileName = generateNameFromPath(testFile, roots, !!removeTestExtension);
+        const baseName = `spec-${fileName}`;
+        let uniqueName = baseName;
+        let suffix = 2;
+        while (seen.has(uniqueName)) {
+            uniqueName = `${baseName}-${suffix}`.replace(/([^\w](?:spec|test))-([\d]+)$/, '-$2$1');
+            ++suffix;
+        }
+        seen.add(uniqueName);
+        return [uniqueName, testFile];
+    }));
+}
+/**
+ * Generates a unique, dash-delimited name from a file path.
+ * This is used to create a consistent and readable bundle name for a given test file.
+ * @param testFile The absolute path to the test file.
+ * @param roots An array of root paths to remove from the beginning of the test file path.
+ * @param removeTestExtension Whether to remove the `.spec` or `.test` extension from the result.
+ * @returns A dash-cased name derived from the relative path of the test file.
+ */
+function generateNameFromPath(testFile, roots, removeTestExtension) {
+    const relativePath = removeRoots(testFile, roots);
+    let startIndex = 0;
+    // Skip leading dots and slashes
+    while (startIndex < relativePath.length && /^[./\\]$/.test(relativePath[startIndex])) {
+        startIndex++;
+    }
+    let endIndex = relativePath.length;
+    if (removeTestExtension) {
+        const match = relativePath.match(/\.(spec|test)\.[^.]+$/);
+        if (match?.index) {
+            endIndex = match.index;
+        }
+    }
+    else {
+        const extIndex = relativePath.lastIndexOf('.');
+        if (extIndex > startIndex) {
+            endIndex = extIndex;
+        }
+    }
+    // Build the final string in a single pass
+    let result = '';
+    for (let i = startIndex; i < endIndex; i++) {
+        const char = relativePath[i];
+        result += char === '/' || char === '\\' ? '-' : char;
+    }
+    return result;
+}
+const removeLeadingSlash = (pattern) => {
+    if (pattern.charAt(0) === '/') {
+        return pattern.substring(1);
+    }
+    return pattern;
+};
+const removeRelativeRoot = (path, root) => {
+    if (path.startsWith(root)) {
+        return path.substring(root.length);
+    }
+    return path;
+};
+/**
+ * Removes potential root paths from a file path, returning a relative path.
+ * If no root path matches, it returns the file's basename.
+ */
+function removeRoots(path, roots) {
+    for (const root of roots) {
+        if (path.startsWith(root)) {
+            return path.substring(root.length);
+        }
+    }
+    return (0, node_path_1.basename)(path);
+}
+/**
+ * Normalizes a glob pattern by converting it to a POSIX path, removing leading slashes,
+ * and making it relative to the project source root.
+ *
+ * @param pattern The glob pattern to normalize.
+ * @param workspaceRoot The absolute path to the workspace root.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A normalized glob pattern.
+ */
+function normalizePattern(pattern, workspaceRoot, projectSourceRoot) {
+    // normalize pattern, glob lib only accepts forward slashes
+    let normalizedPattern = (0, path_1.toPosixPath)(pattern);
+    normalizedPattern = removeLeadingSlash(normalizedPattern);
+    const relativeProjectRoot = (0, path_1.toPosixPath)((0, node_path_1.relative)(workspaceRoot, projectSourceRoot) + '/');
+    // remove relativeProjectRoot to support relative paths from root
+    // such paths are easy to get when running scripts via IDEs
+    return removeRelativeRoot(normalizedPattern, relativeProjectRoot);
+}
+/**
+ * Handles static (non-glob) patterns by attempting to resolve them to a directory
+ * of spec files or a corresponding `.spec` file.
+ *
+ * @param pattern The static path pattern.
+ * @param projectSourceRoot The absolute path to the project's source root.
+ * @returns A promise that resolves to either an array of found spec files, a new glob pattern,
+ * or the original pattern if no special handling was applied.
+ */
+async function handleStaticPattern(pattern, projectSourceRoot) {
+    const fullPath = (0, node_path_1.join)(projectSourceRoot, pattern);
+    if (await isDirectory(fullPath)) {
+        return `${pattern}/**/*.spec.@(ts|tsx)`;
+    }
+    const fileExt = (0, node_path_1.extname)(pattern);
+    // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts`
+    const potentialSpec = (0, node_path_1.join)(projectSourceRoot, (0, node_path_1.dirname)(pattern), `${(0, node_path_1.basename)(pattern, fileExt)}.spec${fileExt}`);
+    if (await exists(potentialSpec)) {
+        return [potentialSpec];
+    }
+    return pattern;
+}
+/** Checks if a path exists and is a directory. */
+async function isDirectory(path) {
+    try {
+        const stats = await node_fs_1.promises.stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Checks if a path exists on the file system. */
+async function exists(path) {
+    try {
+        await node_fs_1.promises.access(path, node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/tools/angular/transformers/jit-bootstrap-transformer.js

@@ -30,7 +30,7 @@ function replaceBootstrap(getTypeChecker) {
                 if (target.text === PLATFORM_BROWSER_DYNAMIC_NAME) {
                     if (!bootstrapNamespace) {
                         bootstrapNamespace = nodeFactory.createUniqueName('__NgCli_bootstrap_');
-                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
+                        bootstrapImport = nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(undefined, undefined, nodeFactory.createNamespaceImport(bootstrapNamespace)), nodeFactory.createStringLiteral('@angular/platform-browser'));
                     }
                     replacedNodes.push(target);
                     return nodeFactory.updateCallExpression(node, nodeFactory.createPropertyAccessExpression(bootstrapNamespace, 'platformBrowser'), node.typeArguments, node.arguments);

package/src/tools/angular/transformers/jit-resource-transformer.js

@@ -141,7 +141,7 @@ function visitComponentMetadata(nodeFactory, node, styleReplacements, resourceIm
 function createResourceImport(nodeFactory, url, resourceImportDeclarations) {
     const urlLiteral = nodeFactory.createStringLiteral(url);
     const importName = nodeFactory.createIdentifier(`__NG_CLI_RESOURCE__${resourceImportDeclarations.length}`);
-    resourceImportDeclarations.push(nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(false, importName, undefined), urlLiteral));
+    resourceImportDeclarations.push(nodeFactory.createImportDeclaration(undefined, nodeFactory.createImportClause(undefined, importName, undefined), urlLiteral));
     return importName;
 }
 function getDecoratorOrigin(decorator, typeChecker) {

package/src/tools/esbuild/application-code-bundle.js

@@ -418,8 +418,6 @@ function getEsBuildCommonOptions(options) {
             packages = 'external';
         }
     }
-    const minifySyntax = optimizationOptions.scripts;
-    const minifyIdentifiers = minifySyntax && environment_options_1.allowMangle;
     return {
         absWorkingDir: workspaceRoot,
         format: 'esm',
@@ -431,10 +429,9 @@ function getEsBuildCommonOptions(options) {
         metafile: true,
         legalComments: options.extractLicenses ? 'none' : 'eof',
         logLevel: options.verbose && !jsonLogs ? 'debug' : 'silent',
-        keepNames: !minifyIdentifiers,
-        minifyIdentifiers,
-        minifySyntax,
-        minifyWhitespace: minifySyntax,
+        minifyIdentifiers: optimizationOptions.scripts && environment_options_1.allowMangle,
+        minifySyntax: optimizationOptions.scripts,
+        minifyWhitespace: optimizationOptions.scripts,
         pure: ['forwardRef'],
         outdir: workspaceRoot,
         outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined,
@@ -451,7 +448,7 @@ function getEsBuildCommonOptions(options) {
             // Only set to false when script optimizations are enabled. It should not be set to true because
             // Angular turns `ngDevMode` into an object for development debugging purposes when not defined
             // which a constant true value would break.
-            ...(minifySyntax ? { 'ngDevMode': 'false' } : undefined),
+            ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),
             'ngJitMode': jit ? 'true' : 'false',
             'ngServerMode': 'false',
             'ngHmrMode': options.templateUpdates ? 'true' : 'false',

package/src/tools/esbuild/stylesheets/less-language.js

@@ -55,11 +55,10 @@ exports.LessStylesheetLanguage = Object.freeze({
     componentFilter: /^less;/,
     fileFilter: /\.less$/,
     process(data, file, _, options, build) {
-        return compileString(data, file, options, build.resolve.bind(build), 
-        /* unsafeInlineJavaScript */ false);
+        return compileString(data, file, options, build.resolve.bind(build));
     },
 });
-async function compileString(data, filename, options, resolver, unsafeInlineJavaScript) {
+async function compileString(data, filename, options, resolver) {
     try {
         lessPreprocessor ??= (await Promise.resolve().then(() => __importStar(require('less')))).default;
     }
@@ -120,7 +119,6 @@ async function compileString(data, filename, options, resolver, unsafeInlineJava
             paths: options.includePaths,
             plugins: [resolverPlugin],
             rewriteUrls: 'all',
-            javascriptEnabled: unsafeInlineJavaScript,
             sourceMap: options.sourcemap
                 ? {
                     sourceMapFileInline: true,
@@ -137,28 +135,6 @@ async function compileString(data, filename, options, resolver, unsafeInlineJava
     catch (error) {
         if (isLessException(error)) {
             const location = convertExceptionLocation(error);
-            // Retry with a warning for less files requiring the deprecated inline JavaScript option
-            if (error.message.includes('Inline JavaScript is not enabled.')) {
-                const withJsResult = await compileString(data, filename, options, resolver, 
-                /* unsafeInlineJavaScript */ true);
-                withJsResult.warnings = [
-                    {
-                        text: 'Deprecated inline execution of JavaScript has been enabled ("javascriptEnabled")',
-                        location,
-                        notes: [
-                            {
-                                location: null,
-                                text: 'JavaScript found within less stylesheets may be executed at build time. [https://lesscss.org/usage/#less-options]',
-                            },
-                            {
-                                location: null,
-                                text: 'Support for "javascriptEnabled" may be removed from the Angular CLI starting with Angular v19.',
-                            },
-                        ],
-                    },
-                ];
-                return withJsResult;
-            }
             return {
                 errors: [
                     {

package/src/tools/esbuild/stylesheets/stylesheet-plugin-factory.js

@@ -152,7 +152,8 @@ class StylesheetPluginFactory {
                 postcssProcessor = postcss();
                 const postCssPluginRequire = (0, node_module_1.createRequire)((0, node_path_1.dirname)(configPath) + '/');
                 for (const [pluginName, pluginOptions] of config.plugins) {
-                    const plugin = postCssPluginRequire(pluginName);
+                    const pluginMod = postCssPluginRequire(pluginName);
+                    const plugin = pluginMod.__esModule ? pluginMod['default'] : pluginMod;
                     if (typeof plugin !== 'function' || plugin.postcss !== true) {
                         throw new Error(`Attempted to load invalid Postcss plugin: "${pluginName}"`);
                     }

package/src/tools/vite/middlewares/assets-middleware.d.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { Connect, ViteDevServer } from 'vite';
+import { ResultFile } from '../../../builders/application/results';
 import { AngularMemoryOutputFiles, AngularOutputAssets } from '../utils';
 export interface ComponentStyleRecord {
     rawContent: Uint8Array;
@@ -13,3 +14,4 @@ export interface ComponentStyleRecord {
     reload?: boolean;
 }
 export declare function createAngularAssetsMiddleware(server: ViteDevServer, assets: AngularOutputAssets, outputFiles: AngularMemoryOutputFiles, componentStyles: Map<string, ComponentStyleRecord>, encapsulateStyle: (style: Uint8Array, componentId: string) => string): Connect.NextHandleFunction;
+export declare function createBuildAssetsMiddleware(basePath: string, buildResultFiles: ReadonlyMap<string, ResultFile>, readHandler?: (path: string) => Buffer): Connect.NextHandleFunction;

package/src/tools/vite/middlewares/assets-middleware.js

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAngularAssetsMiddleware = createAngularAssetsMiddleware;
+exports.createBuildAssetsMiddleware = createBuildAssetsMiddleware;
 const mrmime_1 = require("mrmime");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -171,3 +172,33 @@ function checkAndHandleEtag(req, res, etag) {
     }
     return false;
 }
+function createBuildAssetsMiddleware(basePath, buildResultFiles, readHandler = node_fs_1.readFileSync) {
+    return function buildAssetsMiddleware(req, res, next) {
+        if (req.url === undefined || res.writableEnded) {
+            return;
+        }
+        // Parse the incoming request.
+        // The base of the URL is unused but required to parse the URL.
+        const pathname = (0, utils_1.pathnameWithoutBasePath)(req.url, basePath);
+        const extension = (0, node_path_1.extname)(pathname);
+        if (extension && !/\.[mc]?[jt]s(?:\.map)?$/.test(extension)) {
+            const outputFile = buildResultFiles.get(pathname.slice(1));
+            if (outputFile) {
+                const contents = outputFile.origin === 'memory' ? outputFile.contents : readHandler(outputFile.inputPath);
+                const etag = `W/${(0, node_crypto_1.createHash)('sha256').update(contents).digest('hex')}`;
+                if (checkAndHandleEtag(req, res, etag)) {
+                    return;
+                }
+                const mimeType = (0, mrmime_1.lookup)(extension);
+                if (mimeType) {
+                    res.setHeader('Content-Type', mimeType);
+                }
+                res.setHeader('ETag', etag);
+                res.setHeader('Cache-Control', 'no-cache');
+                res.end(contents);
+                return;
+            }
+        }
+        next();
+    };
+}

package/src/tools/vite/utils.js

@@ -53,7 +53,6 @@ function getDepOptimizationConfig({ disabled, exclude, include, target, zoneless
         esbuildOptions: {
             // Set esbuild supported targets.
             target,
-            keepNames: true,
             supported: (0, utils_1.getFeatureSupport)(target, zoneless),
             plugins,
             loader,

package/src/utils/normalize-cache.js

@@ -10,7 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeCacheOptions = normalizeCacheOptions;
 const node_path_1 = require("node:path");
 /** Version placeholder is replaced during the build process with actual package version */
-const VERSION = '21.0.0-next.3';
+const VERSION = '21.0.0-next.5';
 function hasCacheMetadata(value) {
     return (!!value &&
         typeof value === 'object' &&

package/src/utils/supported-browsers.js

@@ -12,11 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSupportedBrowsers = getSupportedBrowsers;
 const browserslist_1 = __importDefault(require("browserslist"));
+// The below is replaced by bazel `npm_package`.
+const BASELINE_DATE = '2025-08-20';
 function getSupportedBrowsers(projectRoot, logger) {
     // Read the browserslist configuration containing Angular's browser support policy.
-    const angularBrowserslist = (0, browserslist_1.default)(undefined, {
-        path: require.resolve('../../.browserslistrc'),
-    });
+    const angularBrowserslist = (0, browserslist_1.default)(`baseline widely available on ${getBaselineDate()}`);
     // Use Angular's configuration as the default.
     browserslist_1.default.defaults = angularBrowserslist;
     // Get the minimum set of browser versions supported by Angular.
@@ -50,3 +50,7 @@ function getSupportedBrowsers(projectRoot, logger) {
     }
     return Array.from(browsersFromConfigOrDefault);
 }
+function getBaselineDate() {
+    // Unlike `npm_package`, `ts_project` which is used to run unit tests does not support substitutions.
+    return BASELINE_DATE[0] === 'B' ? '2025-01-01' : BASELINE_DATE;
+}

package/src/utils/test-files.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 { ResultFile } from '../builders/application/results';
+/**
+ * Writes a collection of build result files to a specified directory.
+ * This function handles both in-memory and on-disk files, creating subdirectories
+ * as needed.
+ *
+ * @param files A map of file paths to `ResultFile` objects, representing the build output.
+ * @param testDir The absolute path to the directory where the files should be written.
+ */
+export declare function writeTestFiles(files: Record<string, ResultFile>, testDir: string): Promise<void>;