@angular-devkit/build-angular 13.0.0-rc.1 → 13.1.0-next.0

package/src/webpack/{configs → plugins}/typescript.js

@@ -7,7 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypescriptWorkerPlugin = exports.getTypeScriptConfig = void 0;
+exports.createIvyPlugin = void 0;
 const core_1 = require("@angular-devkit/core");
 const webpack_1 = require("@ngtools/webpack");
 const typescript_1 = require("typescript");
@@ -22,6 +22,9 @@ function ensureIvy(wco) {
     wco.tsConfig.options.enableIvy = true;
 }
 function createIvyPlugin(wco, aot, tsconfig) {
+    if (aot) {
+        ensureIvy(wco);
+    }
     const { buildOptions } = wco;
     const optimize = buildOptions.optimization.scripts;
     const compilerOptions = {
@@ -69,26 +72,4 @@ function createIvyPlugin(wco, aot, tsconfig) {
         inlineStyleFileExtension,
     });
 }
-function getTypeScriptConfig(wco) {
-    const { buildOptions: { aot = false, main, polyfills }, tsConfigPath, } = wco;
-    if (main || polyfills) {
-        ensureIvy(wco);
-        return {
-            module: {
-                rules: [
-                    {
-                        test: /\.[jt]sx?$/,
-                        loader: webpack_1.AngularWebpackLoaderPath,
-                    },
-                ],
-            },
-            plugins: [createIvyPlugin(wco, aot, tsConfigPath)],
-        };
-    }
-    return {};
-}
-exports.getTypeScriptConfig = getTypeScriptConfig;
-function getTypescriptWorkerPlugin(wco, workerTsConfigPath) {
-    return createIvyPlugin(wco, false, workerTsConfigPath);
-}
-exports.getTypescriptWorkerPlugin = getTypescriptWorkerPlugin;
+exports.createIvyPlugin = createIvyPlugin;

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

@@ -5,8 +5,10 @@
  * 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 { Configuration, SourceMapDevToolPlugin } from 'webpack';
