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

package/src/webpack/plugins/styles-webpack-plugin.js

@@ -0,0 +1,71 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylesWebpackPlugin = void 0;
+const assert_1 = __importDefault(require("assert"));
+const error_1 = require("../../utils/error");
+const webpack_diagnostics_1 = require("../../utils/webpack-diagnostics");
+/**
+ * The name of the plugin provided to Webpack when tapping Webpack compiler hooks.
+ */
+const PLUGIN_NAME = 'styles-webpack-plugin';
+class StylesWebpackPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const { entryPoints, preserveSymlinks, root } = this.options;
+        const webpackOptions = compiler.options;
+        const entry = typeof webpackOptions.entry === 'function' ? webpackOptions.entry() : webpackOptions.entry;
+        const resolver = compiler.resolverFactory.get('global-styles', {
+            conditionNames: ['sass', 'less', 'style'],
+            mainFields: ['sass', 'less', 'style', 'main', '...'],
+            extensions: ['.scss', '.sass', '.less', '.css'],
+            restrictions: [/\.((le|sa|sc|c)ss)$/i],
+            preferRelative: true,
+            useSyncFileSystemCalls: true,
+            symlinks: !preserveSymlinks,
+            fileSystem: compiler.inputFileSystem,
+        });
+        webpackOptions.entry = async () => {
+            var _a, _b;
+            var _c;
+            const entrypoints = await entry;
+            for (const [bundleName, paths] of Object.entries(entryPoints)) {
+                (_a = entrypoints[bundleName]) !== null && _a !== void 0 ? _a : (entrypoints[bundleName] = {});
+                const entryImport = ((_b = (_c = entrypoints[bundleName]).import) !== null && _b !== void 0 ? _b : (_c.import = []));
+                for (const path of paths) {
+                    try {
+                        const resolvedPath = resolver.resolveSync({}, root, path);
+                        if (resolvedPath) {
+                            entryImport.push(`${resolvedPath}?ngGlobalStyle`);
+                        }
+                        else {
+                            (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.');
+                            (0, webpack_diagnostics_1.addError)(this.compilation, `Cannot resolve '${path}'.`);
+                        }
+                    }
+                    catch (error) {
+                        (0, assert_1.default)(this.compilation, 'Compilation cannot be undefined.');
+                        (0, error_1.assertIsError)(error);
+                        (0, webpack_diagnostics_1.addError)(this.compilation, error.message);
+                    }
+                }
+            }
+            return entrypoints;
+        };
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            this.compilation = compilation;
+        });
+    }
+}
+exports.StylesWebpackPlugin = StylesWebpackPlugin;

package/src/webpack/plugins/transfer-size-plugin.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferSizePlugin = void 0;
 const util_1 = require("util");
 const zlib_1 = require("zlib");
+const webpack_diagnostics_1 = require("../../utils/webpack-diagnostics");
 const brotliCompressAsync = (0, util_1.promisify)(zlib_1.brotliCompress);
 const PLUGIN_NAME = 'angular-transfer-size-estimator';
 class TransferSizePlugin {
@@ -37,7 +38,7 @@ class TransferSizePlugin {
                         }));
                     })
                         .catch((error) => {
-                        compilation.warnings.push(new compilation.compiler.webpack.WebpackError(`Unable to calculate estimated transfer size for '${assetName}'. Reason: ${error.message}`));
+                        (0, webpack_diagnostics_1.addWarning)(compilation, `Unable to calculate estimated transfer size for '${assetName}'. Reason: ${error.message}`);
                     }));
                 }
                 await Promise.all(actions);

package/src/webpack/utils/helpers.d.ts

@@ -21,12 +21,15 @@ export declare type NormalizedEntryPoint = Required<Exclude<ScriptElement | Styl
 export declare function normalizeExtraEntryPoints(extraEntryPoints: (ScriptElement | StyleElement)[], defaultBundleName: string): NormalizedEntryPoint[];
 export declare function assetNameTemplateFactory(hashFormat: HashFormat): (resourcePath: string) => string;
 export declare function getInstrumentationExcludedPaths(root: string, excludedPaths: string[]): Set<string>;
