@angular-devkit/build-angular 16.0.0-rc.0 → 16.0.0-rc.2

package/src/builders/jest/index.js

@@ -0,0 +1,163 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const architect_1 = require("@angular-devkit/architect");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const color_1 = require("../../utils/color");
+const browser_esbuild_1 = require("../browser-esbuild");
+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) => {
+    context.logger.warn('NOTE: The Jest builder is currently EXPERIMENTAL and not ready for production use.');
+    const options = (0, options_1.normalizeOptions)(schema);
+    const testOut = 'dist/test-out'; // TODO(dgp1130): Hide in temp directory.
+    // Verify Jest installation and get the path to it's binary.
+    // We need to `node_modules/.bin/jest`, but there is no means to resolve that directly. Fortunately Jest's `package.json` exports the
+    // same file at `bin/jest`, so we can just resolve that instead.
+    const jest = resolveModule('jest/bin/jest');
+    if (!jest) {
+        return {
+            success: false,
+            // TODO(dgp1130): Display a more accurate message for non-NPM users.
+            error: 'Jest is not installed, most likely you need to run `npm install jest --save-dev` in your project.',
+        };
+    }
+    // Verify that JSDom is installed in the project.
+    const environment = resolveModule('jest-environment-jsdom');
+    if (!environment) {
+        return {
+            success: false,
+            // TODO(dgp1130): Display a more accurate message for non-NPM users.
+            error: '`jest-environment-jsdom` is not installed. Install it with `npm install jest-environment-jsdom --save-dev`.',
+        };
+    }
+    // Build all the test files.
+    const testFiles = await (0, test_files_1.findTestFiles)(options, context.workspaceRoot);
+    const jestGlobal = path.join(__dirname, 'jest-global.mjs');
+    const initTestBed = path.join(__dirname, 'init-test-bed.mjs');
+    const buildResult = await build(context, {
+        // Build all the test files and also the `jest-global` and `init-test-bed` scripts.
+        entryPoints: new Set([...testFiles, jestGlobal, initTestBed]),
+        tsConfig: options.tsConfig,
+        polyfills: options.polyfills ?? ['zone.js', 'zone.js/testing'],
+        outputPath: testOut,
+        aot: false,
+        index: null,
+        outputHashing: schema_1.OutputHashing.None,
+        outExtension: 'mjs',
+        commonChunk: false,
+        optimization: false,
+        buildOptimizer: false,
+        sourceMap: {
+            scripts: true,
+            styles: false,
+            vendor: false,
+        },
+    });
+    if (!buildResult.success) {
+        return buildResult;
+    }
+    // Execute Jest on the built output directory.
+    const jestProc = execFile('node', [
+        '--experimental-vm-modules',
+        jest,
+        `--rootDir="${testOut}"`,
+        '--testEnvironment=jsdom',
+        // TODO(dgp1130): Enable cache once we have a mechanism for properly clearing / disabling it.
+        '--no-cache',
+        // Run basically all files in the output directory, any excluded files were already dropped by the build.
+        `--testMatch="<rootDir>/**/*.mjs"`,
+        // Load polyfills and initialize the environment before executing each test file.
+        // IMPORTANT: Order matters here.
+        // First, we execute `jest-global.mjs` to initialize the `jest` global variable.
+        // Second, we execute user polyfills, including `zone.js` and `zone.js/testing`. This is dependent on the Jest global so it can patch
+        // the environment for fake async to work correctly.
+        // Third, we initialize `TestBed`. This is dependent on fake async being set up correctly beforehand.
+        `--setupFilesAfterEnv="<rootDir>/jest-global.mjs"`,
+        ...(options.polyfills ? [`--setupFilesAfterEnv="<rootDir>/polyfills.mjs"`] : []),
+        `--setupFilesAfterEnv="<rootDir>/init-test-bed.mjs"`,
+        // Don't run any infrastructure files as tests, they are manually loaded where needed.
+        `--testPathIgnorePatterns="<rootDir>/jest-global\\.mjs"`,
+        ...(options.polyfills ? [`--testPathIgnorePatterns="<rootDir>/polyfills\\.mjs"`] : []),
+        `--testPathIgnorePatterns="<rootDir>/init-test-bed\\.mjs"`,
+        // Skip shared chunks, as they are not entry points to tests.
+        `--testPathIgnorePatterns="<rootDir>/chunk-.*\\.mjs"`,
+        // Optionally enable color.
+        ...(color_1.colors.enabled ? ['--colors'] : []),
+    ]);
+    // Stream test output to the terminal.
+    jestProc.child.stdout?.on('data', (chunk) => {
+        context.logger.info(chunk);
+    });
+    jestProc.child.stderr?.on('data', (chunk) => {
+        // Write to stderr directly instead of `context.logger.error(chunk)` because the logger will overwrite Jest's coloring information.
+        process.stderr.write(chunk);
+    });
+    try {
+        await jestProc;
+    }
+    catch (error) {
+        // No need to propagate error message, already piped to terminal output.
+        // TODO(dgp1130): Handle process spawning failures.
+        return { success: false };
+    }
+    return { success: true };
+});
+async function build(context, options) {
+    try {
+        for await (const _ of (0, browser_esbuild_1.buildEsbuildBrowserInternal)(options, context)) {
+            // Nothing to do for each event, just wait for the whole build.
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: err.message,
+        };
+    }
+}
+/** Safely resolves the given Node module string. */
+function resolveModule(module) {
+    try {
+        return require.resolve(module);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/jest/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { execFile as execFileCb } from 'child_process';\nimport * as path from 'path';\nimport { promisify } from 'util';\nimport { colors } from '../../utils/color';\nimport { buildEsbuildBrowserInternal } from '../browser-esbuild';\nimport { BrowserEsbuildOptions } from '../browser-esbuild/options';\nimport { OutputHashing } from '../browser-esbuild/schema';\nimport { normalizeOptions } from './options';\nimport { Schema as JestBuilderSchema } from './schema';\nimport { findTestFiles } from './test-files';\n\nconst execFile = promisify(execFileCb);\n\n/** Main execution function for the Jest builder. */\nexport default createBuilder(\n  async (schema: JestBuilderSchema, context: BuilderContext): Promise<BuilderOutput> => {\n    context.logger.warn(\n      'NOTE: The Jest builder is currently EXPERIMENTAL and not ready for production use.',\n    );\n\n    const options = normalizeOptions(schema);\n    const testOut = 'dist/test-out'; // TODO(dgp1130): Hide in temp directory.\n\n    // Verify Jest installation and get the path to it's binary.\n    // We need to `node_modules/.bin/jest`, but there is no means to resolve that directly. Fortunately Jest's `package.json` exports the\n    // same file at `bin/jest`, so we can just resolve that instead.\n    const jest = resolveModule('jest/bin/jest');\n    if (!jest) {\n      return {\n        success: false,\n        // TODO(dgp1130): Display a more accurate message for non-NPM users.\n        error:\n          'Jest is not installed, most likely you need to run `npm install jest --save-dev` in your project.',\n      };\n    }\n\n    // Verify that JSDom is installed in the project.\n    const environment = resolveModule('jest-environment-jsdom');\n    if (!environment) {\n      return {\n        success: false,\n        // TODO(dgp1130): Display a more accurate message for non-NPM users.\n        error:\n          '`jest-environment-jsdom` is not installed. Install it with `npm install jest-environment-jsdom --save-dev`.',\n      };\n    }\n\n    // Build all the test files.\n    const testFiles = await findTestFiles(options, context.workspaceRoot);\n    const jestGlobal = path.join(__dirname, 'jest-global.mjs');\n    const initTestBed = path.join(__dirname, 'init-test-bed.mjs');\n    const buildResult = await build(context, {\n      // Build all the test files and also the `jest-global` and `init-test-bed` scripts.\n      entryPoints: new Set([...testFiles, jestGlobal, initTestBed]),\n      tsConfig: options.tsConfig,\n      polyfills: options.polyfills ?? ['zone.js', 'zone.js/testing'],\n      outputPath: testOut,\n      aot: false,\n      index: null,\n      outputHashing: OutputHashing.None,\n      outExtension: 'mjs', // Force native ESM.\n      commonChunk: false,\n      optimization: false,\n      buildOptimizer: false,\n      sourceMap: {\n        scripts: true,\n        styles: false,\n        vendor: false,\n      },\n    });\n    if (!buildResult.success) {\n      return buildResult;\n    }\n\n    // Execute Jest on the built output directory.\n    const jestProc = execFile('node', [\n      '--experimental-vm-modules',\n      jest,\n\n      `--rootDir=\"${testOut}\"`,\n      '--testEnvironment=jsdom',\n\n      // TODO(dgp1130): Enable cache once we have a mechanism for properly clearing / disabling it.\n      '--no-cache',\n\n      // Run basically all files in the output directory, any excluded files were already dropped by the build.\n      `--testMatch=\"<rootDir>/**/*.mjs\"`,\n\n      // Load polyfills and initialize the environment before executing each test file.\n      // IMPORTANT: Order matters here.\n      // First, we execute `jest-global.mjs` to initialize the `jest` global variable.\n      // Second, we execute user polyfills, including `zone.js` and `zone.js/testing`. This is dependent on the Jest global so it can patch\n      // the environment for fake async to work correctly.\n      // Third, we initialize `TestBed`. This is dependent on fake async being set up correctly beforehand.\n      `--setupFilesAfterEnv=\"<rootDir>/jest-global.mjs\"`,\n      ...(options.polyfills ? [`--setupFilesAfterEnv=\"<rootDir>/polyfills.mjs\"`] : []),\n      `--setupFilesAfterEnv=\"<rootDir>/init-test-bed.mjs\"`,\n\n      // Don't run any infrastructure files as tests, they are manually loaded where needed.\n      `--testPathIgnorePatterns=\"<rootDir>/jest-global\\\\.mjs\"`,\n      ...(options.polyfills ? [`--testPathIgnorePatterns=\"<rootDir>/polyfills\\\\.mjs\"`] : []),\n      `--testPathIgnorePatterns=\"<rootDir>/init-test-bed\\\\.mjs\"`,\n\n      // Skip shared chunks, as they are not entry points to tests.\n      `--testPathIgnorePatterns=\"<rootDir>/chunk-.*\\\\.mjs\"`,\n\n      // Optionally enable color.\n      ...(colors.enabled ? ['--colors'] : []),\n    ]);\n\n    // Stream test output to the terminal.\n    jestProc.child.stdout?.on('data', (chunk) => {\n      context.logger.info(chunk);\n    });\n    jestProc.child.stderr?.on('data', (chunk) => {\n      // Write to stderr directly instead of `context.logger.error(chunk)` because the logger will overwrite Jest's coloring information.\n      process.stderr.write(chunk);\n    });\n\n    try {\n      await jestProc;\n    } catch (error) {\n      // No need to propagate error message, already piped to terminal output.\n      // TODO(dgp1130): Handle process spawning failures.\n      return { success: false };\n    }\n\n    return { success: true };\n  },\n);\n\nasync function build(\n  context: BuilderContext,\n  options: BrowserEsbuildOptions,\n): Promise<BuilderOutput> {\n  try {\n    for await (const _ of buildEsbuildBrowserInternal(options, context)) {\n      // Nothing to do for each event, just wait for the whole build.\n    }\n\n    return { success: true };\n  } catch (err) {\n    return {\n      success: false,\n      error: (err as Error).message,\n    };\n  }\n}\n\n/** Safely resolves the given Node module string. */\nfunction resolveModule(module: string): string | undefined {\n  try {\n    return require.resolve(module);\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/src/builders/jest/init-test-bed.mjs

@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+
+// TODO(dgp1130): These imports likely don't resolve in stricter package environments like `pnpm`, since they are resolved relative to
+// `@angular-devkit/build-angular` rather than the user's workspace. Should look into virtual modules to support those use cases.
+
+import { getTestBed } from '@angular/core/testing';
+import { BrowserDynamicTestingModule, platformBrowserDynamicTesting } from '@angular/platform-browser-dynamic/testing';
+
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), {
+  errorOnUnknownElements: true,
+  errorOnUnknownProperties: true,
+});

package/src/builders/jest/jest-global.mjs

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+
+/**
+ * @fileoverview Zone.js requires the `jest` global to be initialized in order to know that it must patch the environment to support Jest
+ * execution. When running ESM code, Jest does _not_ inject the global `jest` symbol, so Zone.js would not normally know it is running
+ * within Jest as users are supposed to import from `@jest/globals` or use `import.meta.jest`. Zone.js is not currently aware of this, so we
+ * manually set this global to get Zone.js to run correctly.
+ * 
+ * TODO(dgp1130): Update Zone.js to directly support Jest ESM executions so we can drop this.
+ */
+
+// eslint-disable-next-line no-undef
+globalThis.jest = import.meta.jest;

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

@@ -0,0 +1,21 @@
+/**
+ * @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 JestBuilderSchema } from './schema';
+/**
+ * Options supported for the Jest builder. The schema is an approximate
+ * representation of the options type, but this is a more precise version.
+ */
+export type JestBuilderOptions = JestBuilderSchema & {
+    include: string[];
+    exclude: string[];
+};
+/**
+ * Normalizes input options validated by the schema to a more precise and useful
+ * options type in {@link JestBuilderOptions}.
+ */
+export declare function normalizeOptions(schema: JestBuilderSchema): JestBuilderOptions;

package/src/builders/jest/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 JestBuilderOptions}.
+ */
+function normalizeOptions(schema) {
+    return {
+        // 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 */
+        ...schema,
+    };
+}
+exports.normalizeOptions = normalizeOptions;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,25 @@
+/**
+ * Jest target options
+ */
+export interface Schema {
+    /**
+     * Globs of files to exclude, relative to the project root.
+     */
+    exclude?: string[];
+    /**
+     * Globs of files to include, relative to project root.
+     */
+    include?: string[];
+    /**
+     * Polyfills to be included in the build.
+     */
+    polyfills?: Polyfills;
+    /**
+     * The name of the TypeScript configuration file.
+     */
+    tsConfig: string;
+}
+/**
+ * Polyfills to be included in the build.
+ */
+export type Polyfills = string[] | string;

package/src/builders/jest/schema.js

@@ -0,0 +1,5 @@
+"use strict";
+// THIS FILE IS AUTOMATICALLY GENERATED. TO UPDATE THIS FILE YOU NEED TO CHANGE THE
+// CORRESPONDING JSON SCHEMA FILE, THEN RUN devkit-admin build (or bazel build ...).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhcl9kZXZraXQvYnVpbGRfYW5ndWxhci9zcmMvYnVpbGRlcnMvamVzdC9zY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLG1GQUFtRjtBQUNuRixvRkFBb0YiLCJzb3VyY2VzQ29udGVudCI6WyJcbi8vIFRISVMgRklMRSBJUyBBVVRPTUFUSUNBTExZIEdFTkVSQVRFRC4gVE8gVVBEQVRFIFRISVMgRklMRSBZT1UgTkVFRCBUTyBDSEFOR0UgVEhFXG4vLyBDT1JSRVNQT05ESU5HIEpTT04gU0NIRU1BIEZJTEUsIFRIRU4gUlVOIGRldmtpdC1hZG1pbiBidWlsZCAob3IgYmF6ZWwgYnVpbGQgLi4uKS5cblxuLyoqXG4gKiBKZXN0IHRhcmdldCBvcHRpb25zXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hIHtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBleGNsdWRlLCByZWxhdGl2ZSB0byB0aGUgcHJvamVjdCByb290LlxuICAgICAqL1xuICAgIGV4Y2x1ZGU/OiBzdHJpbmdbXTtcbiAgICAvKipcbiAgICAgKiBHbG9icyBvZiBmaWxlcyB0byBpbmNsdWRlLCByZWxhdGl2ZSB0byBwcm9qZWN0IHJvb3QuXG4gICAgICovXG4gICAgaW5jbHVkZT86IHN0cmluZ1tdO1xuICAgIC8qKlxuICAgICAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gICAgICovXG4gICAgcG9seWZpbGxzPzogUG9seWZpbGxzO1xuICAgIC8qKlxuICAgICAqIFRoZSBuYW1lIG9mIHRoZSBUeXBlU2NyaXB0IGNvbmZpZ3VyYXRpb24gZmlsZS5cbiAgICAgKi9cbiAgICB0c0NvbmZpZzogc3RyaW5nO1xufVxuXG4vKipcbiAqIFBvbHlmaWxscyB0byBiZSBpbmNsdWRlZCBpbiB0aGUgYnVpbGQuXG4gKi9cbmV4cG9ydCB0eXBlIFBvbHlmaWxscyA9IHN0cmluZ1tdIHwgc3RyaW5nO1xuIl19

package/src/builders/jest/schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Jest browser schema for Build Facade.",
+  "description": "Jest target options",
+  "type": "object",
+  "properties": {
+    "include": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": ["**/*.spec.ts"],
+      "description": "Globs of files to include, relative to project root."
+    },
+    "exclude": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": [],
+      "description": "Globs of files to exclude, relative to the project root."
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The name of the TypeScript configuration file."
+    },
+    "polyfills": {
+      "description": "Polyfills to be included in the build.",
+      "oneOf": [
+        {
+          "type": "array",
+          "description": "A list of polyfills to include in the build. Can be a full path for a file, relative to the current workspace or module specifier. Example: 'zone.js'.",
+          "items": {
+            "type": "string",
+            "uniqueItems": true
+          },
+          "default": []
+        },
+        {
+          "type": "string",
+          "description": "The full path for the polyfills file, relative to the current workspace or a module specifier. Example: 'zone.js'."
+        }
+      ]
+    }
+  },
+  "additionalProperties": false,
+  "required": ["tsConfig"]
+}

package/src/builders/jest/test-files.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { JestBuilderOptions } from './options';
+declare const globAsync: typeof import("glob").__promisify__;
+/**
+ * Finds all test files in the project.
+ *
+ * @param options The builder options describing where to find tests.
+ * @param workspaceRoot The path to the root directory of the workspace.
+ * @param glob A promisified implementation of the `glob` module. Only intended for
+ *     testing purposes.
+ * @returns A set of all test files in the project.
+ */
+export declare function findTestFiles(options: JestBuilderOptions, workspaceRoot: string, glob?: typeof globAsync): Promise<Set<string>>;
+export {};

package/src/builders/jest/test-files.js

@@ -0,0 +1,37 @@
+"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.findTestFiles = void 0;
+const glob_1 = require("glob");
+const util_1 = require("util");
+const globAsync = (0, util_1.promisify)(glob_1.glob);
+/**
+ * Finds all test files in the project.
+ *
+ * @param options The builder options describing where to find tests.
+ * @param workspaceRoot The path to the root directory of the workspace.
+ * @param glob A promisified implementation of the `glob` module. Only intended for
+ *     testing purposes.
+ * @returns A set of all test files in the project.
+ */
+async function findTestFiles(options, workspaceRoot, glob = globAsync) {
+    const globOptions = {
+        cwd: workspaceRoot,
+        ignore: ['node_modules/**'].concat(options.exclude),
+        strict: true,
+        nobrace: true,
+        noext: true,
+        nodir: true, // Match only files, don't care about directories.
+    };
+    const included = await Promise.all(options.include.map((pattern) => glob(pattern, globOptions)));
+    // Flatten and deduplicate any files found in multiple include patterns.
+    return new Set(included.flat());
+}
+exports.findTestFiles = findTestFiles;
+//# sourceMappingURL=data:application/json;base64,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

package/src/builders/server/index.js

@@ -33,7 +33,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.execute = void 0;
 const architect_1 = require("@angular-devkit/architect");
 const build_webpack_1 = require("@angular-devkit/build-webpack");
-const path = __importStar(require("path"));
+const promises_1 = require("node:fs/promises");
+const path = __importStar(require("node:path"));
 const rxjs_1 = require("rxjs");
 const utils_1 = require("../../utils");
 const color_1 = require("../../utils/color");
@@ -133,13 +134,13 @@ exports.default = (0, architect_1.createBuilder)(execute);
 async function initialize(options, context, webpackConfigurationTransform) {
     // Purge old build disk cache.
     await (0, purge_cache_1.purgeStaleBuildCache)(context);
+    await checkTsConfigForPreserveWhitespacesSetting(context, options.tsConfig);
     const browserslist = (await Promise.resolve().then(() => __importStar(require('browserslist')))).default;
     const originalOutputPath = options.outputPath;
     // Assets are processed directly by the builder except when watching
     const adjustedOptions = options.watch ? options : { ...options, assets: [] };
     const { config, projectRoot, projectSourceRoot, i18n } = await (0, webpack_browser_config_1.generateI18nBrowserWebpackConfigFromContext)({
         ...adjustedOptions,
-        buildOptimizer: false,
         aot: true,
         platform: 'server',
     }, context, (wco) => {
@@ -155,6 +156,25 @@ async function initialize(options, context, webpackConfigurationTransform) {
     const transformedConfig = (await webpackConfigurationTransform?.(config)) ?? config;
     return { config: transformedConfig, i18n, projectRoot, projectSourceRoot };
 }
+async function checkTsConfigForPreserveWhitespacesSetting(context, tsConfigPath) {
+    // We don't use the `readTsConfig` method on purpose here.
+    // To only catch cases were `preserveWhitespaces` is set directly in the `tsconfig.server.json`,
+    // which in the majority of cases will cause a mistmatch between client and server builds.
+    // Technically we should check if `tsconfig.server.json` and `tsconfig.app.json` values match.
+    // But:
+    // 1. It is not guaranteed that `tsconfig.app.json` is used to build the client side of this app.
+    // 2. There is no easy way to access the build build config from the server builder.
+    // 4. This will no longer be an issue with a single compilation model were the same tsconfig is used for both browser and server builds.
+    const content = await (0, promises_1.readFile)(path.join(context.workspaceRoot, tsConfigPath), 'utf-8');
+    const { parse } = await Promise.resolve().then(() => __importStar(require('jsonc-parser')));
+    const tsConfig = parse(content, [], { allowTrailingComma: true });
+    if (tsConfig.angularCompilerOptions?.preserveWhitespaces !== undefined) {
+        context.logger.warn(`"preserveWhitespaces" was set in "${tsConfigPath}". ` +
+            'Make sure that this setting is set consistently in both "tsconfig.server.json" for your server side ' +
+            'and "tsconfig.app.json" for your client side. A mismatched value will cause hydration to break.\n' +
+            'For more information see: https://angular.io/guide/hydration#preserve-whitespaces');
+    }
+}
 /**
  * Add `@angular/platform-server` exports.
  * This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.
@@ -178,4 +198,4 @@ function getPlatformServerExportsConfig(wco) {
         }
         : {};
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/server/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { runWebpack } from '@angular-devkit/build-webpack';\nimport * as path from 'path';\nimport { Observable, concatMap, from } from 'rxjs';\nimport webpack, { Configuration } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport {\n  NormalizedBrowserBuilderSchema,\n  deleteOutputDir,\n  normalizeAssetPatterns,\n} from '../../utils';\nimport { colors } from '../../utils/color';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { i18nInlineEmittedFiles } from '../../utils/i18n-inlining';\nimport { I18nOptions } from '../../utils/i18n-options';\nimport { ensureOutputPaths } from '../../utils/output-paths';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { Spinner } from '../../utils/spinner';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  BrowserWebpackConfigOptions,\n  generateI18nBrowserWebpackConfigFromContext,\n} from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { isPlatformServerInstalled } from '../../webpack/utils/helpers';\nimport {\n  statsErrorsToString,\n  statsHasErrors,\n  statsHasWarnings,\n  statsWarningsToString,\n  webpackStatsLogger,\n} from '../../webpack/utils/stats';\nimport { Schema as ServerBuilderOptions } from './schema';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type ServerBuilderOutput = BuilderOutput & {\n  baseOutputPath: string;\n  outputPath: string;\n  outputs: {\n    locale?: string;\n    path: string;\n  }[];\n};\n\nexport { ServerBuilderOptions };\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport function execute(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n  } = {},\n): Observable<ServerBuilderOutput> {\n  const root = context.workspaceRoot;\n\n  // Check Angular version.\n  assertCompatibleAngularVersion(root);\n\n  const baseOutputPath = path.resolve(root, options.outputPath);\n  let outputPaths: undefined | Map<string, string>;\n\n  return from(initialize(options, context, transforms.webpackConfiguration)).pipe(\n    concatMap(({ config, i18n, projectRoot, projectSourceRoot }) => {\n      return runWebpack(config, context, {\n        webpackFactory: require('webpack') as typeof webpack,\n        logging: (stats, config) => {\n          if (options.verbose) {\n            context.logger.info(stats.toString(config.stats));\n          }\n        },\n      }).pipe(\n        concatMap(async (output) => {\n          const { emittedFiles = [], outputPath, webpackStats, success } = output;\n          if (!webpackStats) {\n            throw new Error('Webpack stats build result is required.');\n          }\n\n          if (!success) {\n            if (statsHasWarnings(webpackStats)) {\n              context.logger.warn(statsWarningsToString(webpackStats, { colors: true }));\n            }\n            if (statsHasErrors(webpackStats)) {\n              context.logger.error(statsErrorsToString(webpackStats, { colors: true }));\n            }\n\n            return output;\n          }\n\n          const spinner = new Spinner();\n          spinner.enabled = options.progress !== false;\n          outputPaths = ensureOutputPaths(baseOutputPath, i18n);\n\n          // Copy assets\n          if (!options.watch && options.assets?.length) {\n            spinner.start('Copying assets...');\n            try {\n              await copyAssets(\n                normalizeAssetPatterns(\n                  options.assets,\n                  context.workspaceRoot,\n                  projectRoot,\n                  projectSourceRoot,\n                ),\n                Array.from(outputPaths.values()),\n                context.workspaceRoot,\n              );\n              spinner.succeed('Copying assets complete.');\n            } catch (err) {\n              spinner.fail(colors.redBright('Copying of assets failed.'));\n              assertIsError(err);\n\n              return {\n                ...output,\n                success: false,\n                error: 'Unable to copy assets: ' + err.message,\n              };\n            }\n          }\n\n          if (i18n.shouldInline) {\n            const success = await i18nInlineEmittedFiles(\n              context,\n              emittedFiles,\n              i18n,\n              baseOutputPath,\n              Array.from(outputPaths.values()),\n              [],\n              outputPath,\n              options.i18nMissingTranslation,\n            );\n            if (!success) {\n              return {\n                ...output,\n                success: false,\n              };\n            }\n          }\n\n          webpackStatsLogger(context.logger, webpackStats, config);\n\n          return output;\n        }),\n      );\n    }),\n    concatMap(async (output) => {\n      if (!output.success) {\n        return output as ServerBuilderOutput;\n      }\n\n      return {\n        ...output,\n        baseOutputPath,\n        outputs: (outputPaths &&\n          [...outputPaths.entries()].map(([locale, path]) => ({\n            locale,\n            path,\n          }))) || {\n          path: baseOutputPath,\n        },\n      } as ServerBuilderOutput;\n    }),\n  );\n}\n\nexport default createBuilder<ServerBuilderOptions, ServerBuilderOutput>(execute);\n\nasync function initialize(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,\n): Promise<{\n  config: webpack.Configuration;\n  i18n: I18nOptions;\n  projectRoot: string;\n  projectSourceRoot?: string;\n}> {\n  // Purge old build disk cache.\n  await purgeStaleBuildCache(context);\n\n  const browserslist = (await import('browserslist')).default;\n  const originalOutputPath = options.outputPath;\n  // Assets are processed directly by the builder except when watching\n  const adjustedOptions = options.watch ? options : { ...options, assets: [] };\n\n  const { config, projectRoot, projectSourceRoot, i18n } =\n    await generateI18nBrowserWebpackConfigFromContext(\n      {\n        ...adjustedOptions,\n        buildOptimizer: false,\n        aot: true,\n        platform: 'server',\n      } as NormalizedBrowserBuilderSchema,\n      context,\n      (wco) => {\n        // We use the platform to determine the JavaScript syntax output.\n        wco.buildOptions.supportedBrowsers ??= [];\n        wco.buildOptions.supportedBrowsers.push(...browserslist('maintained node versions'));\n\n        return [getPlatformServerExportsConfig(wco), getCommonConfig(wco), getStylesConfig(wco)];\n      },\n    );\n\n  if (options.deleteOutputPath) {\n    deleteOutputDir(context.workspaceRoot, originalOutputPath);\n  }\n\n  const transformedConfig = (await webpackConfigurationTransform?.(config)) ?? config;\n\n  return { config: transformedConfig, i18n, projectRoot, projectSourceRoot };\n}\n\n/**\n * Add `@angular/platform-server` exports.\n * This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n */\nfunction getPlatformServerExportsConfig(wco: BrowserWebpackConfigOptions): Partial<Configuration> {\n  // Add `@angular/platform-server` exports.\n  // This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n\n  // Only add `@angular/platform-server` exports when it is installed.\n  // In some cases this builder is used when `@angular/platform-server` is not installed.\n  // Example: when using `@nguniversal/common/clover` which does not need `@angular/platform-server`.\n\n  return isPlatformServerInstalled(wco.root)\n    ? {\n        module: {\n          rules: [\n            {\n              loader: require.resolve('./platform-server-exports-loader'),\n              include: [path.resolve(wco.root, wco.buildOptions.main)],\n            },\n          ],\n        },\n      }\n    : {};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../../../packages/angular_devkit/build_angular/src/builders/server/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';\nimport { runWebpack } from '@angular-devkit/build-webpack';\nimport { readFile } from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { Observable, concatMap, from } from 'rxjs';\nimport webpack, { Configuration } from 'webpack';\nimport { ExecutionTransformer } from '../../transforms';\nimport {\n  NormalizedBrowserBuilderSchema,\n  deleteOutputDir,\n  normalizeAssetPatterns,\n} from '../../utils';\nimport { colors } from '../../utils/color';\nimport { copyAssets } from '../../utils/copy-assets';\nimport { assertIsError } from '../../utils/error';\nimport { i18nInlineEmittedFiles } from '../../utils/i18n-inlining';\nimport { I18nOptions } from '../../utils/i18n-options';\nimport { ensureOutputPaths } from '../../utils/output-paths';\nimport { purgeStaleBuildCache } from '../../utils/purge-cache';\nimport { Spinner } from '../../utils/spinner';\nimport { assertCompatibleAngularVersion } from '../../utils/version';\nimport {\n  BrowserWebpackConfigOptions,\n  generateI18nBrowserWebpackConfigFromContext,\n} from '../../utils/webpack-browser-config';\nimport { getCommonConfig, getStylesConfig } from '../../webpack/configs';\nimport { isPlatformServerInstalled } from '../../webpack/utils/helpers';\nimport {\n  statsErrorsToString,\n  statsHasErrors,\n  statsHasWarnings,\n  statsWarningsToString,\n  webpackStatsLogger,\n} from '../../webpack/utils/stats';\nimport { Schema as ServerBuilderOptions } from './schema';\n\n/**\n * @experimental Direct usage of this type is considered experimental.\n */\nexport type ServerBuilderOutput = BuilderOutput & {\n  baseOutputPath: string;\n  outputPath: string;\n  outputs: {\n    locale?: string;\n    path: string;\n  }[];\n};\n\nexport { ServerBuilderOptions };\n\n/**\n * @experimental Direct usage of this function is considered experimental.\n */\nexport function execute(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  transforms: {\n    webpackConfiguration?: ExecutionTransformer<webpack.Configuration>;\n  } = {},\n): Observable<ServerBuilderOutput> {\n  const root = context.workspaceRoot;\n\n  // Check Angular version.\n  assertCompatibleAngularVersion(root);\n\n  const baseOutputPath = path.resolve(root, options.outputPath);\n  let outputPaths: undefined | Map<string, string>;\n\n  return from(initialize(options, context, transforms.webpackConfiguration)).pipe(\n    concatMap(({ config, i18n, projectRoot, projectSourceRoot }) => {\n      return runWebpack(config, context, {\n        webpackFactory: require('webpack') as typeof webpack,\n        logging: (stats, config) => {\n          if (options.verbose) {\n            context.logger.info(stats.toString(config.stats));\n          }\n        },\n      }).pipe(\n        concatMap(async (output) => {\n          const { emittedFiles = [], outputPath, webpackStats, success } = output;\n          if (!webpackStats) {\n            throw new Error('Webpack stats build result is required.');\n          }\n\n          if (!success) {\n            if (statsHasWarnings(webpackStats)) {\n              context.logger.warn(statsWarningsToString(webpackStats, { colors: true }));\n            }\n            if (statsHasErrors(webpackStats)) {\n              context.logger.error(statsErrorsToString(webpackStats, { colors: true }));\n            }\n\n            return output;\n          }\n\n          const spinner = new Spinner();\n          spinner.enabled = options.progress !== false;\n          outputPaths = ensureOutputPaths(baseOutputPath, i18n);\n\n          // Copy assets\n          if (!options.watch && options.assets?.length) {\n            spinner.start('Copying assets...');\n            try {\n              await copyAssets(\n                normalizeAssetPatterns(\n                  options.assets,\n                  context.workspaceRoot,\n                  projectRoot,\n                  projectSourceRoot,\n                ),\n                Array.from(outputPaths.values()),\n                context.workspaceRoot,\n              );\n              spinner.succeed('Copying assets complete.');\n            } catch (err) {\n              spinner.fail(colors.redBright('Copying of assets failed.'));\n              assertIsError(err);\n\n              return {\n                ...output,\n                success: false,\n                error: 'Unable to copy assets: ' + err.message,\n              };\n            }\n          }\n\n          if (i18n.shouldInline) {\n            const success = await i18nInlineEmittedFiles(\n              context,\n              emittedFiles,\n              i18n,\n              baseOutputPath,\n              Array.from(outputPaths.values()),\n              [],\n              outputPath,\n              options.i18nMissingTranslation,\n            );\n            if (!success) {\n              return {\n                ...output,\n                success: false,\n              };\n            }\n          }\n\n          webpackStatsLogger(context.logger, webpackStats, config);\n\n          return output;\n        }),\n      );\n    }),\n    concatMap(async (output) => {\n      if (!output.success) {\n        return output as ServerBuilderOutput;\n      }\n\n      return {\n        ...output,\n        baseOutputPath,\n        outputs: (outputPaths &&\n          [...outputPaths.entries()].map(([locale, path]) => ({\n            locale,\n            path,\n          }))) || {\n          path: baseOutputPath,\n        },\n      } as ServerBuilderOutput;\n    }),\n  );\n}\n\nexport default createBuilder<ServerBuilderOptions, ServerBuilderOutput>(execute);\n\nasync function initialize(\n  options: ServerBuilderOptions,\n  context: BuilderContext,\n  webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,\n): Promise<{\n  config: webpack.Configuration;\n  i18n: I18nOptions;\n  projectRoot: string;\n  projectSourceRoot?: string;\n}> {\n  // Purge old build disk cache.\n  await purgeStaleBuildCache(context);\n\n  await checkTsConfigForPreserveWhitespacesSetting(context, options.tsConfig);\n\n  const browserslist = (await import('browserslist')).default;\n  const originalOutputPath = options.outputPath;\n  // Assets are processed directly by the builder except when watching\n  const adjustedOptions = options.watch ? options : { ...options, assets: [] };\n\n  const { config, projectRoot, projectSourceRoot, i18n } =\n    await generateI18nBrowserWebpackConfigFromContext(\n      {\n        ...adjustedOptions,\n        aot: true,\n        platform: 'server',\n      } as NormalizedBrowserBuilderSchema,\n      context,\n      (wco) => {\n        // We use the platform to determine the JavaScript syntax output.\n        wco.buildOptions.supportedBrowsers ??= [];\n        wco.buildOptions.supportedBrowsers.push(...browserslist('maintained node versions'));\n\n        return [getPlatformServerExportsConfig(wco), getCommonConfig(wco), getStylesConfig(wco)];\n      },\n    );\n\n  if (options.deleteOutputPath) {\n    deleteOutputDir(context.workspaceRoot, originalOutputPath);\n  }\n\n  const transformedConfig = (await webpackConfigurationTransform?.(config)) ?? config;\n\n  return { config: transformedConfig, i18n, projectRoot, projectSourceRoot };\n}\n\nasync function checkTsConfigForPreserveWhitespacesSetting(\n  context: BuilderContext,\n  tsConfigPath: string,\n): Promise<void> {\n  // We don't use the `readTsConfig` method on purpose here.\n  // To only catch cases were `preserveWhitespaces` is set directly in the `tsconfig.server.json`,\n  // which in the majority of cases will cause a mistmatch between client and server builds.\n  // Technically we should check if `tsconfig.server.json` and `tsconfig.app.json` values match.\n\n  // But:\n  // 1. It is not guaranteed that `tsconfig.app.json` is used to build the client side of this app.\n  // 2. There is no easy way to access the build build config from the server builder.\n  // 4. This will no longer be an issue with a single compilation model were the same tsconfig is used for both browser and server builds.\n  const content = await readFile(path.join(context.workspaceRoot, tsConfigPath), 'utf-8');\n  const { parse } = await import('jsonc-parser');\n  const tsConfig = parse(content, [], { allowTrailingComma: true });\n  if (tsConfig.angularCompilerOptions?.preserveWhitespaces !== undefined) {\n    context.logger.warn(\n      `\"preserveWhitespaces\" was set in \"${tsConfigPath}\". ` +\n        'Make sure that this setting is set consistently in both \"tsconfig.server.json\" for your server side ' +\n        'and \"tsconfig.app.json\" for your client side. A mismatched value will cause hydration to break.\\n' +\n        'For more information see: https://angular.io/guide/hydration#preserve-whitespaces',\n    );\n  }\n}\n\n/**\n * Add `@angular/platform-server` exports.\n * This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n */\nfunction getPlatformServerExportsConfig(wco: BrowserWebpackConfigOptions): Partial<Configuration> {\n  // Add `@angular/platform-server` exports.\n  // This is needed so that DI tokens can be referenced and set at runtime outside of the bundle.\n\n  // Only add `@angular/platform-server` exports when it is installed.\n  // In some cases this builder is used when `@angular/platform-server` is not installed.\n  // Example: when using `@nguniversal/common/clover` which does not need `@angular/platform-server`.\n\n  return isPlatformServerInstalled(wco.root)\n    ? {\n        module: {\n          rules: [\n            {\n              loader: require.resolve('./platform-server-exports-loader'),\n              include: [path.resolve(wco.root, wco.buildOptions.main)],\n            },\n          ],\n        },\n      }\n    : {};\n}\n"]}

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

@@ -3,6 +3,10 @@ export interface Schema {
      * List of static application assets.
      */
     assets?: AssetPattern[];
+    /**
+     * Enables advanced build optimizations.
+     */
+    buildOptimizer?: boolean;
     /**
      * Delete the output path before building.
      */