@angular/build 20.2.2 → 21.0.0-next.1

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

@@ -0,0 +1,93 @@
+"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.dev/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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KarmaExecutor = void 0;
+class KarmaExecutor {
+    context;
+    options;
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+    }
+    async *execute() {
+        const { context, options: unitTestOptions } = this;
+        if (unitTestOptions.debug) {
+            context.logger.warn('The "karma" test runner does not support the "debug" option. The option will be ignored.');
+        }
+        if (unitTestOptions.setupFiles.length) {
+            context.logger.warn('The "karma" test runner does not support the "setupFiles" option. The option will be ignored.');
+        }
+        const buildTargetOptions = (await context.validateOptions(await context.getTargetOptions(unitTestOptions.buildTarget), await context.getBuilderNameForTarget(unitTestOptions.buildTarget)));
+        const karmaOptions = {
+            tsConfig: unitTestOptions.tsConfig,
+            polyfills: buildTargetOptions.polyfills,
+            assets: buildTargetOptions.assets,
+            scripts: buildTargetOptions.scripts,
+            styles: buildTargetOptions.styles,
+            inlineStyleLanguage: buildTargetOptions.inlineStyleLanguage,
+            stylePreprocessorOptions: buildTargetOptions.stylePreprocessorOptions,
+            externalDependencies: buildTargetOptions.externalDependencies,
+            loader: buildTargetOptions.loader,
+            define: buildTargetOptions.define,
+            include: unitTestOptions.include,
+            exclude: unitTestOptions.exclude,
+            sourceMap: buildTargetOptions.sourceMap,
+            progress: unitTestOptions.buildProgress ?? buildTargetOptions.progress,
+            watch: unitTestOptions.watch,
+            poll: buildTargetOptions.poll,
+            preserveSymlinks: buildTargetOptions.preserveSymlinks,
+            browsers: unitTestOptions.browsers?.join(','),
+            codeCoverage: !!unitTestOptions.codeCoverage,
+            codeCoverageExclude: unitTestOptions.codeCoverage?.exclude,
+            fileReplacements: buildTargetOptions.fileReplacements,
+            reporters: unitTestOptions.reporters,
+            webWorkerTsConfig: buildTargetOptions.webWorkerTsConfig,
+            aot: buildTargetOptions.aot,
+        };
+        const { execute } = await Promise.resolve().then(() => __importStar(require('../../../karma')));
+        yield* execute(karmaOptions, context);
+    }
+    async [Symbol.asyncDispose]() {
+        // The Karma builder handles its own teardown
+    }
+}
+exports.KarmaExecutor = KarmaExecutor;

package/src/builders/unit-test/runners/karma/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 type { TestRunner } from '../api';
+/**
+ * A declarative definition of the Karma test runner.
+ */
+declare const KarmaTestRunner: TestRunner;
+export default KarmaTestRunner;

package/src/builders/unit-test/runners/karma/index.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.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const executor_1 = require("./executor");
+/**
+ * A declarative definition of the Karma test runner.
+ */
+const KarmaTestRunner = {
+    name: 'karma',
+    isStandalone: true,
+    getBuildOptions() {
+        return {
+            buildOptions: {},
+        };
+    },
+    async createExecutor(context, options) {
+        return new executor_1.KarmaExecutor(context, options);
+    },
+};
+exports.default = KarmaTestRunner;

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+export declare function setupBrowserConfiguration(browsers: string[] | undefined, debug: boolean, projectSourceRoot: string): {
+    browser?: import('vitest/node').BrowserConfigOptions;
+    errors?: string[];
+};

package/src/builders/unit-test/runners/vitest/browser-provider.js