-import { ExtraEntryPoint, ExtraEntryPointClass } from '../../builders/browser/schema';
+import type { ObjectPattern } from 'copy-webpack-plugin';
+import type { Configuration, WebpackOptionsNormalized } from 'webpack';
+import { AssetPatternClass, ExtraEntryPoint, ExtraEntryPointClass } from '../../builders/browser/schema';
+import { WebpackConfigOptions } from '../../utils/build-options';
 export interface HashFormat {
     chunk: string;
     extract: string;
@@ -16,7 +18,16 @@ export interface HashFormat {
 export declare function getOutputHashFormat(option: string, length?: number): HashFormat;
 export declare type NormalizedEntryPoint = Required<ExtraEntryPointClass>;
 export declare function normalizeExtraEntryPoints(extraEntryPoints: ExtraEntryPoint[], defaultBundleName: string): NormalizedEntryPoint[];
-export declare function getSourceMapDevTool(scriptsSourceMap: boolean | undefined, stylesSourceMap: boolean | undefined, hiddenSourceMap?: boolean, inlineSourceMap?: boolean): SourceMapDevToolPlugin;
-export declare function isPolyfillsEntry(name: string): boolean;
-export declare function getWatchOptions(poll: number | undefined): NonNullable<Configuration['watchOptions']>;
 export declare function assetNameTemplateFactory(hashFormat: HashFormat): (resourcePath: string) => string;
+export declare function getInstrumentationExcludedPaths(sourceRoot: string, excludedPaths: string[]): Set<string>;
+export declare function getCacheSettings(wco: WebpackConfigOptions, supportedBrowsers: string[], angularVersion: string): WebpackOptionsNormalized['cache'];
+export declare function globalScriptsByBundleName(root: string, scripts: ExtraEntryPoint[]): {
+    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;
+declare type WebpackStatsOptions = Exclude<Configuration['stats'], string | boolean>;
+export declare function getStatsOptions(verbose?: boolean): WebpackStatsOptions;
+export {};

package/src/webpack/utils/helpers.js

@@ -25,10 +25,15 @@ 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.assetNameTemplateFactory = exports.getWatchOptions = exports.isPolyfillsEntry = exports.getSourceMapDevTool = exports.normalizeExtraEntryPoints = exports.getOutputHashFormat = void 0;
+exports.getStatsOptions = exports.externalizePackages = exports.assetPatterns = exports.globalScriptsByBundleName = exports.getCacheSettings = 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 webpack_1 = require("webpack");
 function getOutputHashFormat(option, length = 20) {
     const hashFormats = {
         none: { chunk: '', extract: '', file: '', script: '' },
@@ -70,38 +75,6 @@ function normalizeExtraEntryPoints(extraEntryPoints, defaultBundleName) {
     });
 }
 exports.normalizeExtraEntryPoints = normalizeExtraEntryPoints;
-function getSourceMapDevTool(scriptsSourceMap, stylesSourceMap, hiddenSourceMap = false, inlineSourceMap = false) {
-    const include = [];
-    if (scriptsSourceMap) {
-        include.push(/js$/);
-    }
-    if (stylesSourceMap) {
-        include.push(/css$/);
-    }
-    return new webpack_1.SourceMapDevToolPlugin({
-        filename: inlineSourceMap ? undefined : '[file].map',
-        include,
-        // We want to set sourceRoot to  `webpack:///` for non
-        // inline sourcemaps as otherwise paths to sourcemaps will be broken in browser
-        // `webpack:///` is needed for Visual Studio breakpoints to work properly as currently
-        // there is no way to set the 'webRoot'
-        sourceRoot: 'webpack:///',
-        moduleFilenameTemplate: '[resource-path]',
-        append: hiddenSourceMap ? false : undefined,
-    });
-}
-exports.getSourceMapDevTool = getSourceMapDevTool;
-function isPolyfillsEntry(name) {
-    return name === 'polyfills';
-}
-exports.isPolyfillsEntry = isPolyfillsEntry;
-function getWatchOptions(poll) {
-    return {
-        poll,
-        ignored: poll === undefined ? '**/$_lazy_route_resources' : 'node_modules/**',
-    };
-}
-exports.getWatchOptions = getWatchOptions;
 function assetNameTemplateFactory(hashFormat) {
     const visitedFiles = new Map();
     return (resourcePath) => {
@@ -126,3 +99,170 @@ function assetNameTemplateFactory(hashFormat) {
     };
 }
 exports.assetNameTemplateFactory = assetNameTemplateFactory;
+function getInstrumentationExcludedPaths(sourceRoot, excludedPaths) {
+    const excluded = new Set();
+    for (const excludeGlob of excludedPaths) {
+        glob_1.default
+            .sync(path.join(sourceRoot, excludeGlob), { nodir: true })
+            .forEach((p) => excluded.add(path.normalize(p)));
+    }
+    return excluded;
+}
+exports.getInstrumentationExcludedPaths = getInstrumentationExcludedPaths;
+function getCacheSettings(wco, supportedBrowsers, angularVersion) {
+    const { enabled, path: cacheDirectory } = wco.buildOptions.cache;
+    if (enabled) {
+        const packageVersion = require('../../../package.json').version;
+        return {
+            type: 'filesystem',
+            cacheDirectory: path.join(cacheDirectory, 'angular-webpack'),
+            maxMemoryGenerations: 1,
+            // We use the versions and build options as the cache name. The Webpack configurations are too
+            // dynamic and shared among different build types: test, build and serve.
+            // None of which are "named".
+            name: (0, crypto_1.createHash)('sha1')
+                .update(angularVersion)
+                .update(packageVersion)
+                .update(wco.projectRoot)
+                .update(JSON.stringify(wco.tsConfig))
+                .update(JSON.stringify({
+                ...wco.buildOptions,
+                // Needed because outputPath changes on every build when using i18n extraction
+                // https://github.com/angular/angular-cli/blob/736a5f89deaca85f487b78aec9ff66d4118ceb6a/packages/angular_devkit/build_angular/src/utils/i18n-options.ts#L264-L265
+                outputPath: undefined,
+            }))
+                .update(supportedBrowsers.join(''))
+                .digest('hex'),
+        };
+    }
+    if (wco.buildOptions.watch) {
+        return {
+            type: 'memory',
+            maxGenerations: 1,
+        };
+    }
+    return false;
+}
+exports.getCacheSettings = getCacheSettings;
+function globalScriptsByBundleName(root, 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);
+        }
+        else {
+            prev.push({
+                bundleName,
+                inject,
+                paths: [resolvedPath],
+            });
+        }
+        return prev;
+    }, []);
+}
+exports.globalScriptsByBundleName = globalScriptsByBundleName;
+function assetPatterns(root, assets) {
+    return assets.map((asset, index) => {
+        // Resolve input paths relative to workspace root and add slash at the end.
+        // eslint-disable-next-line prefer-const
+        let { input, output, ignore = [], glob } = asset;
+        input = path.resolve(root, input).replace(/\\/g, '/');
+        input = input.endsWith('/') ? input : input + '/';
+        output = output.endsWith('/') ? output : output + '/';
+        if (output.startsWith('..')) {
+            throw new Error('An asset cannot be written to a location outside of the output path.');
+        }
+        return {
+            context: input,
+            // Now we remove starting slash to make Webpack place it from the output root.
+            to: output.replace(/^\//, ''),
+            from: glob,
+            noErrorOnMissing: true,
+            force: true,
+            globOptions: {
+                dot: true,
+                followSymbolicLinks: !!asset.followSymlinks,
+                ignore: [
+                    '.gitkeep',
+                    '**/.DS_Store',
+                    '**/Thumbs.db',
+                    // Negate patterns needs to be absolute because copy-webpack-plugin uses absolute globs which
+                    // causes negate patterns not to match.
+                    // See: https://github.com/webpack-contrib/copy-webpack-plugin/issues/498#issuecomment-639327909
+                    ...ignore,
+                ].map((i) => path.posix.join(input, i)),
+            },
+            priority: index,
+        };
+    });
+}
+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,
+        colors: true,
+        hash: true,
+        timings: true,
+        chunks: true,
+        builtAt: true,
+        warnings: true,
+        errors: true,
+        assets: true,
+        cachedAssets: true,
+        // Needed for markAsyncChunksNonInitial.
+        ids: true,
+        entrypoints: true,
+    };
+    const verboseWebpackOutputOptions = {
+        // The verbose output will most likely be piped to a file, so colors just mess it up.
+        colors: false,
+        usedExports: true,
+        optimizationBailout: true,
+        reasons: true,
+        children: true,
+        assets: true,
+        version: true,
+        chunkModules: true,
+        errorDetails: true,
+        moduleTrace: true,
+        logging: 'verbose',
+        modulesSpace: Infinity,
+    };
+    return verbose
+        ? { ...webpackOutputOptions, ...verboseWebpackOutputOptions }
+        : webpackOutputOptions;
+}
+exports.getStatsOptions = getStatsOptions;

