@angular-devkit/build-angular 15.0.0-next.2 → 15.0.0-next.4

package/src/builders/browser-esbuild/watcher.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.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatcher = exports.ChangedFiles = void 0;
+const chokidar_1 = require("chokidar");
+class ChangedFiles {
+    constructor() {
+        this.added = new Set();
+        this.modified = new Set();
+        this.removed = new Set();
+    }
+    toDebugString() {
+        const content = {
+            added: Array.from(this.added),
+            modified: Array.from(this.modified),
+            removed: Array.from(this.removed),
+        };
+        return JSON.stringify(content, null, 2);
+    }
+}
+exports.ChangedFiles = ChangedFiles;
+function createWatcher(options) {
+    const watcher = new chokidar_1.FSWatcher({
+        ...options,
+        disableGlobbing: true,
+        ignoreInitial: true,
+    });
+    const nextQueue = [];
+    let currentChanges;
+    watcher.on('all', (event, path) => {
+        switch (event) {
+            case 'add':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.added.add(path);
+                break;
+            case 'change':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.modified.add(path);
+                break;
+            case 'unlink':
+                currentChanges !== null && currentChanges !== void 0 ? currentChanges : (currentChanges = new ChangedFiles());
+                currentChanges.removed.add(path);
+                break;
+            default:
+                return;
+        }
+        const next = nextQueue.shift();
+        if (next) {
+            const value = currentChanges;
+            currentChanges = undefined;
+            next(value);
+        }
+    });
+    return {
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        async next() {
+            if (currentChanges && nextQueue.length === 0) {
+                const result = { value: currentChanges };
+                currentChanges = undefined;
+                return result;
+            }
+            return new Promise((resolve) => {
+                nextQueue.push((value) => resolve(value ? { value } : { done: true, value }));
+            });
+        },
+        add(paths) {
+            watcher.add(paths);
+        },
+        remove(paths) {
+            watcher.unwatch(paths);
+        },
+        async close() {
+            try {
+                await watcher.close();
+            }
+            finally {
+                let next;
+                while ((next = nextQueue.shift()) !== undefined) {
+                    next();
+                }
+            }
+        },
+    };
+}
+exports.createWatcher = createWatcher;

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

@@ -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
+ */
+import type { Compiler } from 'webpack';
+export interface FindTestsPluginOptions {
+    include?: string[];
+    workspaceRoot: string;
+    projectSourceRoot: string;
+}
+export declare class FindTestsPlugin {
+    private options;
+    private compilation;
+    constructor(options: FindTestsPluginOptions);
+    apply(compiler: Compiler): void;
+}

package/src/builders/karma/{find-tests.js → find-tests-plugin.js}

@@ -29,13 +29,54 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.findTests = void 0;
+exports.FindTestsPlugin = void 0;
+const assert_1 = __importDefault(require("assert"));
 const fs_1 = require("fs");
 const glob_1 = __importStar(require("glob"));
 const path_1 = require("path");
 const util_1 = require("util");
+const webpack_diagnostics_1 = require("../../utils/webpack-diagnostics");
 const globPromise = (0, util_1.promisify)(glob_1.default);
