@angular/build 19.2.0-next.2 → 19.2.0

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

@@ -0,0 +1,144 @@
+"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.findTests = findTests;
+exports.getTestEntrypoints = getTestEntrypoints;
+const fast_glob_1 = __importStar(require("fast-glob"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/* Go through all patterns and find unique list of files */
+async function findTests(include, exclude, workspaceRoot, projectSourceRoot) {
+    const matchingTestsPromises = include.map((pattern) => findMatchingTests(pattern, exclude, workspaceRoot, projectSourceRoot));
+    const files = await Promise.all(matchingTestsPromises);
+    // Unique file names
+    return [...new Set(files.flat())];
+}
+/** Generate unique bundle names for a set of test files. */
+function getTestEntrypoints(testFiles, { projectSourceRoot, workspaceRoot }) {
+    const seen = new Set();
+    return new Map(Array.from(testFiles, (testFile) => {
+        const relativePath = removeRoots(testFile, [projectSourceRoot, workspaceRoot])
+            // Strip leading dots and path separators.
+            .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 uniqueName = baseName;
+        let suffix = 2;
+        while (seen.has(uniqueName)) {
+            uniqueName = `${baseName}-${suffix}`.replace(/([^\w](?:spec|test))-([\d]+)$/, '-$2$1');
+            ++suffix;
+        }
+        seen.add(uniqueName);
+        return [uniqueName, testFile];
+    }));
+}
+const normalizePath = (path) => path.replace(/\\/g, '/');
+const removeLeadingSlash = (pattern) => {
+    if (pattern.charAt(0) === '/') {
+        return pattern.substring(1);
+    }
+    return pattern;
+};
+const removeRelativeRoot = (path, root) => {
+    if (path.startsWith(root)) {
+        return path.substring(root.length);
+    }
+    return path;
+};
+function removeRoots(path, roots) {
+    for (const root of roots) {
+        if (path.startsWith(root)) {
+            return path.substring(root.length);
+        }
+    }
+    return (0, node_path_1.basename)(path);
+}
+async function findMatchingTests(pattern, ignore, workspaceRoot, projectSourceRoot) {
+    // normalize pattern, glob lib only accepts forward slashes
+    let normalizedPattern = normalizePath(pattern);
+    normalizedPattern = removeLeadingSlash(normalizedPattern);
+    const relativeProjectRoot = normalizePath((0, node_path_1.relative)(workspaceRoot, projectSourceRoot) + '/');
+    // remove relativeProjectRoot to support relative paths from root
+    // such paths are easy to get when running scripts via IDEs
+    normalizedPattern = removeRelativeRoot(normalizedPattern, relativeProjectRoot);
+    // special logic when pattern does not look like a glob
+    if (!(0, fast_glob_1.isDynamicPattern)(normalizedPattern)) {
+        if (await isDirectory((0, node_path_1.join)(projectSourceRoot, normalizedPattern))) {
+            normalizedPattern = `${normalizedPattern}/**/*.spec.@(ts|tsx)`;
+        }
+        else {
+            // see if matching spec file exists
+            const fileExt = (0, node_path_1.extname)(normalizedPattern);
+            // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts`
+            const potentialSpec = (0, node_path_1.join)(projectSourceRoot, (0, node_path_1.dirname)(normalizedPattern), `${(0, node_path_1.basename)(normalizedPattern, fileExt)}.spec${fileExt}`);
+            if (await exists(potentialSpec)) {
+                return [potentialSpec];
+            }
+        }
+    }
+    // normalize the patterns in the ignore list
+    const normalizedIgnorePatternList = ignore.map((pattern) => removeRelativeRoot(removeLeadingSlash(normalizePath(pattern)), relativeProjectRoot));
+    return (0, fast_glob_1.default)(normalizedPattern, {
+        cwd: projectSourceRoot,
+        absolute: true,
+        ignore: ['**/node_modules/**', ...normalizedIgnorePatternList],
+    });
+}
+async function isDirectory(path) {
+    try {
+        const stats = await node_fs_1.promises.stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function exists(path) {
+    try {
+        await node_fs_1.promises.access(path, node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/builders/karma/index.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 Builder, type BuilderContext, type BuilderOutput } from '@angular-devkit/architect';
+import type { ConfigOptions } from 'karma';
+import type { Schema as KarmaBuilderOptions } from './schema';
+export type KarmaConfigOptions = ConfigOptions & {
+    buildWebpack?: unknown;
+    configFile?: string;
+};
+/**
+ * @experimental Direct usage of this function is considered experimental.
+ */
+export declare function execute(options: KarmaBuilderOptions, context: BuilderContext, transforms?: {
+    karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions;
+}): AsyncIterable<BuilderOutput>;
+export type { KarmaBuilderOptions };
+declare const builder: Builder<KarmaBuilderOptions>;
+export default builder;

package/src/builders/karma/index.js

@@ -0,0 +1,135 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const architect_1 = require("@angular-devkit/architect");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * @experimental Direct usage of this function is considered experimental.
+ */
+async function* execute(options, context, transforms = {}) {
+    const { execute } = await Promise.resolve().then(() => __importStar(require('./application_builder')));
+    const karmaOptions = getBaseKarmaOptions(options, context);
+    yield* execute(options, context, karmaOptions, transforms);
+}
+function getBaseKarmaOptions(options, context) {
+    let singleRun;
+    if (options.watch !== undefined) {
+        singleRun = !options.watch;
+    }
+    // Determine project name from builder context target
+    const projectName = context.target?.project;
+    if (!projectName) {
+        throw new Error(`The 'karma' builder requires a target to be specified.`);
+    }
+    const karmaOptions = options.karmaConfig
+        ? {}
+        : getBuiltInKarmaConfig(context.workspaceRoot, projectName);
+    karmaOptions.singleRun = singleRun;
+    // Workaround https://github.com/angular/angular-cli/issues/28271, by clearing context by default
+    // for single run executions. Not clearing context for multi-run (watched) builds allows the
+    // Jasmine Spec Runner to be visible in the browser after test execution.
+    karmaOptions.client ??= {};
+    karmaOptions.client.clearContext ??= singleRun ?? false; // `singleRun` defaults to `false` per Karma docs.
+    // Convert browsers from a string to an array
+    if (typeof options.browsers === 'string' && options.browsers) {
+        karmaOptions.browsers = options.browsers.split(',');
+    }
+    else if (options.browsers === false) {
+        karmaOptions.browsers = [];
+    }
+    if (options.reporters) {
+        // Split along commas to make it more natural, and remove empty strings.
+        const reporters = options.reporters
+            .reduce((acc, curr) => acc.concat(curr.split(',')), [])
+            .filter((x) => !!x);
+        if (reporters.length > 0) {
+            karmaOptions.reporters = reporters;
+        }
+    }
+    return karmaOptions;
+}
+function getBuiltInKarmaConfig(workspaceRoot, projectName) {
+    let coverageFolderName = projectName.charAt(0) === '@' ? projectName.slice(1) : projectName;
+    coverageFolderName = coverageFolderName.toLowerCase();
+    const workspaceRootRequire = (0, node_module_1.createRequire)(workspaceRoot + '/');
+    // Any changes to the config here need to be synced to: packages/schematics/angular/config/files/karma.conf.js.template
+    return {
+        basePath: '',
+        frameworks: ['jasmine'],
+        plugins: [
+            'karma-jasmine',
+            'karma-chrome-launcher',
+            'karma-jasmine-html-reporter',
+            'karma-coverage',
+        ].map((p) => workspaceRootRequire(p)),
+        jasmineHtmlReporter: {
+            suppressAll: true, // removes the duplicated traces
+        },
+        coverageReporter: {
+            dir: node_path_1.default.join(workspaceRoot, 'coverage', coverageFolderName),
+            subdir: '.',
+            reporters: [{ type: 'html' }, { type: 'text-summary' }],
+        },
+        reporters: ['progress', 'kjhtml'],
+        browsers: ['Chrome'],
+        customLaunchers: {
+            // Chrome configured to run in a bazel sandbox.
+            // Disable the use of the gpu and `/dev/shm` because it causes Chrome to
+            // crash on some environments.
+            // See:
+            //   https://github.com/puppeteer/puppeteer/blob/v1.0.0/docs/troubleshooting.md#tips
+            //   https://stackoverflow.com/questions/50642308/webdriverexception-unknown-error-devtoolsactiveport-file-doesnt-exist-while-t
+            ChromeHeadlessNoSandbox: {
+                base: 'ChromeHeadless',
+                flags: ['--no-sandbox', '--headless', '--disable-gpu', '--disable-dev-shm-usage'],
+            },
+        },
+        restartOnFileChange: true,
+    };
+}
+const builder = (0, architect_1.createBuilder)(execute);
+exports.default = builder;

package/src/builders/karma/polyfills/init_sourcemaps.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+// eslint-disable-next-line no-undef
+globalThis.sourceMapSupport?.install();

package/src/builders/karma/polyfills/init_test_bed.js

@@ -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.dev/license
+ */
+
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+// Initialize the Angular testing environment.
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting(), {
+  errorOnUnknownElements: true,
+  errorOnUnknownProperties: true,
+});

package/src/builders/karma/polyfills/jasmine_global.js

@@ -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.dev/license
+ */
+
+// See: https://github.com/jasmine/jasmine/issues/2015
+(function () {
+  'use strict';
+
+  // jasmine will ignore `window` unless it returns this specific (but uncommon)
+  // value from toString().
+  window.toString = function () {
+    return '[object GjsGlobal]';
+  };
+})();

package/src/builders/karma/polyfills/jasmine_global_cleanup.js

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+
+// See: https://github.com/jasmine/jasmine/issues/2015
+(function () {
+  'use strict';
+
+  delete window.toString;
+})();

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

@@ -0,0 +1,248 @@
+/**
+ * Karma target options for Build Facade.
+ */
+export type Schema = {
+    /**
+     * Run tests using Ahead of Time compilation.
+     */
+    aot?: boolean;
+    /**
+     * List of static application assets.
+     */
+    assets?: AssetPattern[];
+    /**
+     * Override which browsers tests are run against. Set to `false` to not use any browser.
+     */
+    browsers?: Browsers;
+    /**
+     * Output a code coverage report.
+     */
+    codeCoverage?: boolean;
+    /**
+     * Globs to exclude from code coverage.
+     */
+    codeCoverageExclude?: string[];
+    /**
+     * Defines global identifiers that will be replaced with a specified constant value when
+     * found in any JavaScript or TypeScript code including libraries. The value will be used
+     * directly. String values must be put in quotes. Identifiers within Angular metadata such
+     * as Component Decorators will not be replaced.
+     */
+    define?: {
+        [key: string]: string;
+    };
+    /**
+     * Globs of files to exclude, relative to the project root.
+     */
+    exclude?: string[];
+    /**
+     * Exclude the listed external dependencies from being bundled into the bundle. Instead, the
+     * created bundle relies on these dependencies to be available during runtime.
+     */
+    externalDependencies?: string[];
+    /**
+     * Replace compilation source files with other compilation source files in the build.
+     */
+    fileReplacements?: FileReplacement[];
+    /**
+     * Globs of files to include, relative to project root.
+     * There are 2 special cases:
+     * - when a path to directory is provided, all spec files ending ".spec.@(ts|tsx)" will be
+     * included
+     * - when a path to a file is provided, and a matching spec file exists it will be included
+     * instead.
+     */
+    include?: string[];
+    /**
+     * The stylesheet language to use for the application's inline component styles.
+     */
+    inlineStyleLanguage?: InlineStyleLanguage;
+    /**
+     * The name of the Karma configuration file.
+     */
+    karmaConfig?: string;
+    /**
+     * Defines the type of loader to use with a specified file extension when used with a
+     * JavaScript `import`. `text` inlines the content as a string; `binary` inlines the content
+     * as a Uint8Array; `file` emits the file and provides the runtime location of the file;
+     * `empty` considers the content to be empty and not include it in bundles.
+     */
+    loader?: {
+        [key: string]: any;
+    };
+    /**
+     * The name of the main entry-point file.
+     */
+    main?: string;
+    /**
+     * Enable and define the file watching poll time period in milliseconds.
+     */
+    poll?: number;
+    /**
+     * 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'.
+     */
+    polyfills?: string[];
+    /**
+     * Do not use the real path when resolving modules. If unset then will default to `true` if
+     * NodeJS option --preserve-symlinks is set.
+     */
+    preserveSymlinks?: boolean;
+    /**
+     * Log progress to the console while building.
+     */
+    progress?: boolean;
+    /**
+     * Karma reporters to use. Directly passed to the karma runner.
+     */
+    reporters?: string[];
+    /**
+     * Global scripts to be included in the build.
+     */
+    scripts?: ScriptElement[];
+    /**
+     * Output source maps for scripts and styles. For more information, see
+     * https://angular.dev/reference/configs/workspace-config#source-map-configuration.
+     */
+    sourceMap?: SourceMapUnion;
+    /**
+     * Options to pass to style preprocessors.
+     */
+    stylePreprocessorOptions?: StylePreprocessorOptions;
+    /**
+     * Global styles to be included in the build.
+     */
+    styles?: StyleElement[];
+    /**
+     * The name of the TypeScript configuration file.
+     */
+    tsConfig: string;
+    /**
+     * Run build when files change.
+     */
+    watch?: boolean;
+    /**
+     * TypeScript configuration for Web Worker modules.
+     */
+    webWorkerTsConfig?: string;
+};
+export type AssetPattern = AssetPatternClass | string;
+export type AssetPatternClass = {
+    /**
+     * The pattern to match.
+     */
+    glob: string;
+    /**
+     * An array of globs to ignore.
+     */
+    ignore?: string[];
+    /**
+     * The input directory path in which to apply 'glob'. Defaults to the project root.
+     */
+    input: string;
+    /**
+     * Absolute path within the output.
+     */
+    output?: string;
+};
+/**
+ * Override which browsers tests are run against. Set to `false` to not use any browser.
+ */
+export type Browsers = boolean | string;
+export type FileReplacement = {
+    replace: string;
+    with: string;
+};
+/**
+ * The stylesheet language to use for the application's inline component styles.
+ */
+export declare enum InlineStyleLanguage {
+    Css = "css",
+    Less = "less",
+    Sass = "sass",
+    Scss = "scss"
+}
+export type ScriptElement = ScriptClass | string;
+export type ScriptClass = {
+    /**
+     * The bundle name for this extra entry point.
+     */
+    bundleName?: string;
+    /**
+     * If the bundle will be referenced in the HTML file.
+     */
+    inject?: boolean;
+    /**
+     * The file to include.
+     */
+    input: string;
+};
+/**
+ * Output source maps for scripts and styles. For more information, see
+ * https://angular.dev/reference/configs/workspace-config#source-map-configuration.
+ */
+export type SourceMapUnion = boolean | SourceMapClass;
+export type SourceMapClass = {
+    /**
+     * Output source maps for all scripts.
+     */
+    scripts?: boolean;
+    /**
+     * Output source maps for all styles.
+     */
+    styles?: boolean;
+    /**
+     * Resolve vendor packages source maps.
+     */
+    vendor?: boolean;
+};
+/**
+ * Options to pass to style preprocessors.
+ */
+export type StylePreprocessorOptions = {
+    /**
+     * Paths to include. Paths will be resolved to workspace root.
+     */
+    includePaths?: string[];
+    /**
+     * Options to pass to the sass preprocessor.
+     */
+    sass?: Sass;
+};
+/**
+ * Options to pass to the sass preprocessor.
+ */
+export type Sass = {
+    /**
+     * A set of deprecations to treat as fatal. If a deprecation warning of any provided type is
+     * encountered during compilation, the compiler will error instead. If a Version is
+     * provided, then all deprecations that were active in that compiler version will be treated
+     * as fatal.
+     */
+    fatalDeprecations?: string[];
+    /**
+     * A set of future deprecations to opt into early. Future deprecations passed here will be
+     * treated as active by the compiler, emitting warnings as necessary.
+     */
+    futureDeprecations?: string[];
+    /**
+     * A set of active deprecations to ignore. If a deprecation warning of any provided type is
+     * encountered during compilation, the compiler will ignore it instead.
+     */
+    silenceDeprecations?: string[];
+};
+export type StyleElement = StyleClass | string;
+export type StyleClass = {
+    /**
+     * The bundle name for this extra entry point.
+     */
+    bundleName?: string;
+    /**
+     * If the bundle will be referenced in the HTML file.
+     */
+    inject?: boolean;
+    /**
+     * The file to include.
+     */
+    input: string;
+};

package/src/builders/karma/schema.js

@@ -0,0 +1,15 @@
+"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 });
+exports.InlineStyleLanguage = void 0;
+/**
+ * The stylesheet language to use for the application's inline component styles.
+ */
+var InlineStyleLanguage;
+(function (InlineStyleLanguage) {
+    InlineStyleLanguage["Css"] = "css";
+    InlineStyleLanguage["Less"] = "less";
+    InlineStyleLanguage["Sass"] = "sass";
+    InlineStyleLanguage["Scss"] = "scss";
+})(InlineStyleLanguage || (exports.InlineStyleLanguage = InlineStyleLanguage = {}));