package/src/webpack/utils/stats.js

@@ -34,7 +34,6 @@ const core_1 = require("@angular-devkit/core");
 const path = __importStar(require("path"));
 const text_table_1 = __importDefault(require("text-table"));
 const color_1 = require("../../utils/color");
-const stats_1 = require("../configs/stats");
 const async_chunks_1 = require("./async-chunks");
 const helpers_1 = require("./helpers");
 function formatSize(size) {
@@ -266,7 +265,7 @@ function createWebpackLoggingCallback(options, logger) {
         if (verbose) {
             logger.info(stats.toString(config.stats));
         }
-        const rawStats = stats.toJson((0, stats_1.getWebpackStatsConfig)(false));
+        const rawStats = stats.toJson((0, helpers_1.getStatsOptions)(false));
         const webpackStats = {
             ...rawStats,
             chunks: (0, async_chunks_1.markAsyncChunksNonInitial)(rawStats, extraEntryPoints),

package/src/webpack/configs/browser.js

@@ -1,81 +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.getBrowserConfig = void 0;
-const webpack_subresource_integrity_1 = require("webpack-subresource-integrity");
-const plugins_1 = require("../plugins");
-const helpers_1 = require("../utils/helpers");
-function getBrowserConfig(wco) {
-    const { buildOptions } = wco;
-    const { crossOrigin = 'none', subresourceIntegrity, vendorChunk, commonChunk, allowedCommonJsDependencies, } = buildOptions;
-    const extraPlugins = [];
-    const { styles: stylesSourceMap, scripts: scriptsSourceMap, hidden: hiddenSourceMap, } = buildOptions.sourceMap;
-    if (subresourceIntegrity) {
-        extraPlugins.push(new webpack_subresource_integrity_1.SubresourceIntegrityPlugin({
-            hashFuncNames: ['sha384'],
-        }));
-    }
-    if (scriptsSourceMap || stylesSourceMap) {
-        extraPlugins.push((0, helpers_1.getSourceMapDevTool)(scriptsSourceMap, stylesSourceMap, hiddenSourceMap, false));
-    }
-    let crossOriginLoading = false;
-    if (subresourceIntegrity && crossOrigin === 'none') {
-        crossOriginLoading = 'anonymous';
-    }
-    else if (crossOrigin !== 'none') {
-        crossOriginLoading = crossOrigin;
-    }
-    return {
-        devtool: false,
-        resolve: {
-            mainFields: ['es2020', 'es2015', 'browser', 'module', 'main'],
-            conditionNames: ['es2020', 'es2015', '...'],
-        },
-        output: {
-            crossOriginLoading,
-            trustedTypes: 'angular#bundler',
-            scriptType: 'module',
-        },
-        optimization: {
-            runtimeChunk: 'single',
-            splitChunks: {
-                maxAsyncRequests: Infinity,
-                cacheGroups: {
-                    default: !!commonChunk && {
-                        chunks: 'async',
-                        minChunks: 2,
-                        priority: 10,
-                    },
-                    common: !!commonChunk && {
-                        name: 'common',
-                        chunks: 'async',
-                        minChunks: 2,
-                        enforce: true,
-                        priority: 5,
-                    },
-                    vendors: false,
-                    defaultVendors: !!vendorChunk && {
-                        name: 'vendor',
-                        chunks: (chunk) => chunk.name === 'main',
-                        enforce: true,
-                        test: /[\\/]node_modules[\\/]/,
-                    },
-                },
-            },
-        },
-        plugins: [
-            new plugins_1.CommonJsUsageWarnPlugin({
-                allowedDependencies: allowedCommonJsDependencies,
-            }),
-            ...extraPlugins,
-        ],
-        node: false,
-    };
-}
-exports.getBrowserConfig = getBrowserConfig;

package/src/webpack/configs/server.d.ts

@@ -1,14 +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 { Configuration } from 'webpack';
-import { WebpackConfigOptions } from '../../utils/build-options';
-/**
- * Returns a partial Webpack configuration specific to creating a bundle for node
- * @param wco Options which include the build options and app config
- */
-export declare function getServerConfig(wco: WebpackConfigOptions): Configuration;

package/src/webpack/configs/server.js

@@ -1,72 +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.getServerConfig = void 0;
-const path_1 = require("path");
-const webpack_1 = require("webpack");
-const helpers_1 = require("../utils/helpers");
-/**
- * Returns a partial Webpack configuration specific to creating a bundle for node
- * @param wco Options which include the build options and app config
- */
-function getServerConfig(wco) {
-    const { sourceMap, bundleDependencies, externalDependencies = [] } = wco.buildOptions;
-    const extraPlugins = [];
-    const { scripts, styles, hidden } = sourceMap;
-    if (scripts || styles) {
-        extraPlugins.push((0, helpers_1.getSourceMapDevTool)(scripts, styles, hidden));
-    }
-    const externals = [...externalDependencies];
-    if (!bundleDependencies) {
-        externals.push(({ context, request }, callback) => externalizePackages(context !== null && context !== void 0 ? context : wco.projectRoot, request, callback));
-    }
-    return {
-        resolve: {
-            mainFields: ['es2020', 'es2015', 'main', 'module'],
-        },
-        output: {
-            libraryTarget: 'commonjs',
-        },
-        module: {
-            parser: {
-                javascript: {
-                    worker: false,
-                    url: false,
-                },
-            },
-        },
-        plugins: [
-            // Fixes Critical dependency: the request of a dependency is an expression
-            new webpack_1.ContextReplacementPlugin(/@?hapi(\\|\/)/),
-            new webpack_1.ContextReplacementPlugin(/express(\\|\/)/),
-            ...extraPlugins,
-        ],
-        node: false,
-        externals,
-    };
-}
-exports.getServerConfig = getServerConfig;
-function externalizePackages(context, request, callback) {
-    if (!request) {
-        return;
-    }
-    // Absolute & Relative paths are not externals
-    if (request.startsWith('.') || (0, path_1.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();
-    }
-}

package/src/webpack/configs/stats.d.ts

@@ -1,38 +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 { WebpackConfigOptions } from '../../utils/build-options';
-export declare function getWebpackStatsConfig(verbose?: boolean): {
-    all: boolean;
-    colors: boolean;
-    hash: boolean;
-    timings: boolean;
-    chunks: boolean;
-    builtAt: boolean;
-    warnings: boolean;
-    errors: boolean;
-    assets: boolean;
-    cachedAssets: boolean;
-    ids: boolean;
-    entrypoints: boolean;
-};
-export declare function getStatsConfig(wco: WebpackConfigOptions): {
-    stats: {
-        all: boolean;
-        colors: boolean;
-        hash: boolean;
-        timings: boolean;
-        chunks: boolean;
-        builtAt: boolean;
-        warnings: boolean;
-        errors: boolean;
-        assets: boolean;
-        cachedAssets: boolean;
-        ids: boolean;
-        entrypoints: boolean;
-    };
-};

package/src/webpack/configs/stats.js

@@ -1,53 +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.getStatsConfig = exports.getWebpackStatsConfig = void 0;
-const webpackOutputOptions = {
-    all: false,
-    colors: true,
-    hash: true,
-    timings: true,
-    chunks: true,
-    builtAt: true,
-    warnings: true,
-    errors: true,
-    assets: true,
-    cachedAssets: true,
-    // Needed for markAsyncChunksNonInitial.
-    ids: true,
-    entrypoints: true,
-};
-const verboseWebpackOutputOptions = {
-    // The verbose output will most likely be piped to a file, so colors just mess it up.
-    colors: false,
-    usedExports: true,
-    optimizationBailout: true,
-    reasons: true,
-    children: true,
-    assets: true,
-    version: true,
-    chunkModules: true,
-    errorDetails: true,
-    moduleTrace: true,
-    logging: 'verbose',
-    modulesSpace: Infinity,
-};
-function getWebpackStatsConfig(verbose = false) {
-    return verbose
-        ? { ...webpackOutputOptions, ...verboseWebpackOutputOptions }
-        : webpackOutputOptions;
-}
-exports.getWebpackStatsConfig = getWebpackStatsConfig;
-function getStatsConfig(wco) {
-    const verbose = !!wco.buildOptions.verbose;
-    return {
-        stats: getWebpackStatsConfig(verbose),
-    };
-}
-exports.getStatsConfig = getStatsConfig;

package/src/webpack/configs/test.d.ts

@@ -1,10 +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 * as webpack from 'webpack';
-import { WebpackConfigOptions, WebpackTestOptions } from '../../utils/build-options';
-export declare function getTestConfig(wco: WebpackConfigOptions<WebpackTestOptions>): webpack.Configuration;