@@ -0,0 +1,69 @@
+"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.dev/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBrowserConfiguration = setupBrowserConfiguration;
+const node_module_1 = require("node:module");
+function findBrowserProvider(projectResolver) {
+    // One of these must be installed in the project to use browser testing
+    const vitestBuiltinProviders = ['playwright', 'webdriverio'];
+    for (const providerName of vitestBuiltinProviders) {
+        try {
+            projectResolver(providerName);
+            return providerName;
+        }
+        catch { }
+    }
+    return undefined;
+}
+function normalizeBrowserName(browserName) {
+    // Normalize browser names to match Vitest's expectations for headless but also supports karma's names
+    // e.g., 'ChromeHeadless' -> 'chrome', 'FirefoxHeadless' -> 'firefox'
+    // and 'Chrome' -> 'chrome', 'Firefox' -> 'firefox'.
+    const normalized = browserName.toLowerCase();
+    return normalized.replace(/headless$/, '');
+}
+function setupBrowserConfiguration(browsers, debug, projectSourceRoot) {
+    if (browsers === undefined) {
+        return {};
+    }
+    const projectResolver = (0, node_module_1.createRequire)(projectSourceRoot + '/').resolve;
+    let errors;
+    try {
+        projectResolver('@vitest/browser');
+    }
+    catch {
+        errors ??= [];
+        errors.push('The "browsers" option requires the "@vitest/browser" package to be installed within the project.' +
+            ' Please install this package and rerun the test command.');
+    }
+    const provider = findBrowserProvider(projectResolver);
+    if (!provider) {
+        errors ??= [];
+        errors.push('The "browsers" option requires either "playwright" or "webdriverio" to be installed within the project.' +
+            ' Please install one of these packages and rerun the test command.');
+    }
+    // Vitest current requires the playwright browser provider to use the inspect-brk option used by "debug"
+    if (debug && provider !== 'playwright') {
+        errors ??= [];
+        errors.push('Debugging browser mode tests currently requires the use of "playwright".' +
+            ' Please install this package and rerun the test command.');
+    }
+    if (errors) {
+        return { errors };
+    }
+    const browser = {
+        enabled: true,
+        provider,
+        headless: browsers.some((name) => name.toLowerCase().includes('headless')),
+        instances: browsers.map((browserName) => ({
+            browser: normalizeBrowserName(browserName),
+        })),
+    };
+    return { browser };
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type { ApplicationBuilderInternalOptions } from '../../../application/options';
+import { NormalizedUnitTestBuilderOptions } from '../../options';
+import { RunnerOptions } from '../api';
+export declare function getVitestBuildOptions(options: NormalizedUnitTestBuilderOptions, baseBuildOptions: Partial<ApplicationBuilderInternalOptions>): Promise<RunnerOptions>;

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

@@ -0,0 +1,87 @@
+"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.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVitestBuildOptions = getVitestBuildOptions;
+const node_path_1 = __importDefault(require("node:path"));
+const path_1 = require("../../../../utils/path");
+const schema_1 = require("../../../application/schema");
+const options_1 = require("../../options");
+const test_discovery_1 = require("../../test-discovery");
+function createTestBedInitVirtualFile(providersFile, projectSourceRoot) {
+    let providersImport = 'const providers = [];';
+    if (providersFile) {
+        const relativePath = node_path_1.default.relative(projectSourceRoot, providersFile);
+        const { dir, name } = node_path_1.default.parse(relativePath);
+        const importPath = (0, path_1.toPosixPath)(node_path_1.default.join(dir, name));
+        providersImport = `import providers from './${importPath}';`;
+    }
+    return `
+    // Initialize the Angular testing environment
+    import { NgModule } from '@angular/core';
+    import { getTestBed, ɵgetCleanupHook as getCleanupHook } from '@angular/core/testing';
+    import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
+    ${providersImport}
+    // Same as https://github.com/angular/angular/blob/05a03d3f975771bb59c7eefd37c01fa127ee2229/packages/core/testing/srcs/test_hooks.ts#L21-L29
+    beforeEach(getCleanupHook(false));
+    afterEach(getCleanupHook(true));
+    @NgModule({
+      providers,
+    })
+    export class TestModule {}
+    getTestBed().initTestEnvironment([BrowserTestingModule, TestModule], platformBrowserTesting(), {
+      errorOnUnknownElements: true,
+      errorOnUnknownProperties: true,
+    });
+  `;
+}
+async function getVitestBuildOptions(options, baseBuildOptions) {
+    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) {
+        throw new Error('No tests found matching the following patterns:\n' +
+            `- Included: ${include.join(', ')}\n` +
+            (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 });
+    entryPoints.set('init-testbed', 'angular:test-bed-init');
+    const buildOptions = {
+        ...baseBuildOptions,
+        watch,
+        incrementalResults: watch,
+        index: false,
+        browser: undefined,
+        server: undefined,
+        outputMode: undefined,
+        localize: false,
+        budgets: [],
+        serviceWorker: false,
+        appShell: false,
+        ssr: false,
+        prerender: false,
+        sourceMap: { scripts: true, vendor: false, styles: false },
+        outputHashing: schema_1.OutputHashing.None,
+        optimization: false,
+        tsConfig,
+        entryPoints,
+        externalDependencies: ['vitest', '@vitest/browser/context'],
+    };
+    buildOptions.polyfills = (0, options_1.injectTestingPolyfills)(buildOptions.polyfills);
+    const testBedInitContents = createTestBedInitVirtualFile(providersFile, projectSourceRoot);
+    return {
+        buildOptions,
+        virtualFiles: {
+            'angular:test-bed-init': testBedInitContents,
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @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 type { BuilderOutput } from '@angular-devkit/architect';
+import { type FullResult, type IncrementalResult } from '../../../application/results';
+import { NormalizedUnitTestBuilderOptions } from '../../options';
+import type { TestExecutor } from '../api';
+export declare class VitestExecutor implements TestExecutor {
+    private vitest;
+    private readonly projectName;
+    private readonly options;
+    private readonly outputPath;
+    private latestBuildResult;
+    private readonly sigintListener;
+    constructor(projectName: string, options: NormalizedUnitTestBuilderOptions);
+    execute(buildResult: FullResult | IncrementalResult): AsyncIterable<BuilderOutput>;
+    [Symbol.asyncDispose](): Promise<void>;
+    private initializeVitest;
+}

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

@@ -0,0 +1,200 @@
+"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.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 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 });
+    };
+    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;
+        // 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]);
+            }
+            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);
+                }
+            }
+        }
+        // Check if all the tests pass to calculate the result
+        const testModules = testResults?.testModules;
+        yield { success: testModules?.every((testModule) => testModule.ok()) ?? true };
+    }
+    async [Symbol.asyncDispose]() {
+        process.off('SIGINT', this.sigintListener);
+        await this.vitest?.close();
+        await (0, promises_1.rm)(this.outputPath, { recursive: true, force: true });
+    }
+    async initializeVitest() {
+        const { codeCoverage, reporters, workspaceRoot, setupFiles, browsers, debug, watch } = this.options;
+        const { outputPath, projectName, latestBuildResult } = this;
+        let vitestNodeModule;
+        try {
+            vitestNodeModule = await (0, load_esm_1.loadEsmModule)('vitest/node');
+        }
+        catch (error) {
+            (0, error_1.assertIsError)(error);
+            if (error.code !== 'ERR_MODULE_NOT_FOUND') {
+                throw error;
+            }
+            throw new Error('The `vitest` package was not found. Please install the package and rerun the test command.');
+        }
+        const { startVitest } = vitestNodeModule;
+        // Setup vitest browser options if configured
+        const browserOptions = (0, browser_provider_1.setupBrowserConfiguration)(browsers, debug, this.options.projectSourceRoot);
+        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);
+        }
+        const debugOptions = debug
+            ? {
+                inspectBrk: true,
+                isolate: false,
+                fileParallelism: false,
+            }
+            : {};
+        return startVitest('test', undefined, {
+            // Disable configuration file resolution/loading
+            config: false,
+            root: workspaceRoot,
+            project: ['base', projectName],
+            name: 'base',
+            include: [],
+            reporters: reporters ?? ['default'],
+            watch,
+            coverage: generateCoverageOption(codeCoverage, workspaceRoot, this.outputPath),
+            ...debugOptions,
+        }, {
+            server: {
+                // Disable the actual file watcher. The boolean watch option above should still
+                // 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',
+                        ];
+                    },
+                },
+            ],
+        });
+    }
+}
+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) {
+    if (!codeCoverage) {
+        return {
+            enabled: false,
+        };
+    }
+    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
+        ...(codeCoverage.reporters
+            ? { reporter: codeCoverage.reporters }
+            : {}),
+    };
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @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 type { TestRunner } from '../api';
+/**
+ * A declarative definition of the Vitest test runner.
+ */
+declare const VitestTestRunner: TestRunner;
+export default VitestTestRunner;

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