+export declare function normalizeGlobalStyles(styleEntrypoints: StyleElement[]): {
+    entryPoints: Record<string, string[]>;
+    noInjectNames: string[];
+};
 export declare function getCacheSettings(wco: WebpackConfigOptions, angularVersion: string): WebpackOptionsNormalized['cache'];
-export declare function globalScriptsByBundleName(root: string, scripts: ScriptElement[]): {
+export declare function globalScriptsByBundleName(scripts: ScriptElement[]): {
     bundleName: string;
     inject: boolean;
     paths: string[];
 }[];
 export declare function assetPatterns(root: string, assets: AssetPatternClass[]): ObjectPattern[];
-export declare function externalizePackages(context: string, request: string | undefined, callback: (error?: Error, result?: string) => void): void;
 export declare function getStatsOptions(verbose?: boolean): WebpackStatsOptions;

package/src/webpack/utils/helpers.js

@@ -33,9 +33,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStatsOptions = exports.externalizePackages = exports.assetPatterns = exports.globalScriptsByBundleName = exports.getCacheSettings = exports.getInstrumentationExcludedPaths = exports.assetNameTemplateFactory = exports.normalizeExtraEntryPoints = exports.getOutputHashFormat = void 0;
+exports.getStatsOptions = exports.assetPatterns = exports.globalScriptsByBundleName = exports.getCacheSettings = exports.normalizeGlobalStyles = exports.getInstrumentationExcludedPaths = exports.assetNameTemplateFactory = exports.normalizeExtraEntryPoints = exports.getOutputHashFormat = void 0;
 const crypto_1 = require("crypto");
-const fs_1 = require("fs");
 const glob_1 = __importDefault(require("glob"));
 const path = __importStar(require("path"));
 const schema_1 = require("../../builders/browser/schema");
@@ -130,6 +129,26 @@ function getInstrumentationExcludedPaths(root, excludedPaths) {
     return excluded;
 }
 exports.getInstrumentationExcludedPaths = getInstrumentationExcludedPaths;
+function normalizeGlobalStyles(styleEntrypoints) {
+    var _a;
+    var _b;
+    const entryPoints = {};
+    const noInjectNames = [];
+    if (styleEntrypoints.length === 0) {
+        return { entryPoints, noInjectNames };
+    }
+    for (const style of normalizeExtraEntryPoints(styleEntrypoints, 'styles')) {
+        // Add style entry points.
+        (_a = entryPoints[_b = style.bundleName]) !== null && _a !== void 0 ? _a : (entryPoints[_b] = []);
+        entryPoints[style.bundleName].push(style.input);
+        // Add non injected styles to the list.
+        if (!style.inject) {
+            noInjectNames.push(style.bundleName);
+        }
+    }
+    return { entryPoints, noInjectNames };
+}
+exports.normalizeGlobalStyles = normalizeGlobalStyles;
 function getCacheSettings(wco, angularVersion) {
     const { enabled, path: cacheDirectory } = wco.buildOptions.cache;
     if (enabled) {
@@ -164,31 +183,22 @@ function getCacheSettings(wco, angularVersion) {
     return false;
 }
 exports.getCacheSettings = getCacheSettings;
-function globalScriptsByBundleName(root, scripts) {
+function globalScriptsByBundleName(scripts) {
     return normalizeExtraEntryPoints(scripts, 'scripts').reduce((prev, curr) => {
         const { bundleName, inject, input } = curr;
-        let resolvedPath = path.resolve(root, input);
-        if (!(0, fs_1.existsSync)(resolvedPath)) {
-            try {
-                resolvedPath = require.resolve(input, { paths: [root] });
-            }
-            catch {
-                throw new Error(`Script file ${input} does not exist.`);
-            }
-        }
         const existingEntry = prev.find((el) => el.bundleName === bundleName);
         if (existingEntry) {
             if (existingEntry.inject && !inject) {
                 // All entries have to be lazy for the bundle to be lazy.
                 throw new Error(`The ${bundleName} bundle is mixing injected and non-injected scripts.`);
             }
-            existingEntry.paths.push(resolvedPath);
+            existingEntry.paths.push(input);
         }
         else {
             prev.push({
                 bundleName,
                 inject,
-                paths: [resolvedPath],
+                paths: [input],
             });
         }
         return prev;
@@ -231,25 +241,6 @@ function assetPatterns(root, assets) {
     });
 }
 exports.assetPatterns = assetPatterns;
-function externalizePackages(context, request, callback) {
-    if (!request) {
-        return;
-    }
-    // Absolute & Relative paths are not externals
-    if (request.startsWith('.') || path.isAbsolute(request)) {
-        callback();
-        return;
-    }
-    try {
-        require.resolve(request, { paths: [context] });
-        callback(undefined, request);
-    }
-    catch {
-        // Node couldn't find it, so it must be user-aliased
-        callback();
-    }
-}
-exports.externalizePackages = externalizePackages;
 function getStatsOptions(verbose = false) {
     const webpackOutputOptions = {
         all: false,

package/src/webpack/plugins/single-test-transform.d.ts

@@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { logging } from '@angular-devkit/core';
-export interface SingleTestTransformLoaderOptions {
-    files?: string[];
-    logger?: logging.Logger;
-}
-export declare const SingleTestTransformLoader: string;
-/**
- * This loader transforms the default test file to only run tests
- * for some specs instead of all specs.
- * It works by replacing the known content of the auto-generated test file:
- *   const context = require.context('./', true, /\.spec\.ts$/);
- *   context.keys().map(context);
- * with:
- *   const context = { keys: () => ({ map: (_a) => { } }) };
- *   context.keys().map(context);
- * So that it does nothing.
- * Then it adds import statements for each file in the files options
- * array to import them directly, and thus run the tests there.
- */
-export default function loader(this: import('webpack').LoaderContext<SingleTestTransformLoaderOptions>, source: string): string;

package/src/webpack/plugins/single-test-transform.js

@@ -1,44 +0,0 @@
-"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.SingleTestTransformLoader = void 0;
-const core_1 = require("@angular-devkit/core");
-const path_1 = require("path");
-exports.SingleTestTransformLoader = __filename;
-/**
- * This loader transforms the default test file to only run tests
- * for some specs instead of all specs.
- * It works by replacing the known content of the auto-generated test file:
- *   const context = require.context('./', true, /\.spec\.ts$/);
- *   context.keys().map(context);
- * with:
- *   const context = { keys: () => ({ map: (_a) => { } }) };
- *   context.keys().map(context);
- * So that it does nothing.
- * Then it adds import statements for each file in the files options
- * array to import them directly, and thus run the tests there.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function loader(source) {
-    const { files = [], logger = console } = this.getOptions();
-    // signal the user that expected content is not present.
-    if (!source.includes('require.context(')) {
-        logger.error(core_1.tags.stripIndent `The 'include' option requires that the 'main' file for tests includes the below line:
-      const context = require.context('./', true, /\.spec\.ts$/);
-      Arguments passed to require.context are not strict and can be changed.`);
-        return source;
-    }
-    const targettedImports = files
-        .map((path) => `require('./${path.replace('.' + (0, path_1.extname)(path), '')}');`)
-        .join('\n');
-    const mockedRequireContext = 'Object.assign(() => { }, { keys: () => [], resolve: () => undefined });\n';
-    source = source.replace(/require\.context\(.*/, mockedRequireContext + targettedImports);
-    return source;
-}
-exports.default = loader;