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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/build",
-  "version": "21.0.0-next.1",
+  "version": "21.0.0-next.3",
   "description": "Official build system for Angular",
   "keywords": [
     "Angular CLI",
@@ -23,8 +23,8 @@
   "builders": "builders.json",
   "dependencies": {
     "@ampproject/remapping": "2.3.0",
-    "@angular-devkit/architect": "0.2100.0-next.1",
-    "@babel/core": "7.28.3",
+    "@angular-devkit/architect": "0.2100.0-next.3",
+    "@babel/core": "7.28.4",
     "@babel/helper-annotate-as-pure": "7.27.3",
     "@babel/helper-split-export-declaration": "7.24.7",
     "@inquirer/confirm": "5.1.16",
@@ -35,18 +35,18 @@
     "https-proxy-agent": "7.0.6",
     "istanbul-lib-instrument": "6.0.3",
     "jsonc-parser": "3.3.1",
-    "listr2": "9.0.2",
-    "magic-string": "0.30.18",
+    "listr2": "9.0.3",
+    "magic-string": "0.30.19",
     "mrmime": "2.0.1",
     "parse5-html-rewriting-stream": "8.0.0",
     "picomatch": "4.0.3",
     "piscina": "5.1.3",
-    "rolldown": "1.0.0-beta.34",
-    "sass": "1.91.0",
+    "rolldown": "1.0.0-beta.36",
+    "sass": "1.92.1",
     "semver": "7.7.2",
     "source-map-support": "0.5.21",
-    "tinyglobby": "0.2.14",
-    "vite": "7.1.3",
+    "tinyglobby": "0.2.15",
+    "vite": "7.1.5",
     "watchpack": "2.4.4"
   },
   "optionalDependencies": {
@@ -60,14 +60,14 @@
     "@angular/platform-browser": "^21.0.0-next.0",
     "@angular/platform-server": "^21.0.0-next.0",
     "@angular/service-worker": "^21.0.0-next.0",
-    "@angular/ssr": "^21.0.0-next.1",
+    "@angular/ssr": "^21.0.0-next.3",
     "karma": "^6.4.0",
     "less": "^4.2.0",
     "ng-packagr": "^21.0.0-next.0",
     "postcss": "^8.4.0",
     "tailwindcss": "^2.0.0 || ^3.0.0 || ^4.0.0",
     "tslib": "^2.3.0",
-    "typescript": ">=5.8 <6.0",
+    "typescript": ">=5.9 <6.0",
     "vitest": "^3.1.1"
   },
   "peerDependenciesMeta": {
@@ -112,7 +112,7 @@
     "type": "git",
     "url": "https://github.com/angular/angular-cli.git"
   },
-  "packageManager": "pnpm@10.15.0",
+  "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
     "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",

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

@@ -177,7 +177,10 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
         file: string;
         package: string;
     } | undefined;