+/**
+ * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.
+ */
+const PLUGIN_NAME = 'angular-find-tests-plugin';
+class FindTestsPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { include = ['**/*.spec.ts'], projectSourceRoot, workspaceRoot } = this.options;
+        const webpackOptions = compiler.options;
+        const entry = typeof webpackOptions.entry === 'function' ? webpackOptions.entry() : webpackOptions.entry;
+        let originalImport;
+        // Add tests files are part of the entry-point.
+        webpackOptions.entry = async () => {
+            const specFiles = await findTests(include, workspaceRoot, projectSourceRoot);
+            if (!specFiles.length) {
+                (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.');
+                (0, webpack_diagnostics_1.addError)(this.compilation, `Specified patterns: "${include.join(', ')}" did not match any spec files.`);
+            }
+            const entrypoints = await entry;
+            const entrypoint = entrypoints['main'];
+            if (!entrypoint.import) {
+                throw new Error(`Cannot find 'main' entrypoint.`);
+            }
+            originalImport !== null && originalImport !== void 0 ? originalImport : (originalImport = entrypoint.import);
+            entrypoint.import = [...originalImport, ...specFiles];
+            return entrypoints;
+        };
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            this.compilation = compilation;
+            compilation.contextDependencies.add(projectSourceRoot);
+        });
+    }
+}
+exports.FindTestsPlugin = FindTestsPlugin;
 // go through all patterns and find unique list of files
 async function findTests(patterns, workspaceRoot, projectSourceRoot) {
     const matchingTestsPromises = patterns.map((pattern) => findMatchingTests(pattern, workspaceRoot, projectSourceRoot));
@@ -43,11 +84,13 @@ async function findTests(patterns, workspaceRoot, projectSourceRoot) {
     // Unique file names
     return [...new Set(files.flat())];
 }
-exports.findTests = findTests;
 const normalizePath = (path) => path.replace(/\\/g, '/');
 async function findMatchingTests(pattern, workspaceRoot, projectSourceRoot) {
     // normalize pattern, glob lib only accepts forward slashes
     let normalizedPattern = normalizePath(pattern);
+    if (normalizedPattern.charAt(0) === '/') {
+        normalizedPattern = normalizedPattern.substring(1);
+    }
     const relativeProjectRoot = normalizePath((0, path_1.relative)(workspaceRoot, projectSourceRoot) + '/');
     // remove relativeProjectRoot to support relative paths from root
     // such paths are easy to get when running scripts via IDEs
@@ -63,9 +106,9 @@ async function findMatchingTests(pattern, workspaceRoot, projectSourceRoot) {
             // see if matching spec file exists
             const fileExt = (0, path_1.extname)(normalizedPattern);
             // Replace extension to `.spec.ext`. Example: `src/app/app.component.ts`-> `src/app/app.component.spec.ts`
-            const potentialSpec = (0, path_1.join)((0, path_1.dirname)(normalizedPattern), `${(0, path_1.basename)(normalizedPattern, fileExt)}.spec${fileExt}`);
-            if (await exists((0, path_1.join)(projectSourceRoot, potentialSpec))) {
-                return [normalizePath(potentialSpec)];
+            const potentialSpec = (0, path_1.join)(projectSourceRoot, (0, path_1.dirname)(normalizedPattern), `${(0, path_1.basename)(normalizedPattern, fileExt)}.spec${fileExt}`);
+            if (await exists(potentialSpec)) {
+                return [potentialSpec];
             }
         }
     }
@@ -73,6 +116,7 @@ async function findMatchingTests(pattern, workspaceRoot, projectSourceRoot) {
         cwd: projectSourceRoot,
         root: projectSourceRoot,
         nomount: true,
+        absolute: true,
     });
 }
 async function isDirectory(path) {

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

@@ -23,5 +23,5 @@ export declare function execute(options: KarmaBuilderOptions, context: BuilderCo
     karmaOptions?: (options: KarmaConfigOptions) => KarmaConfigOptions;
 }): Observable<BuilderOutput>;
 export { KarmaBuilderOptions };
-declare const _default: import("@angular-devkit/architect/src/internal").Builder<Record<string, string> & KarmaBuilderOptions & import("../../../../core/src").JsonObject>;
+declare const _default: import("@angular-devkit/architect/src/internal").Builder<Record<string, string> & KarmaBuilderOptions & import("@angular-devkit/core").JsonObject>;
 export default _default;

package/src/builders/karma/index.js

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execute = void 0;
 const architect_1 = require("@angular-devkit/architect");
+const core_1 = require("@angular-devkit/core");
+const karma_1 = require("karma");
+const module_1 = require("module");
 const path = __importStar(require("path"));
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
@@ -39,10 +42,10 @@ const purge_cache_1 = require("../../utils/purge-cache");
 const version_1 = require("../../utils/version");
 const webpack_browser_config_1 = require("../../utils/webpack-browser-config");
 const configs_1 = require("../../webpack/configs");