@@ -0,0 +1,30 @@
+"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.dev/license
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const build_options_1 = require("./build-options");
+const executor_1 = require("./executor");
+/**
+ * A declarative definition of the Vitest test runner.
+ */
+const VitestTestRunner = {
+    name: 'vitest',
+    getBuildOptions(options, baseBuildOptions) {
+        return (0, build_options_1.getVitestBuildOptions)(options, baseBuildOptions);
+    },
+    async createExecutor(context, options) {
+        const projectName = context.target?.project;
+        (0, node_assert_1.default)(projectName, 'The builder requires a target.');
+        return new executor_1.VitestExecutor(projectName, options);
+    },
+};
+exports.default = VitestTestRunner;

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

@@ -43,6 +43,10 @@ export type Schema = {
      * instead.
      */
     include?: string[];
+    /**
+     * Log progress to the console while building. Defaults to the build target's progress value.
+     */
+    progress?: boolean;
     /**
      * TypeScript file that exports an array of Angular providers to use during test execution.
      * The array must be a default export.

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

@@ -106,6 +106,10 @@
         "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."
+    },
+    "progress": {
+      "type": "boolean",
+      "description": "Log progress to the console while building. Defaults to the build target's progress value."
     }
   },
   "additionalProperties": false,

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

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export { findTests, getTestEntrypoints } from '../karma/find-tests';

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

@@ -0,0 +1,14 @@
+"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.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; } });

package/src/private.d.ts

@@ -17,7 +17,7 @@ import { BundleStylesheetOptions } from './tools/esbuild/stylesheets/bundle-opti
 export { buildApplicationInternal } from './builders/application';
 export type { ApplicationBuilderInternalOptions } from './builders/application/options';
 export { type Result, type ResultFile, ResultKind } from './builders/application/results';
-export { serveWithVite } from './builders/dev-server/vite-server';
+export { serveWithVite } from './builders/dev-server/vite';
 export * from './tools/babel/plugins';
 export type { ExternalResultMetadata } from './tools/esbuild/bundler-execution-result';
 export { emitFilesToDisk } from './tools/esbuild/utils';

package/src/private.js

@@ -38,8 +38,8 @@ var application_1 = require("./builders/application");
 Object.defineProperty(exports, "buildApplicationInternal", { enumerable: true, get: function () { return application_1.buildApplicationInternal; } });
 var results_1 = require("./builders/application/results");
 Object.defineProperty(exports, "ResultKind", { enumerable: true, get: function () { return results_1.ResultKind; } });
-var vite_server_1 = require("./builders/dev-server/vite-server");
-Object.defineProperty(exports, "serveWithVite", { enumerable: true, get: function () { return vite_server_1.serveWithVite; } });
+var vite_1 = require("./builders/dev-server/vite");
+Object.defineProperty(exports, "serveWithVite", { enumerable: true, get: function () { return vite_1.serveWithVite; } });
 // Tools
 __exportStar(require("./tools/babel/plugins"), exports);
 var utils_1 = require("./tools/esbuild/utils");