-    postcssConfiguration: import("../../utils/postcss-configuration").PostcssConfiguration | undefined;
+    postcssConfiguration: {
+        configPath: string;
+        config: import("../../utils/postcss-configuration").PostcssConfiguration;
+    } | undefined;
     i18nOptions: I18nOptions & {
         duplicateTranslationBehavior?: I18NTranslation;
         missingTranslationBehavior?: I18NTranslation;

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

@@ -317,6 +317,7 @@ async function* serveWithVite(serverOptions, builderName, builderAction, context
             // Setup server and start listening
             const serverConfiguration = await (0, server_1.setupServer)(serverOptions, generatedFiles, assetFiles, browserOptions.preserveSymlinks, externalMetadata, ssrMode, prebundleTransformer, target, (0, internal_1.isZonelessApp)(polyfills), componentStyles, templateUpdates, browserOptions.loader, {
                 ...browserOptions.define,
+                'ngJitMode': browserOptions.aot ? 'false' : 'true',
                 'ngHmrMode': browserOptions.templateUpdates ? 'true' : 'false',
             }, extensions?.middleware, transformers?.indexHtml, thirdPartySourcemaps);
             server = await createServer(serverConfiguration);

package/src/builders/karma/find-tests.d.ts

@@ -9,7 +9,8 @@ export declare function findTests(include: string[], exclude: string[], workspac
 interface TestEntrypointsOptions {
     projectSourceRoot: string;
     workspaceRoot: string;
+    removeTestExtension?: boolean;
 }
 /** Generate unique bundle names for a set of test files. */
-export declare function getTestEntrypoints(testFiles: string[], { projectSourceRoot, workspaceRoot }: TestEntrypointsOptions): Map<string, string>;
+export declare function getTestEntrypoints(testFiles: string[], { projectSourceRoot, workspaceRoot, removeTestExtension }: TestEntrypointsOptions): Map<string, string>;
 export {};

package/src/builders/karma/find-tests.js

@@ -21,7 +21,7 @@ async function findTests(include, exclude, workspaceRoot, projectSourceRoot) {
     return [...new Set(files.flat())];
 }
 /** Generate unique bundle names for a set of test files. */
-function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot }) {
+function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot, removeTestExtension }) {
     const seen = new Set();
     return new Map(Array.from(testFiles, (testFile) => {
         const relativePath = removeRoots(testFile, [projectSourceRoot, workspaceRoot])
@@ -29,7 +29,11 @@ function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot }) {
             .replace(/^[./\\]+/, '')
             // Replace any path separators with dashes.
             .replace(/[/\\]/g, '-');
-        const baseName = `spec-${(0, node_path_1.basename)(relativePath, (0, node_path_1.extname)(relativePath))}`;
+        let fileName = (0, node_path_1.basename)(relativePath, (0, node_path_1.extname)(relativePath));
+        if (removeTestExtension) {
+            fileName = fileName.replace(/\.(spec|test)$/, '');
+        }
+        const baseName = `spec-${fileName}`;
         let uniqueName = baseName;
         let suffix = 2;
         while (seen.has(uniqueName)) {

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

@@ -15,7 +15,7 @@ export declare function normalizeOptions(context: BuilderContext, projectName: s
     cacheOptions: import("../../utils/normalize-cache").NormalizedCachedOptions;
     buildTarget: import("@angular-devkit/architect").Target;
     include: string[];
-    exclude: string[];
+    exclude: string[] | undefined;
     runnerName: import("./schema").Runner;
     codeCoverage: {
         exclude: string[] | undefined;

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

@@ -38,7 +38,7 @@ async function normalizeOptions(context, projectName, options) {
         // Target/configuration specified options
         buildTarget,
         include: options.include ?? ['**/*.spec.ts'],
-        exclude: options.exclude ?? [],
+        exclude: options.exclude,
         runnerName: runner,
         codeCoverage: options.codeCoverage
             ? {

package/src/builders/unit-test/runners/vitest/build-options.js

@@ -43,8 +43,18 @@ function createTestBedInitVirtualFile(providersFile, projectSourceRoot) {
     });
   `;
 }
+function adjustOutputHashing(hashing) {
+    switch (hashing) {
+        case schema_1.OutputHashing.All:
+        case schema_1.OutputHashing.Media:
+            // Ensure media is continued to be hashed to avoid overwriting of output media files
+            return schema_1.OutputHashing.Media;
+        default:
+            return schema_1.OutputHashing.None;
+    }
+}
 async function getVitestBuildOptions(options, baseBuildOptions) {
-    const { workspaceRoot, projectSourceRoot, include, exclude, watch, tsConfig, providersFile } = options;
+    const { workspaceRoot, projectSourceRoot, include, exclude = [], watch, tsConfig, providersFile, } = options;
     // Find test files
     const testFiles = await (0, test_discovery_1.findTests)(include, exclude, workspaceRoot, projectSourceRoot);
     if (testFiles.length === 0) {
@@ -53,7 +63,11 @@ async function getVitestBuildOptions(options, baseBuildOptions) {
             (exclude.length ? `- Excluded: ${exclude.join(', ')}\n` : '') +
             `\nPlease check the 'test' target configuration in your project's 'angular.json' file.`);
     }
-    const entryPoints = (0, test_discovery_1.getTestEntrypoints)(testFiles, { projectSourceRoot, workspaceRoot });
+    const entryPoints = (0, test_discovery_1.getTestEntrypoints)(testFiles, {
+        projectSourceRoot,
+        workspaceRoot,
+        removeTestExtension: true,
+    });
     entryPoints.set('init-testbed', 'angular:test-bed-init');
     const buildOptions = {
         ...baseBuildOptions,
@@ -70,7 +84,7 @@ async function getVitestBuildOptions(options, baseBuildOptions) {
         ssr: false,
         prerender: false,
         sourceMap: { scripts: true, vendor: false, styles: false },
-        outputHashing: schema_1.OutputHashing.None,
+        outputHashing: adjustOutputHashing(baseBuildOptions.outputHashing),
         optimization: false,
         tsConfig,
         entryPoints,

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

@@ -13,11 +13,13 @@ export declare class VitestExecutor implements TestExecutor {
     private vitest;
     private readonly projectName;
     private readonly options;
-    private readonly outputPath;
-    private latestBuildResult;
-    private readonly sigintListener;
+    private buildResultFiles;
+    private testFileToEntryPoint;
+    private entryPointToTestFile;
     constructor(projectName: string, options: NormalizedUnitTestBuilderOptions);
     execute(buildResult: FullResult | IncrementalResult): AsyncIterable<BuilderOutput>;
     [Symbol.asyncDispose](): Promise<void>;
+    private prepareSetupFiles;
+    private createVitestPlugins;
     private initializeVitest;
 }

package/src/builders/unit-test/runners/vitest/executor.js

@@ -12,73 +12,219 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VitestExecutor = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const error_1 = require("../../../../utils/error");
 const load_esm_1 = require("../../../../utils/load-esm");
 const path_1 = require("../../../../utils/path");
 const results_1 = require("../../../application/results");
-const application_builder_1 = require("../../../karma/application_builder");
+const test_discovery_1 = require("../../test-discovery");
 const browser_provider_1 = require("./browser-provider");
 class VitestExecutor {
     vitest;
     projectName;
     options;
-    outputPath;
-    latestBuildResult;
-    // Graceful shutdown signal handler
-    // This is needed to remove the temporary output directory on Ctrl+C
-    sigintListener = () => {
-        (0, node_fs_1.rmSync)(this.outputPath, { recursive: true, force: true });
-    };
+    buildResultFiles = new Map();
+    // This is a reverse map of the entry points created in `build-options.ts`.
+    // It is used by the in-memory provider plugin to map the requested test file
+    // path back to its bundled output path.
+    // Example: `Map<'/path/to/src/app.spec.ts', 'spec-src-app-spec'>`
+    testFileToEntryPoint = new Map();
+    entryPointToTestFile = new Map();
     constructor(projectName, options) {
         this.projectName = projectName;
         this.options = options;
-        this.outputPath = (0, path_1.toPosixPath)(node_path_1.default.join(options.workspaceRoot, generateOutputPath()));
-        process.on('SIGINT', this.sigintListener);
     }
     async *execute(buildResult) {
-        await (0, application_builder_1.writeTestFiles)(buildResult.files, this.outputPath);
-        this.latestBuildResult = buildResult;
+        if (buildResult.kind === results_1.ResultKind.Full) {
+            this.buildResultFiles.clear();
+            for (const [path, file] of Object.entries(buildResult.files)) {
+                this.buildResultFiles.set(path, file);
+            }
+        }
+        else {
+            for (const file of buildResult.removed) {
+                this.buildResultFiles.delete(file.path);
+            }
+            for (const [path, file] of Object.entries(buildResult.files)) {
+                this.buildResultFiles.set(path, file);
+            }
+        }
+        // The `getTestEntrypoints` function is used here to create the same mapping
+        // that was used in `build-options.ts` to generate the build entry points.
+        // This is a deliberate duplication to avoid a larger refactoring of the
+        // builder's core interfaces to pass the entry points from the build setup
+        // phase to the execution phase.
+        if (this.testFileToEntryPoint.size === 0) {
+            const { include, exclude = [], workspaceRoot, projectSourceRoot } = this.options;
+            const testFiles = await (0, test_discovery_1.findTests)(include, exclude, workspaceRoot, projectSourceRoot);
+            const entryPoints = (0, test_discovery_1.getTestEntrypoints)(testFiles, {
+                projectSourceRoot,
+                workspaceRoot,
+                removeTestExtension: true,
+            });
+            for (const [entryPoint, testFile] of entryPoints) {
+                this.testFileToEntryPoint.set(testFile, entryPoint);
+                this.entryPointToTestFile.set(entryPoint + '.js', testFile);
+            }
+        }
         // Initialize Vitest if not already present.
         this.vitest ??= await this.initializeVitest();
         const vitest = this.vitest;
         let testResults;
         if (buildResult.kind === results_1.ResultKind.Incremental) {
-            const addedFiles = buildResult.added.map((file) => node_path_1.default.join(this.outputPath, file));
-            const modifiedFiles = buildResult.modified.map((file) => node_path_1.default.join(this.outputPath, file));
-            if (addedFiles.length === 0 && modifiedFiles.length === 0) {
-                yield { success: true };
-                return;
-            }
-            // If new files are added, use `start` to trigger test discovery.
-            // Also pass modified files to `start` to ensure they are re-run.
-            if (addedFiles.length > 0) {
-                await vitest.start([...addedFiles, ...modifiedFiles]);
+            // To rerun tests, Vitest needs the original test file paths, not the output paths.
+            const modifiedSourceFiles = new Set();
+            for (const modifiedFile of buildResult.modified) {
+                // The `modified` files in the build result are the output paths.
+                // We need to find the original source file path to pass to Vitest.
+                const source = this.entryPointToTestFile.get(modifiedFile);
+                if (source) {
+                    modifiedSourceFiles.add(source);
+                }
+                vitest.invalidateFile((0, path_1.toPosixPath)(node_path_1.default.join(this.options.workspaceRoot, modifiedFile)));
             }
-            else {
-                // For modified files only, use the more efficient `rerunTestSpecifications`
-                const specsToRerun = modifiedFiles.flatMap((file) => vitest.getModuleSpecifications(file));
-                if (specsToRerun.length > 0) {
-                    modifiedFiles.forEach((file) => vitest.invalidateFile(file));
-                    testResults = await vitest.rerunTestSpecifications(specsToRerun);
+            const specsToRerun = [];
+            for (const file of modifiedSourceFiles) {
+                vitest.invalidateFile(file);
+                const specs = vitest.getModuleSpecifications(file);
+                if (specs) {
+                    specsToRerun.push(...specs);
                 }
             }
+            if (specsToRerun.length > 0) {
+                testResults = await vitest.rerunTestSpecifications(specsToRerun);
+            }
         }
         // Check if all the tests pass to calculate the result
-        const testModules = testResults?.testModules;
-        yield { success: testModules?.every((testModule) => testModule.ok()) ?? true };
+        const testModules = testResults?.testModules ?? this.vitest.state.getTestModules();
+        yield { success: testModules.every((testModule) => testModule.ok()) };
     }
     async [Symbol.asyncDispose]() {
-        process.off('SIGINT', this.sigintListener);
         await this.vitest?.close();
-        await (0, promises_1.rm)(this.outputPath, { recursive: true, force: true });
+    }
+    prepareSetupFiles() {
+        const { setupFiles } = this.options;
+        // Add setup file entries for TestBed initialization and project polyfills
+        const testSetupFiles = ['init-testbed.js', ...setupFiles];
+        // TODO: Provide additional result metadata to avoid needing to extract based on filename
+        if (this.buildResultFiles.has('polyfills.js')) {
+            testSetupFiles.unshift('polyfills.js');
+        }
+        return testSetupFiles;
+    }
+    createVitestPlugins(testSetupFiles, browserOptions) {
+        const { workspaceRoot } = this.options;
+        return [
+            {
+                name: 'angular:project-init',
+                // Type is incorrect. This allows a Promise<void>.
+                // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                configureVitest: async (context) => {
+                    // Create a subproject that can be configured with plugins for browser mode.
+                    // Plugins defined directly in the vite overrides will not be present in the
+                    // browser specific Vite instance.
+                    await context.injectTestProjects({
+                        test: {
+                            name: this.projectName,
+                            root: workspaceRoot,
+                            globals: true,
+                            setupFiles: testSetupFiles,
+                            // Use `jsdom` if no browsers are explicitly configured.
+                            // `node` is effectively no "environment" and the default.
+                            environment: browserOptions.browser ? 'node' : 'jsdom',
+                            browser: browserOptions.browser,
+                            include: this.options.include,
+                            ...(this.options.exclude ? { exclude: this.options.exclude } : {}),
+                        },
+                        plugins: [
+                            {
+                                name: 'angular:test-in-memory-provider',
+                                enforce: 'pre',
+                                resolveId: (id, importer) => {
+                                    if (importer && (id[0] === '.' || id[0] === '/')) {
+                                        let fullPath;
+                                        if (this.testFileToEntryPoint.has(importer)) {
+                                            fullPath = (0, path_1.toPosixPath)(node_path_1.default.join(this.options.workspaceRoot, id));
+                                        }
+                                        else {
+                                            fullPath = (0, path_1.toPosixPath)(node_path_1.default.join(node_path_1.default.dirname(importer), id));
+                                        }
+                                        const relativePath = node_path_1.default.relative(this.options.workspaceRoot, fullPath);
+                                        if (this.buildResultFiles.has((0, path_1.toPosixPath)(relativePath))) {
+                                            return fullPath;
+                                        }
+                                    }
+                                    if (this.testFileToEntryPoint.has(id)) {
+                                        return id;
+                                    }
+                                    (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available for resolving.');
+                                    const relativePath = node_path_1.default.relative(this.options.workspaceRoot, id);
+                                    if (this.buildResultFiles.has((0, path_1.toPosixPath)(relativePath))) {
+                                        return id;
+                                    }
+                                },
+                                load: async (id) => {
+                                    (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available for in-memory loading.');
+                                    // Attempt to load as a source test file.
+                                    const entryPoint = this.testFileToEntryPoint.get(id);
+                                    let outputPath;
+                                    if (entryPoint) {
+                                        outputPath = entryPoint + '.js';
+                                        // To support coverage exclusion of the actual test file, the virtual
+                                        // test entry point only references the built and bundled intermediate file.
+                                        return {
+                                            code: `import "./${outputPath}";`,
+                                        };
+                                    }
+                                    else {
+                                        // Attempt to load as a built artifact.
+                                        const relativePath = node_path_1.default.relative(this.options.workspaceRoot, id);
+                                        outputPath = (0, path_1.toPosixPath)(relativePath);
+                                    }
+                                    const outputFile = this.buildResultFiles.get(outputPath);
+                                    if (outputFile) {
+                                        const sourceMapPath = outputPath + '.map';
+                                        const sourceMapFile = this.buildResultFiles.get(sourceMapPath);
+                                        const code = outputFile.origin === 'memory'
+                                            ? Buffer.from(outputFile.contents).toString('utf-8')
+                                            : await (0, promises_1.readFile)(outputFile.inputPath, 'utf-8');
+                                        const map = sourceMapFile
+                                            ? sourceMapFile.origin === 'memory'
+                                                ? Buffer.from(sourceMapFile.contents).toString('utf-8')
+                                                : await (0, promises_1.readFile)(sourceMapFile.inputPath, 'utf-8')
+                                            : undefined;
+                                        return {
+                                            code,
+                                            map: map ? JSON.parse(map) : undefined,
+                                        };
+                                    }
+                                },
+                            },
+                            {
+                                name: 'angular:html-index',
+                                transformIndexHtml: () => {
+                                    // Add all global stylesheets
+                                    if (this.buildResultFiles.has('styles.css')) {
+                                        return [
+                                            {
+                                                tag: 'link',
+                                                attrs: { href: 'styles.css', rel: 'stylesheet' },
+                                                injectTo: 'head',
+                                            },
+                                        ];
+                                    }
+                                    return [];
+                                },
+                            },
+                        ],
+                    });
+                },
+            },
+        ];
     }
     async initializeVitest() {
-        const { codeCoverage, reporters, workspaceRoot, setupFiles, browsers, debug, watch } = this.options;
-        const { outputPath, projectName, latestBuildResult } = this;
+        const { codeCoverage, reporters, workspaceRoot, browsers, debug, watch } = this.options;
         let vitestNodeModule;
         try {
             vitestNodeModule = await (0, load_esm_1.loadEsmModule)('vitest/node');
@@ -96,14 +242,9 @@ class VitestExecutor {
         if (browserOptions.errors?.length) {
             throw new Error(browserOptions.errors.join('\n'));
         }
-        (0, node_assert_1.default)(latestBuildResult, 'buildResult must be available before initializing vitest');
-        // Add setup file entries for TestBed initialization and project polyfills
-        const testSetupFiles = ['init-testbed.js', ...setupFiles];
-        // TODO: Provide additional result metadata to avoid needing to extract based on filename
-        const polyfillsFile = Object.keys(latestBuildResult.files).find((f) => f === 'polyfills.js');
-        if (polyfillsFile) {
-            testSetupFiles.unshift(polyfillsFile);
-        }
+        (0, node_assert_1.default)(this.buildResultFiles.size > 0, 'buildResult must be available before initializing vitest');
+        const testSetupFiles = this.prepareSetupFiles();
+        const plugins = this.createVitestPlugins(testSetupFiles, browserOptions);
         const debugOptions = debug
             ? {
                 inspectBrk: true,
@@ -115,12 +256,12 @@ class VitestExecutor {
             // Disable configuration file resolution/loading
             config: false,
             root: workspaceRoot,
-            project: ['base', projectName],
+            project: ['base', this.projectName],
             name: 'base',
             include: [],
             reporters: reporters ?? ['default'],
             watch,
-            coverage: generateCoverageOption(codeCoverage, workspaceRoot, this.outputPath),
+            coverage: generateCoverageOption(codeCoverage),
             ...debugOptions,
         }, {
             server: {
@@ -128,61 +269,12 @@ class VitestExecutor {
                 // be enabled as it controls other internal behavior related to rerunning tests.
                 watch: null,
             },
-            plugins: [
-                {
-                    name: 'angular:project-init',
-                    async configureVitest(context) {
-                        // Create a subproject that can be configured with plugins for browser mode.
-                        // Plugins defined directly in the vite overrides will not be present in the
-                        // browser specific Vite instance.
-                        const [project] = await context.injectTestProjects({
-                            test: {
-                                name: projectName,
-                                root: outputPath,
-                                globals: true,
-                                setupFiles: testSetupFiles,
-                                // Use `jsdom` if no browsers are explicitly configured.
-                                // `node` is effectively no "environment" and the default.
-                                environment: browserOptions.browser ? 'node' : 'jsdom',
-                                browser: browserOptions.browser,
-                            },
-                            plugins: [
-                                {
-                                    name: 'angular:html-index',
-                                    transformIndexHtml: () => {
-                                        (0, node_assert_1.default)(latestBuildResult, 'buildResult must be available for HTML index transformation.');
-                                        // Add all global stylesheets
-                                        const styleFiles = Object.entries(latestBuildResult.files).filter(([file]) => file === 'styles.css');
-                                        return styleFiles.map(([href]) => ({
-                                            tag: 'link',
-                                            attrs: { href, rel: 'stylesheet' },
-                                            injectTo: 'head',
-                                        }));
-                                    },
-                                },
-                            ],
-                        });
-                        // Adjust coverage excludes to not include the otherwise automatically inserted included unit tests.
-                        // Vite does this as a convenience but is problematic for the bundling strategy employed by the
-                        // builder's test setup. To workaround this, the excludes are adjusted here to only automatically
-                        // exclude the TypeScript source test files.
-                        project.config.coverage.exclude = [
-                            ...(codeCoverage?.exclude ?? []),
-                            '**/*.{test,spec}.?(c|m)ts',
-                        ];
-                    },
-                },
-            ],
+            plugins,
         });
     }
 }
 exports.VitestExecutor = VitestExecutor;
-function generateOutputPath() {
-    const datePrefix = new Date().toISOString().replaceAll(/[-:.]/g, '');
-    const uuidSuffix = (0, node_crypto_1.randomUUID)().slice(0, 8);
-    return node_path_1.default.join('dist', 'test-out', `${datePrefix}-${uuidSuffix}`);
-}
-function generateCoverageOption(codeCoverage, workspaceRoot, outputPath) {
+function generateCoverageOption(codeCoverage) {
     if (!codeCoverage) {
         return {
             enabled: false,
@@ -191,8 +283,8 @@ function generateCoverageOption(codeCoverage, workspaceRoot, outputPath) {
     return {
         enabled: true,
         excludeAfterRemap: true,
-        include: [`${(0, path_1.toPosixPath)(node_path_1.default.relative(workspaceRoot, outputPath))}/**`],
-        // Special handling for `reporter` due to an undefined value causing upstream failures
+        // Special handling for `exclude`/`reporters` due to an undefined value causing upstream failures
+        ...(codeCoverage.exclude ? { exclude: codeCoverage.exclude } : {}),
         ...(codeCoverage.reporters
             ? { reporter: codeCoverage.reporters }
             : {}),

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

@@ -39,7 +39,6 @@
       "items": {
         "type": "string"
       },
-      "default": [],
       "description": "Globs of files to exclude, relative to the project root."
     },
     "watch": {
@@ -61,8 +60,7 @@
       "description": "Globs to exclude from code coverage.",
       "items": {
         "type": "string"
-      },
-      "default": []
+      }
     },
     "codeCoverageReporters": {
       "type": "array",

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

@@ -418,6 +418,8 @@ function getEsBuildCommonOptions(options) {
             packages = 'external';
         }
     }
+    const minifySyntax = optimizationOptions.scripts;
+    const minifyIdentifiers = minifySyntax && environment_options_1.allowMangle;
     return {
         absWorkingDir: workspaceRoot,
         format: 'esm',
@@ -429,9 +431,10 @@ function getEsBuildCommonOptions(options) {
         metafile: true,
         legalComments: options.extractLicenses ? 'none' : 'eof',
         logLevel: options.verbose && !jsonLogs ? 'debug' : 'silent',
-        minifyIdentifiers: optimizationOptions.scripts && environment_options_1.allowMangle,
-        minifySyntax: optimizationOptions.scripts,
-        minifyWhitespace: optimizationOptions.scripts,
+        keepNames: !minifyIdentifiers,
+        minifyIdentifiers,
+        minifySyntax,
+        minifyWhitespace: minifySyntax,
         pure: ['forwardRef'],
         outdir: workspaceRoot,
         outExtension: outExtension ? { '.js': `.${outExtension}` } : undefined,
@@ -448,7 +451,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.
-            ...(optimizationOptions.scripts ? { 'ngDevMode': 'false' } : undefined),
+            ...(minifySyntax ? { 'ngDevMode': 'false' } : undefined),
             'ngJitMode': jit ? 'true' : 'false',
             'ngServerMode': 'false',
             'ngHmrMode': options.templateUpdates ? 'true' : 'false',

package/src/tools/esbuild/stylesheets/bundle-options.d.ts

@@ -29,7 +29,10 @@ export interface BundleStylesheetOptions {
         file: string;
         package: string;
     };
-    postcssConfiguration?: PostcssConfiguration;
+    postcssConfiguration?: {
+        config: PostcssConfiguration;
+        configPath: string;
+    };
     publicPath?: string;
     cacheOptions: NormalizedCachedOptions;
 }

package/src/tools/esbuild/stylesheets/stylesheet-plugin-factory.d.ts

@@ -46,7 +46,10 @@ export interface StylesheetPluginOptions {
      * initialized and used for every stylesheet. This overrides the tailwind integration
      * and any tailwind usage must be manually configured in the custom postcss usage.
      */
-    postcssConfiguration?: PostcssConfiguration;
+    postcssConfiguration?: {
+        config: PostcssConfiguration;
+        configPath: string;
+    };
     /**
      * Optional Options for configuring Sass behavior.
      */

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

@@ -46,6 +46,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StylesheetPluginFactory = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
 const node_path_1 = require("node:path");
 const tinyglobby_1 = require("tinyglobby");
 const error_1 = require("../../../utils/error");
@@ -143,13 +144,15 @@ class StylesheetPluginFactory {
         node_assert_1.default.equal(++this.initPostcssCallCount, 1, '`initPostcss` was called more than once.');
         const { options } = this;
         if (options.postcssConfiguration) {
-            const postCssInstanceKey = JSON.stringify(options.postcssConfiguration);
+            const { config, configPath } = options.postcssConfiguration;
+            const postCssInstanceKey = JSON.stringify(config);
             let postcssProcessor = postcssProcessors.get(postCssInstanceKey)?.deref();
             if (!postcssProcessor) {
                 postcss ??= (await Promise.resolve().then(() => __importStar(require('postcss')))).default;
                 postcssProcessor = postcss();
-                for (const [pluginName, pluginOptions] of options.postcssConfiguration.plugins) {
-                    const { default: plugin } = await Promise.resolve(`${pluginName}`).then(s => __importStar(require(s)));
+                const postCssPluginRequire = (0, node_module_1.createRequire)((0, node_path_1.dirname)(configPath) + '/');
+                for (const [pluginName, pluginOptions] of config.plugins) {
+                    const plugin = postCssPluginRequire(pluginName);
                     if (typeof plugin !== 'function' || plugin.postcss !== true) {
                         throw new Error(`Attempted to load invalid Postcss plugin: "${pluginName}"`);
                     }

package/src/tools/vite/utils.js

@@ -53,6 +53,7 @@ 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.1';
+const VERSION = '21.0.0-next.3';
 function hasCacheMetadata(value) {
     return (!!value &&
         typeof value === 'object' &&

package/src/utils/postcss-configuration.d.ts

@@ -14,4 +14,7 @@ export interface SearchDirectory {
 }
 export declare function generateSearchDirectories(roots: string[]): Promise<SearchDirectory[]>;
 export declare function findTailwindConfiguration(searchDirectories: SearchDirectory[]): string | undefined;
-export declare function loadPostcssConfiguration(searchDirectories: SearchDirectory[]): Promise<PostcssConfiguration | undefined>;
+export declare function loadPostcssConfiguration(searchDirectories: SearchDirectory[]): Promise<{
+    configPath: string;
+    config: PostcssConfiguration;
+} | undefined>;

package/src/utils/postcss-configuration.js

@@ -67,7 +67,7 @@ async function loadPostcssConfiguration(searchDirectories) {
                 config.plugins.push(element);
             }
         }
-        return config;
+        return { config, configPath };
     }
     // Normalize plugin object map form
     const entries = Object.entries(raw.plugins);
@@ -81,5 +81,5 @@ async function loadPostcssConfiguration(searchDirectories) {
         }
         config.plugins.push([name, options]);
     }
-    return config;
+    return { config, configPath };
 }

package/src/utils/server-rendering/load-esm-from-memory.d.ts

@@ -6,12 +6,13 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { ApplicationRef, Type } from '@angular/core';
+import type { BootstrapContext } from '@angular/platform-browser';
 import type { ɵextractRoutesAndCreateRouteTree, ɵgetOrCreateAngularServerApp } from '@angular/ssr';
 /**
  * Represents the exports available from the main server bundle.
  */
 interface MainServerBundleExports {
-    default: (() => Promise<ApplicationRef>) | Type<unknown>;
+    default: ((context: BootstrapContext) => Promise<ApplicationRef>) | Type<unknown>;
     ɵextractRoutesAndCreateRouteTree: typeof ɵextractRoutesAndCreateRouteTree;
     ɵgetOrCreateAngularServerApp: typeof ɵgetOrCreateAngularServerApp;
 }

package/src/typings.d.ts

@@ -1,19 +0,0 @@
-/**
- * @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
- */
-
-// The `bundled_beasties` causes issues with module mappings in Bazel,
-// leading to unexpected behavior with esbuild. Specifically, the problem occurs
-// when esbuild resolves to a different module or version than expected, due to
-// how Bazel handles module mappings.
-//
-// This change aims to resolve esbuild types correctly and maintain consistency
-// in the Bazel build process.
-
-declare module 'esbuild' {
-  export * from 'esbuild-wasm';
-}