-const single_test_transform_1 = require("../../webpack/plugins/single-test-transform");
 const schema_1 = require("../browser/schema");
-const find_tests_1 = require("./find-tests");
+const find_tests_plugin_1 = require("./find-tests-plugin");
 async function initialize(options, context, webpackConfigurationTransformer) {
+    var _a;
     // Purge old build disk cache.
     await (0, purge_cache_1.purgeStaleBuildCache)(context);
     const { config } = await (0, webpack_browser_config_1.generateBrowserWebpackConfigFromContext)(
@@ -67,10 +70,7 @@ async function initialize(options, context, webpackConfigurationTransformer) {
         watch: true,
     }, context, (wco) => [(0, configs_1.getCommonConfig)(wco), (0, configs_1.getStylesConfig)(wco)]);
     const karma = await Promise.resolve().then(() => __importStar(require('karma')));
-    return [
-        karma,
-        webpackConfigurationTransformer ? await webpackConfigurationTransformer(config) : config,
-    ];
+    return [karma, (_a = (await (webpackConfigurationTransformer === null || webpackConfigurationTransformer === void 0 ? void 0 : webpackConfigurationTransformer(config)))) !== null && _a !== void 0 ? _a : config];
 }
 /**
  * @experimental Direct usage of this function is considered experimental.
@@ -84,9 +84,15 @@ function execute(options, context, transforms = {}) {
     }
     return (0, rxjs_1.from)(initialize(options, context, transforms.webpackConfiguration)).pipe((0, operators_1.switchMap)(async ([karma, webpackConfig]) => {
         var _a, _b, _c, _d, _e;
-        const karmaOptions = {
-            singleRun,
-        };
+        // Determine project name from builder context target
+        const projectName = (_a = context.target) === null || _a === void 0 ? void 0 : _a.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;
         // Convert browsers from a string to an array
         if (options.browsers) {
             karmaOptions.browsers = options.browsers.split(',');
@@ -100,47 +106,32 @@ function execute(options, context, transforms = {}) {
                 karmaOptions.reporters = reporters;
             }
         }
-        // prepend special webpack loader that will transform test.ts
-        if ((_a = options.include) === null || _a === void 0 ? void 0 : _a.length) {
-            const projectName = (_b = context.target) === null || _b === void 0 ? void 0 : _b.project;
-            if (!projectName) {
-                throw new Error('The builder requires a target.');
-            }
-            const projectMetadata = await context.getProjectMetadata(projectName);
-            const sourceRoot = ((_d = (_c = projectMetadata.sourceRoot) !== null && _c !== void 0 ? _c : projectMetadata.root) !== null && _d !== void 0 ? _d : '');
-            const projectSourceRoot = path.join(context.workspaceRoot, sourceRoot);
-            const files = await (0, find_tests_1.findTests)(options.include, context.workspaceRoot, projectSourceRoot);
-            // early exit, no reason to start karma
-            if (!files.length) {
-                throw new Error(`Specified patterns: "${options.include.join(', ')}" did not match any spec files.`);
-            }
-            // Get the rules and ensure the Webpack configuration is setup properly
-            const rules = ((_e = webpackConfig.module) === null || _e === void 0 ? void 0 : _e.rules) || [];
-            if (!webpackConfig.module) {
-                webpackConfig.module = { rules };
+        if (!options.main) {
+            (_b = webpackConfig.entry) !== null && _b !== void 0 ? _b : (webpackConfig.entry = {});
+            if (typeof webpackConfig.entry === 'object' && !Array.isArray(webpackConfig.entry)) {
+                if (Array.isArray(webpackConfig.entry['main'])) {
+                    webpackConfig.entry['main'].push(getBuiltInMainFile());
+                }
+                else {
+                    webpackConfig.entry['main'] = [getBuiltInMainFile()];
+                }
             }
-            else if (!webpackConfig.module.rules) {
-                webpackConfig.module.rules = rules;
-            }
-            rules.unshift({
-                test: path.resolve(context.workspaceRoot, options.main),
-                use: {
-                    // cannot be a simple path as it differs between environments
-                    loader: single_test_transform_1.SingleTestTransformLoader,
-                    options: {
-                        files,
-                        logger: context.logger,
-                    },
-                },
-            });
         }
+        const projectMetadata = await context.getProjectMetadata(projectName);
+        const sourceRoot = ((_d = (_c = projectMetadata.sourceRoot) !== null && _c !== void 0 ? _c : projectMetadata.root) !== null && _d !== void 0 ? _d : '');
+        (_e = webpackConfig.plugins) !== null && _e !== void 0 ? _e : (webpackConfig.plugins = []);
+        webpackConfig.plugins.push(new find_tests_plugin_1.FindTestsPlugin({
+            include: options.include,
+            workspaceRoot: context.workspaceRoot,
+            projectSourceRoot: path.join(context.workspaceRoot, sourceRoot),
+        }));
         karmaOptions.buildWebpack = {
             options,
             webpackConfig,
             logger: context.logger,
         };
-        const config = await karma.config.parseConfig(path.resolve(context.workspaceRoot, options.karmaConfig), transforms.karmaOptions ? transforms.karmaOptions(karmaOptions) : karmaOptions, { promiseConfig: true, throwErrors: true });
-        return [karma, config];
+        const parsedKarmaConfig = await karma_1.config.parseConfig(options.karmaConfig && path.resolve(context.workspaceRoot, options.karmaConfig), transforms.karmaOptions ? transforms.karmaOptions(karmaOptions) : karmaOptions, { promiseConfig: true, throwErrors: true });
+        return [karma, parsedKarmaConfig];
     }), (0, operators_1.switchMap)(([karma, karmaConfig]) => new rxjs_1.Observable((subscriber) => {
         var _a, _b, _c;
         var _d, _e;
@@ -163,4 +154,56 @@ function execute(options, context, transforms = {}) {
     })), (0, operators_1.defaultIfEmpty)({ success: false }));
 }
 exports.execute = execute;
+function getBuiltInKarmaConfig(workspaceRoot, projectName) {
+    let coverageFolderName = projectName.charAt(0) === '@' ? projectName.slice(1) : projectName;
+    if (/[A-Z]/.test(coverageFolderName)) {
+        coverageFolderName = core_1.strings.dasherize(coverageFolderName);
+    }
+    const workspaceRootRequire = (0, module_1.createRequire)(workspaceRoot + '/');
+    return {
+        basePath: '',
+        frameworks: ['jasmine', '@angular-devkit/build-angular'],
+        plugins: [
+            'karma-jasmine',
+            'karma-chrome-launcher',
+            'karma-jasmine-html-reporter',
+            'karma-coverage',
+            '@angular-devkit/build-angular/plugins/karma',
+        ].map((p) => workspaceRootRequire(p)),
+        client: {
+            clearContext: false, // leave Jasmine Spec Runner output visible in browser
+        },
+        jasmineHtmlReporter: {
+            suppressAll: true, // removes the duplicated traces
+        },
+        coverageReporter: {
+            dir: path.join(workspaceRoot, 'coverage', coverageFolderName),
+            subdir: '.',
+            reporters: [{ type: 'html' }, { type: 'text-summary' }],
+        },
+        reporters: ['progress', 'kjhtml'],
+        port: 9876,
+        colors: true,
+        logLevel: karma_1.constants.LOG_INFO,
+        autoWatch: true,
+        browsers: ['Chrome'],
+        restartOnFileChange: true,
+    };
+}
 exports.default = (0, architect_1.createBuilder)(execute);
+function getBuiltInMainFile() {
+    const content = Buffer.from(`
+  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
+  });
+`).toString('base64');
+    return `ng-virtual-main.js!=!data:text/javascript;base64,${content}`;
+}

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

@@ -38,19 +38,19 @@ export interface Schema {
     /**
      * The name of the Karma configuration file.
      */
-    karmaConfig: string;
+    karmaConfig?: string;
     /**
      * The name of the main entry-point file.
      */
-    main: string;
+    main?: string;
     /**
      * Enable and define the file watching poll time period in milliseconds.
      */
     poll?: number;
     /**
-     * The name of the polyfills file.
+     * Polyfills to be included in the build.
      */
-    polyfills?: string;
+    polyfills?: Polyfills;
     /**
      * Do not use the real path when resolving modules. If unset then will default to `true` if
      * NodeJS option --preserve-symlinks is set.
@@ -128,6 +128,10 @@ export declare enum InlineStyleLanguage {
     Sass = "sass",
     Scss = "scss"
 }
+/**
+ * Polyfills to be included in the build.
+ */
+export declare type Polyfills = string[] | string;
 export declare type ScriptElement = ScriptClass | string;
 export interface ScriptClass {
     /**

package/src/builders/karma/schema.json

@@ -17,8 +17,22 @@
       "description": "The name of the Karma configuration file."
     },
     "polyfills": {
-      "type": "string",
-      "description": "The name of the polyfills file."
+      "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'."
+        }
+      ]
     },
     "assets": {
       "type": "array",
@@ -126,6 +140,7 @@
       "items": {
         "type": "string"
       },
+      "default": ["**/*.spec.ts"],
       "description": "Globs of files to include, relative to workspace or project root. \nThere are 2 special cases:\n - when a path to directory is provided, all spec files ending \".spec.@(ts|tsx)\" will be included\n - when a path to a file is provided, and a matching spec file exists it will be included instead."
     },
     "sourceMap": {
@@ -240,7 +255,7 @@
     }
   },
   "additionalProperties": false,
-  "required": ["main", "tsConfig", "karmaConfig"],
+  "required": ["tsConfig"],
   "definitions": {
     "assetPattern": {
       "oneOf": [

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

@@ -1,9 +1,4 @@
 export interface Schema {
-    /**
-     * Which external dependencies to bundle into the bundle. By default, all of node_modules
-     * will be bundled.
-     */
-    bundleDependencies?: boolean;
     /**
      * Delete the output path before building.
      */

package/src/builders/server/schema.json

@@ -181,11 +181,6 @@
       "description": "Use file name for lazy loaded chunks.",
       "default": false
     },
-    "bundleDependencies": {
-      "description": "Which external dependencies to bundle into the bundle. By default, all of node_modules will be bundled.",
-      "default": true,
-      "type": "boolean"
-    },
     "externalDependencies": {
       "description": "Exclude the listed external dependencies from being bundled into the bundle. Instead, the created bundle relies on these dependencies to be available during runtime.",
       "type": "array",

package/src/sass/sass-service-legacy.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @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 { LegacyResult as CompileResult, LegacyException as Exception, LegacyOptions as Options } from 'sass';
+/**
+ * The callback type for the `dart-sass` asynchronous render function.
+ */
+declare type RenderCallback = (error?: Exception, result?: CompileResult) => void;
+/**
+ * A Sass renderer implementation that provides an interface that can be used by Webpack's
+ * `sass-loader`. The implementation uses a Worker thread to perform the Sass rendering
+ * with the `dart-sass` package.  The `dart-sass` synchronous render function is used within
+ * the worker which can be up to two times faster than the asynchronous variant.
+ */
+export declare class SassLegacyWorkerImplementation {
+    private readonly workers;
+    private readonly availableWorkers;
+    private readonly requests;
+    private readonly workerPath;
+    private idCounter;
+    private nextWorkerIndex;
+    /**
+     * Provides information about the Sass implementation.
+     * This mimics enough of the `dart-sass` value to be used with the `sass-loader`.
+     */
+    get info(): string;
+    /**
+     * The synchronous render function is not used by the `sass-loader`.
+     */
+    renderSync(): never;
+    /**
+     * Asynchronously request a Sass stylesheet to be renderered.
+     *
+     * @param options The `dart-sass` options to use when rendering the stylesheet.
+     * @param callback The function to execute when the rendering is complete.
+     */
+    render(options: Options<'async'>, callback: RenderCallback): void;
+    /**
+     * Shutdown the Sass render worker.
+     * Executing this method will stop any pending render requests.
+     */
+    close(): void;
+    private createWorker;
+    private processImporters;
+    private createRequest;
+}
+export {};