@angular-devkit/build-angular 16.1.0-next.2 → 16.1.0

package/src/tools/webpack/configs/common.js

@@ -0,0 +1,421 @@
+"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 __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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.getCommonConfig = void 0;
+const webpack_1 = require("@ngtools/webpack");
+const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
+const path = __importStar(require("path"));
+const webpack_2 = require("webpack");
+const webpack_subresource_integrity_1 = require("webpack-subresource-integrity");
+const environment_options_1 = require("../../../utils/environment-options");
+const load_esm_1 = require("../../../utils/load-esm");
+const plugins_1 = require("../plugins");
+const devtools_ignore_plugin_1 = require("../plugins/devtools-ignore-plugin");
+const named_chunks_plugin_1 = require("../plugins/named-chunks-plugin");
+const occurrences_plugin_1 = require("../plugins/occurrences-plugin");
+const progress_plugin_1 = require("../plugins/progress-plugin");
+const transfer_size_plugin_1 = require("../plugins/transfer-size-plugin");
+const typescript_1 = require("../plugins/typescript");
+const watch_files_logs_plugin_1 = require("../plugins/watch-files-logs-plugin");
+const helpers_1 = require("../utils/helpers");
+const VENDORS_TEST = /[\\/]node_modules[\\/]/;
+// eslint-disable-next-line max-lines-per-function
+async function getCommonConfig(wco) {
+    const { root, projectRoot, buildOptions, tsConfig, projectName, sourceRoot, tsConfigPath } = wco;
+    const { cache, codeCoverage, crossOrigin = 'none', platform = 'browser', aot = true, codeCoverageExclude = [], main, sourceMap: { styles: stylesSourceMap, scripts: scriptsSourceMap, vendor: vendorSourceMap, hidden: hiddenSourceMap, }, optimization: { styles: stylesOptimization, scripts: scriptsOptimization }, commonChunk, vendorChunk, subresourceIntegrity, verbose, poll, webWorkerTsConfig, externalDependencies = [], allowedCommonJsDependencies, } = buildOptions;
+    const isPlatformServer = buildOptions.platform === 'server';
+    const extraPlugins = [];
+    const extraRules = [];
+    const entryPoints = {};
+    // Load ESM `@angular/compiler-cli` using the TypeScript dynamic import workaround.
+    // Once TypeScript provides support for keeping the dynamic import this workaround can be
+    // changed to a direct dynamic import.
+    const { GLOBAL_DEFS_FOR_TERSER, GLOBAL_DEFS_FOR_TERSER_WITH_AOT, VERSION: NG_VERSION, } = await (0, load_esm_1.loadEsmModule)('@angular/compiler-cli');
+    // determine hashing format
+    const hashFormat = (0, helpers_1.getOutputHashFormat)(buildOptions.outputHashing);
+    if (buildOptions.progress) {
+        extraPlugins.push(new progress_plugin_1.ProgressPlugin(platform));
+    }
+    const localizePackageInitEntryPoint = '@angular/localize/init';
+    const hasLocalizeType = tsConfig.options.types?.some((t) => t === '@angular/localize' || t === localizePackageInitEntryPoint);
+    if (hasLocalizeType) {
+        entryPoints['main'] = [localizePackageInitEntryPoint];
+    }
+    if (buildOptions.main) {
+        const mainPath = path.resolve(root, buildOptions.main);
+        if (Array.isArray(entryPoints['main'])) {
+            entryPoints['main'].push(mainPath);
+        }
+        else {
+            entryPoints['main'] = [mainPath];
+        }
+    }
+    if (isPlatformServer) {
+        // Fixes Critical dependency: the request of a dependency is an expression
+        extraPlugins.push(new webpack_2.ContextReplacementPlugin(/@?hapi|express[\\/]/));
+        if ((0, helpers_1.isPlatformServerInstalled)(wco.root) && Array.isArray(entryPoints['main'])) {
+            // This import must come before any imports (direct or transitive) that rely on DOM built-ins being
+            // available, such as `@angular/elements`.
+            entryPoints['main'].unshift('@angular/platform-server/init');
+        }
+    }
+    const polyfills = [...buildOptions.polyfills];
+    if (!aot) {
+        polyfills.push('@angular/compiler');
+    }
+    if (polyfills.length) {
+        // `zone.js/testing` is a **special** polyfill because when not imported in the main it fails with the below errors:
+        // `Error: Expected to be running in 'ProxyZone', but it was not found.`
+        // This was also the reason why previously it was imported in `test.ts` as the first module.
+        // From Jia li:
+        // This is because the jasmine functions such as beforeEach/it will not be patched by zone.js since
+        // jasmine will not be loaded yet, so the ProxyZone will not be there. We have to load zone-testing.js after
+        // jasmine is ready.
+        // We could force loading 'zone.js/testing' prior to jasmine by changing the order of scripts in 'karma-context.html'.
+        // But this has it's own problems as zone.js needs to be loaded prior to jasmine due to patching of timing functions
+        // See: https://github.com/jasmine/jasmine/issues/1944
+        // Thus the correct order is zone.js -> jasmine -> zone.js/testing.
+        const zoneTestingEntryPoint = 'zone.js/testing';
+        const polyfillsExludingZoneTesting = polyfills.filter((p) => p !== zoneTestingEntryPoint);
+        if (Array.isArray(entryPoints['polyfills'])) {
+            entryPoints['polyfills'].push(...polyfillsExludingZoneTesting);
+        }
+        else {
+            entryPoints['polyfills'] = polyfillsExludingZoneTesting;
+        }
+        if (polyfillsExludingZoneTesting.length !== polyfills.length) {
+            if (Array.isArray(entryPoints['main'])) {
+                entryPoints['main'].unshift(zoneTestingEntryPoint);
+            }
+            else {
+                entryPoints['main'] = [zoneTestingEntryPoint];
+            }
+        }
+    }
+    if (allowedCommonJsDependencies) {
+        // When this is not defined it means the builder doesn't support showing common js usages.
+        // When it does it will be an array.
+        extraPlugins.push(new plugins_1.CommonJsUsageWarnPlugin({
+            allowedDependencies: allowedCommonJsDependencies,
+        }));
+    }
+    // process global scripts
+    // Add a new asset for each entry.
+    for (const { bundleName, inject, paths } of (0, helpers_1.globalScriptsByBundleName)(buildOptions.scripts)) {
+        // Lazy scripts don't get a hash, otherwise they can't be loaded by name.
+        const hash = inject ? hashFormat.script : '';
+        extraPlugins.push(new plugins_1.ScriptsWebpackPlugin({
+            name: bundleName,
+            sourceMap: scriptsSourceMap,
+            scripts: paths,
+            filename: `${path.basename(bundleName)}${hash}.js`,
+            basePath: root,
+        }));
+    }
+    // process asset entries
+    if (buildOptions.assets.length) {
+        extraPlugins.push(new copy_webpack_plugin_1.default({
+            patterns: (0, helpers_1.assetPatterns)(root, buildOptions.assets),
+        }));
+    }
+    if (buildOptions.extractLicenses) {
+        const LicenseWebpackPlugin = require('license-webpack-plugin').LicenseWebpackPlugin;
+        extraPlugins.push(new LicenseWebpackPlugin({
+            stats: {
+                warnings: false,
+                errors: false,
+            },
+            perChunkOutput: false,
+            outputFilename: '3rdpartylicenses.txt',
+            skipChildCompilers: true,
+        }));
+    }
+    if (scriptsSourceMap || stylesSourceMap) {
+        const include = [];
+        if (scriptsSourceMap) {
+            include.push(/js$/);
+        }
+        if (stylesSourceMap) {
+            include.push(/css$/);
+        }
+        extraPlugins.push(new devtools_ignore_plugin_1.DevToolsIgnorePlugin());
+        extraPlugins.push(new webpack_2.SourceMapDevToolPlugin({
+            filename: '[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,
+        }));
+    }
+    if (verbose) {
+        extraPlugins.push(new watch_files_logs_plugin_1.WatchFilesLogsPlugin());
+    }
+    if (buildOptions.statsJson) {
+        extraPlugins.push(new plugins_1.JsonStatsPlugin(path.resolve(root, buildOptions.outputPath, 'stats.json')));
+    }
+    if (subresourceIntegrity) {
+        extraPlugins.push(new webpack_subresource_integrity_1.SubresourceIntegrityPlugin({
+            hashFuncNames: ['sha384'],
+        }));
+    }
+    if (scriptsSourceMap || stylesSourceMap) {
+        extraRules.push({
+            test: /\.[cm]?jsx?$/,
+            enforce: 'pre',
+            loader: require.resolve('source-map-loader'),
+            options: {
+                filterSourceMappingUrl: (_mapUri, resourcePath) => {
+                    if (vendorSourceMap) {
+                        // Consume all sourcemaps when vendor option is enabled.
+                        return true;
+                    }
+                    // Don't consume sourcemaps in node_modules when vendor is disabled.
+                    // But, do consume local libraries sourcemaps.
+                    return !resourcePath.includes('node_modules');
+                },
+            },
+        });
+    }
+    if (main || polyfills) {
+        extraRules.push({
+            test: tsConfig.options.allowJs ? /\.[cm]?[tj]sx?$/ : /\.[cm]?tsx?$/,
+            loader: webpack_1.AngularWebpackLoaderPath,
+            // The below are known paths that are not part of the TypeScript compilation even when allowJs is enabled.
+            exclude: [
+                /[\\/]node_modules[/\\](?:css-loader|mini-css-extract-plugin|webpack-dev-server|webpack)[/\\]/,
+            ],
+        });
+        extraPlugins.push((0, typescript_1.createIvyPlugin)(wco, aot, tsConfigPath));
+    }
+    if (webWorkerTsConfig) {
+        extraPlugins.push((0, typescript_1.createIvyPlugin)(wco, false, path.resolve(wco.root, webWorkerTsConfig)));
+    }
+    const extraMinimizers = [];
+    if (scriptsOptimization) {
+        extraMinimizers.push(new plugins_1.JavaScriptOptimizerPlugin({
+            define: buildOptions.aot ? GLOBAL_DEFS_FOR_TERSER_WITH_AOT : GLOBAL_DEFS_FOR_TERSER,
+            sourcemap: scriptsSourceMap,
+            supportedBrowsers: buildOptions.supportedBrowsers,
+            keepIdentifierNames: !environment_options_1.allowMangle || isPlatformServer,
+            keepNames: isPlatformServer,
+            removeLicenses: buildOptions.extractLicenses,
+            advanced: buildOptions.buildOptimizer,
+        }));
+    }
+    if (platform === 'browser' && (scriptsOptimization || stylesOptimization.minify)) {
+        extraMinimizers.push(new transfer_size_plugin_1.TransferSizePlugin());
+    }
+    let crossOriginLoading = false;
+    if (subresourceIntegrity && crossOrigin === 'none') {
+        crossOriginLoading = 'anonymous';
+    }
+    else if (crossOrigin !== 'none') {
+        crossOriginLoading = crossOrigin;
+    }
+    return {
+        mode: scriptsOptimization || stylesOptimization.minify ? 'production' : 'development',
+        devtool: false,
+        target: [isPlatformServer ? 'node' : 'web', 'es2015'],
+        profile: buildOptions.statsJson,
+        resolve: {
+            roots: [projectRoot],
+            extensions: ['.ts', '.tsx', '.mjs', '.js'],
+            symlinks: !buildOptions.preserveSymlinks,
+            modules: [tsConfig.options.baseUrl || projectRoot, 'node_modules'],
+            mainFields: isPlatformServer
+                ? ['es2020', 'es2015', 'module', 'main']
+                : ['es2020', 'es2015', 'browser', 'module', 'main'],
+            conditionNames: ['es2020', 'es2015', '...'],
+        },
+        resolveLoader: {
+            symlinks: !buildOptions.preserveSymlinks,
+        },
+        context: root,
+        entry: entryPoints,
+        externals: externalDependencies,
+        output: {
+            uniqueName: projectName,
+            hashFunction: 'xxhash64',
+            clean: buildOptions.deleteOutputPath ?? true,
+            path: path.resolve(root, buildOptions.outputPath),
+            publicPath: buildOptions.deployUrl ?? '',
+            filename: `[name]${hashFormat.chunk}.js`,
+            chunkFilename: `[name]${hashFormat.chunk}.js`,
+            libraryTarget: isPlatformServer ? 'commonjs' : undefined,
+            crossOriginLoading,
+            trustedTypes: 'angular#bundler',
+            scriptType: 'module',
+        },
+        watch: buildOptions.watch,
+        watchOptions: {
+            poll,
+            // The below is needed as when preserveSymlinks is enabled we disable `resolve.symlinks`.
+            followSymlinks: buildOptions.preserveSymlinks,
+            ignored: poll === undefined ? undefined : '**/node_modules/**',
+        },
+        snapshot: {
+            module: {
+                // Use hash of content instead of timestamp because the timestamp of the symlink will be used
+                // instead of the referenced files which causes changes in symlinks not to be picked up.
+                hash: buildOptions.preserveSymlinks,
+            },
+        },
+        performance: {
+            hints: false,
+        },
+        ignoreWarnings: [
+            // https://github.com/webpack-contrib/source-map-loader/blob/b2de4249c7431dd8432da607e08f0f65e9d64219/src/index.js#L83
+            /Failed to parse source map from/,
+            // https://github.com/webpack-contrib/postcss-loader/blob/bd261875fdf9c596af4ffb3a1a73fe3c549befda/src/index.js#L153-L158
+            /Add postcss as project dependency/,
+            // esbuild will issue a warning, while still hoists the @charset at the very top.
+            // This is caused by a bug in css-loader https://github.com/webpack-contrib/css-loader/issues/1212
+            /"@charset" must be the first rule in the file/,
+        ],
+        module: {
+            // Show an error for missing exports instead of a warning.
+            strictExportPresence: true,
+            parser: {
+                javascript: {
+                    requireContext: false,
+                    // Disable auto URL asset module creation. This doesn't effect `new Worker(new URL(...))`
+                    // https://webpack.js.org/guides/asset-modules/#url-assets
+                    url: false,
+                    worker: !!webWorkerTsConfig,
+                },
+            },
+            rules: [
+                {
+                    test: /\.?(svg|html)$/,
+                    // Only process HTML and SVG which are known Angular component resources.
+                    resourceQuery: /\?ngResource/,
+                    type: 'asset/source',
+                },
+                {
+                    // Mark files inside `rxjs/add` as containing side effects.
+                    // If this is fixed upstream and the fixed version becomes the minimum
+                    // supported version, this can be removed.
+                    test: /[/\\]rxjs[/\\]add[/\\].+\.js$/,
+                    sideEffects: true,
+                },
+                {
+                    test: /\.[cm]?[tj]sx?$/,
+                    // The below is needed due to a bug in `@babel/runtime`. See: https://github.com/babel/babel/issues/12824
+                    resolve: { fullySpecified: false },
+                    exclude: [
+                        /[\\/]node_modules[/\\](?:core-js|@babel|tslib|web-animations-js|web-streams-polyfill|whatwg-url)[/\\]/,
+                    ],
+                    use: [
+                        {
+                            loader: require.resolve('../../babel/webpack-loader'),
+                            options: {
+                                cacheDirectory: (cache.enabled && path.join(cache.path, 'babel-webpack')) || false,
+                                aot: buildOptions.aot,
+                                optimize: buildOptions.buildOptimizer,
+                                supportedBrowsers: buildOptions.supportedBrowsers,
+                                instrumentCode: codeCoverage
+                                    ? {
+                                        includedBasePath: sourceRoot ?? projectRoot,
+                                        excludedPaths: (0, helpers_1.getInstrumentationExcludedPaths)(root, codeCoverageExclude),
+                                    }
+                                    : undefined,
+                            },
+                        },
+                    ],
+                },
+                ...extraRules,
+            ],
+        },
+        experiments: {
+            backCompat: false,
+            syncWebAssembly: true,
+            asyncWebAssembly: true,
+            topLevelAwait: false,
+        },
+        infrastructureLogging: {
+            debug: verbose,
+            level: verbose ? 'verbose' : 'error',
+        },
+        stats: (0, helpers_1.getStatsOptions)(verbose),
+        cache: (0, helpers_1.getCacheSettings)(wco, NG_VERSION.full),
+        optimization: {
+            minimizer: extraMinimizers,
+            moduleIds: 'deterministic',
+            chunkIds: buildOptions.namedChunks ? 'named' : 'deterministic',
+            emitOnErrors: false,
+            runtimeChunk: isPlatformServer ? false : '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: VENDORS_TEST,
+                    },
+                },
+            },
+        },
+        plugins: [
+            new named_chunks_plugin_1.NamedChunksPlugin(),
+            new occurrences_plugin_1.OccurrencesPlugin({
+                aot,
+                scriptsOptimization,
+            }),
+            new plugins_1.DedupeModuleResolvePlugin({ verbose }),
+            ...extraPlugins,
+        ],
+        node: false,
+    };
+}
+exports.getCommonConfig = getCommonConfig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../../../../../../packages/angular_devkit/build_angular/src/tools/webpack/configs/common.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { AngularWebpackLoaderPath } from '@ngtools/webpack';\nimport CopyWebpackPlugin from 'copy-webpack-plugin';\nimport * as path from 'path';\nimport {\n  Compiler,\n  Configuration,\n  ContextReplacementPlugin,\n  RuleSetRule,\n  SourceMapDevToolPlugin,\n} from 'webpack';\nimport { SubresourceIntegrityPlugin } from 'webpack-subresource-integrity';\nimport { WebpackConfigOptions } from '../../../utils/build-options';\nimport { allowMangle } from '../../../utils/environment-options';\nimport { loadEsmModule } from '../../../utils/load-esm';\nimport { AngularBabelLoaderOptions } from '../../babel/webpack-loader';\nimport {\n  CommonJsUsageWarnPlugin,\n  DedupeModuleResolvePlugin,\n  JavaScriptOptimizerPlugin,\n  JsonStatsPlugin,\n  ScriptsWebpackPlugin,\n} from '../plugins';\nimport { DevToolsIgnorePlugin } from '../plugins/devtools-ignore-plugin';\nimport { NamedChunksPlugin } from '../plugins/named-chunks-plugin';\nimport { OccurrencesPlugin } from '../plugins/occurrences-plugin';\nimport { ProgressPlugin } from '../plugins/progress-plugin';\nimport { TransferSizePlugin } from '../plugins/transfer-size-plugin';\nimport { createIvyPlugin } from '../plugins/typescript';\nimport { WatchFilesLogsPlugin } from '../plugins/watch-files-logs-plugin';\nimport {\n  assetPatterns,\n  getCacheSettings,\n  getInstrumentationExcludedPaths,\n  getOutputHashFormat,\n  getStatsOptions,\n  globalScriptsByBundleName,\n  isPlatformServerInstalled,\n} from '../utils/helpers';\n\nconst VENDORS_TEST = /[\\\\/]node_modules[\\\\/]/;\n\n// eslint-disable-next-line max-lines-per-function\nexport async function getCommonConfig(wco: WebpackConfigOptions): Promise<Configuration> {\n  const { root, projectRoot, buildOptions, tsConfig, projectName, sourceRoot, tsConfigPath } = wco;\n  const {\n    cache,\n    codeCoverage,\n    crossOrigin = 'none',\n    platform = 'browser',\n    aot = true,\n    codeCoverageExclude = [],\n    main,\n    sourceMap: {\n      styles: stylesSourceMap,\n      scripts: scriptsSourceMap,\n      vendor: vendorSourceMap,\n      hidden: hiddenSourceMap,\n    },\n    optimization: { styles: stylesOptimization, scripts: scriptsOptimization },\n    commonChunk,\n    vendorChunk,\n    subresourceIntegrity,\n    verbose,\n    poll,\n    webWorkerTsConfig,\n    externalDependencies = [],\n    allowedCommonJsDependencies,\n  } = buildOptions;\n\n  const isPlatformServer = buildOptions.platform === 'server';\n  const extraPlugins: { apply(compiler: Compiler): void }[] = [];\n  const extraRules: RuleSetRule[] = [];\n  const entryPoints: Configuration['entry'] = {};\n\n  // Load ESM `@angular/compiler-cli` using the TypeScript dynamic import workaround.\n  // Once TypeScript provides support for keeping the dynamic import this workaround can be\n  // changed to a direct dynamic import.\n  const {\n    GLOBAL_DEFS_FOR_TERSER,\n    GLOBAL_DEFS_FOR_TERSER_WITH_AOT,\n    VERSION: NG_VERSION,\n  } = await loadEsmModule<typeof import('@angular/compiler-cli')>('@angular/compiler-cli');\n\n  // determine hashing format\n  const hashFormat = getOutputHashFormat(buildOptions.outputHashing);\n\n  if (buildOptions.progress) {\n    extraPlugins.push(new ProgressPlugin(platform));\n  }\n\n  const localizePackageInitEntryPoint = '@angular/localize/init';\n  const hasLocalizeType = tsConfig.options.types?.some(\n    (t) => t === '@angular/localize' || t === localizePackageInitEntryPoint,\n  );\n\n  if (hasLocalizeType) {\n    entryPoints['main'] = [localizePackageInitEntryPoint];\n  }\n\n  if (buildOptions.main) {\n    const mainPath = path.resolve(root, buildOptions.main);\n    if (Array.isArray(entryPoints['main'])) {\n      entryPoints['main'].push(mainPath);\n    } else {\n      entryPoints['main'] = [mainPath];\n    }\n  }\n\n  if (isPlatformServer) {\n    // Fixes Critical dependency: the request of a dependency is an expression\n    extraPlugins.push(new ContextReplacementPlugin(/@?hapi|express[\\\\/]/));\n\n    if (isPlatformServerInstalled(wco.root) && Array.isArray(entryPoints['main'])) {\n      // This import must come before any imports (direct or transitive) that rely on DOM built-ins being\n      // available, such as `@angular/elements`.\n      entryPoints['main'].unshift('@angular/platform-server/init');\n    }\n  }\n\n  const polyfills = [...buildOptions.polyfills];\n  if (!aot) {\n    polyfills.push('@angular/compiler');\n  }\n\n  if (polyfills.length) {\n    // `zone.js/testing` is a **special** polyfill because when not imported in the main it fails with the below errors:\n    // `Error: Expected to be running in 'ProxyZone', but it was not found.`\n    // This was also the reason why previously it was imported in `test.ts` as the first module.\n    // From Jia li:\n    // This is because the jasmine functions such as beforeEach/it will not be patched by zone.js since\n    // jasmine will not be loaded yet, so the ProxyZone will not be there. We have to load zone-testing.js after\n    // jasmine is ready.\n    // We could force loading 'zone.js/testing' prior to jasmine by changing the order of scripts in 'karma-context.html'.\n    // But this has it's own problems as zone.js needs to be loaded prior to jasmine due to patching of timing functions\n    // See: https://github.com/jasmine/jasmine/issues/1944\n    // Thus the correct order is zone.js -> jasmine -> zone.js/testing.\n    const zoneTestingEntryPoint = 'zone.js/testing';\n    const polyfillsExludingZoneTesting = polyfills.filter((p) => p !== zoneTestingEntryPoint);\n\n    if (Array.isArray(entryPoints['polyfills'])) {\n      entryPoints['polyfills'].push(...polyfillsExludingZoneTesting);\n    } else {\n      entryPoints['polyfills'] = polyfillsExludingZoneTesting;\n    }\n\n    if (polyfillsExludingZoneTesting.length !== polyfills.length) {\n      if (Array.isArray(entryPoints['main'])) {\n        entryPoints['main'].unshift(zoneTestingEntryPoint);\n      } else {\n        entryPoints['main'] = [zoneTestingEntryPoint];\n      }\n    }\n  }\n\n  if (allowedCommonJsDependencies) {\n    // When this is not defined it means the builder doesn't support showing common js usages.\n    // When it does it will be an array.\n    extraPlugins.push(\n      new CommonJsUsageWarnPlugin({\n        allowedDependencies: allowedCommonJsDependencies,\n      }),\n    );\n  }\n\n  // process global scripts\n  // Add a new asset for each entry.\n  for (const { bundleName, inject, paths } of globalScriptsByBundleName(buildOptions.scripts)) {\n    // Lazy scripts don't get a hash, otherwise they can't be loaded by name.\n    const hash = inject ? hashFormat.script : '';\n\n    extraPlugins.push(\n      new ScriptsWebpackPlugin({\n        name: bundleName,\n        sourceMap: scriptsSourceMap,\n        scripts: paths,\n        filename: `${path.basename(bundleName)}${hash}.js`,\n        basePath: root,\n      }),\n    );\n  }\n\n  // process asset entries\n  if (buildOptions.assets.length) {\n    extraPlugins.push(\n      new CopyWebpackPlugin({\n        patterns: assetPatterns(root, buildOptions.assets),\n      }),\n    );\n  }\n\n  if (buildOptions.extractLicenses) {\n    const LicenseWebpackPlugin = require('license-webpack-plugin').LicenseWebpackPlugin;\n    extraPlugins.push(\n      new LicenseWebpackPlugin({\n        stats: {\n          warnings: false,\n          errors: false,\n        },\n        perChunkOutput: false,\n        outputFilename: '3rdpartylicenses.txt',\n        skipChildCompilers: true,\n      }),\n    );\n  }\n\n  if (scriptsSourceMap || stylesSourceMap) {\n    const include = [];\n    if (scriptsSourceMap) {\n      include.push(/js$/);\n    }\n\n    if (stylesSourceMap) {\n      include.push(/css$/);\n    }\n\n    extraPlugins.push(new DevToolsIgnorePlugin());\n\n    extraPlugins.push(\n      new SourceMapDevToolPlugin({\n        filename: '[file].map',\n        include,\n        // We want to set sourceRoot to  `webpack:///` for non\n        // inline sourcemaps as otherwise paths to sourcemaps will be broken in browser\n        // `webpack:///` is needed for Visual Studio breakpoints to work properly as currently\n        // there is no way to set the 'webRoot'\n        sourceRoot: 'webpack:///',\n        moduleFilenameTemplate: '[resource-path]',\n        append: hiddenSourceMap ? false : undefined,\n      }),\n    );\n  }\n\n  if (verbose) {\n    extraPlugins.push(new WatchFilesLogsPlugin());\n  }\n\n  if (buildOptions.statsJson) {\n    extraPlugins.push(\n      new JsonStatsPlugin(path.resolve(root, buildOptions.outputPath, 'stats.json')),\n    );\n  }\n\n  if (subresourceIntegrity) {\n    extraPlugins.push(\n      new SubresourceIntegrityPlugin({\n        hashFuncNames: ['sha384'],\n      }),\n    );\n  }\n\n  if (scriptsSourceMap || stylesSourceMap) {\n    extraRules.push({\n      test: /\\.[cm]?jsx?$/,\n      enforce: 'pre',\n      loader: require.resolve('source-map-loader'),\n      options: {\n        filterSourceMappingUrl: (_mapUri: string, resourcePath: string) => {\n          if (vendorSourceMap) {\n            // Consume all sourcemaps when vendor option is enabled.\n            return true;\n          }\n\n          // Don't consume sourcemaps in node_modules when vendor is disabled.\n          // But, do consume local libraries sourcemaps.\n          return !resourcePath.includes('node_modules');\n        },\n      },\n    });\n  }\n\n  if (main || polyfills) {\n    extraRules.push({\n      test: tsConfig.options.allowJs ? /\\.[cm]?[tj]sx?$/ : /\\.[cm]?tsx?$/,\n      loader: AngularWebpackLoaderPath,\n      // The below are known paths that are not part of the TypeScript compilation even when allowJs is enabled.\n      exclude: [\n        /[\\\\/]node_modules[/\\\\](?:css-loader|mini-css-extract-plugin|webpack-dev-server|webpack)[/\\\\]/,\n      ],\n    });\n    extraPlugins.push(createIvyPlugin(wco, aot, tsConfigPath));\n  }\n\n  if (webWorkerTsConfig) {\n    extraPlugins.push(createIvyPlugin(wco, false, path.resolve(wco.root, webWorkerTsConfig)));\n  }\n\n  const extraMinimizers = [];\n  if (scriptsOptimization) {\n    extraMinimizers.push(\n      new JavaScriptOptimizerPlugin({\n        define: buildOptions.aot ? GLOBAL_DEFS_FOR_TERSER_WITH_AOT : GLOBAL_DEFS_FOR_TERSER,\n        sourcemap: scriptsSourceMap,\n        supportedBrowsers: buildOptions.supportedBrowsers,\n        keepIdentifierNames: !allowMangle || isPlatformServer,\n        keepNames: isPlatformServer,\n        removeLicenses: buildOptions.extractLicenses,\n        advanced: buildOptions.buildOptimizer,\n      }),\n    );\n  }\n\n  if (platform === 'browser' && (scriptsOptimization || stylesOptimization.minify)) {\n    extraMinimizers.push(new TransferSizePlugin());\n  }\n\n  let crossOriginLoading: NonNullable<Configuration['output']>['crossOriginLoading'] = false;\n  if (subresourceIntegrity && crossOrigin === 'none') {\n    crossOriginLoading = 'anonymous';\n  } else if (crossOrigin !== 'none') {\n    crossOriginLoading = crossOrigin;\n  }\n\n  return {\n    mode: scriptsOptimization || stylesOptimization.minify ? 'production' : 'development',\n    devtool: false,\n    target: [isPlatformServer ? 'node' : 'web', 'es2015'],\n    profile: buildOptions.statsJson,\n    resolve: {\n      roots: [projectRoot],\n      extensions: ['.ts', '.tsx', '.mjs', '.js'],\n      symlinks: !buildOptions.preserveSymlinks,\n      modules: [tsConfig.options.baseUrl || projectRoot, 'node_modules'],\n      mainFields: isPlatformServer\n        ? ['es2020', 'es2015', 'module', 'main']\n        : ['es2020', 'es2015', 'browser', 'module', 'main'],\n      conditionNames: ['es2020', 'es2015', '...'],\n    },\n    resolveLoader: {\n      symlinks: !buildOptions.preserveSymlinks,\n    },\n    context: root,\n    entry: entryPoints,\n    externals: externalDependencies,\n    output: {\n      uniqueName: projectName,\n      hashFunction: 'xxhash64', // todo: remove in webpack 6. This is part of `futureDefaults`.\n      clean: buildOptions.deleteOutputPath ?? true,\n      path: path.resolve(root, buildOptions.outputPath),\n      publicPath: buildOptions.deployUrl ?? '',\n      filename: `[name]${hashFormat.chunk}.js`,\n      chunkFilename: `[name]${hashFormat.chunk}.js`,\n      libraryTarget: isPlatformServer ? 'commonjs' : undefined,\n      crossOriginLoading,\n      trustedTypes: 'angular#bundler',\n      scriptType: 'module',\n    },\n    watch: buildOptions.watch,\n    watchOptions: {\n      poll,\n      // The below is needed as when preserveSymlinks is enabled we disable `resolve.symlinks`.\n      followSymlinks: buildOptions.preserveSymlinks,\n      ignored: poll === undefined ? undefined : '**/node_modules/**',\n    },\n    snapshot: {\n      module: {\n        // Use hash of content instead of timestamp because the timestamp of the symlink will be used\n        // instead of the referenced files which causes changes in symlinks not to be picked up.\n        hash: buildOptions.preserveSymlinks,\n      },\n    },\n    performance: {\n      hints: false,\n    },\n    ignoreWarnings: [\n      // https://github.com/webpack-contrib/source-map-loader/blob/b2de4249c7431dd8432da607e08f0f65e9d64219/src/index.js#L83\n      /Failed to parse source map from/,\n      // https://github.com/webpack-contrib/postcss-loader/blob/bd261875fdf9c596af4ffb3a1a73fe3c549befda/src/index.js#L153-L158\n      /Add postcss as project dependency/,\n      // esbuild will issue a warning, while still hoists the @charset at the very top.\n      // This is caused by a bug in css-loader https://github.com/webpack-contrib/css-loader/issues/1212\n      /\"@charset\" must be the first rule in the file/,\n    ],\n    module: {\n      // Show an error for missing exports instead of a warning.\n      strictExportPresence: true,\n      parser: {\n        javascript: {\n          requireContext: false,\n          // Disable auto URL asset module creation. This doesn't effect `new Worker(new URL(...))`\n          // https://webpack.js.org/guides/asset-modules/#url-assets\n          url: false,\n          worker: !!webWorkerTsConfig,\n        },\n      },\n      rules: [\n        {\n          test: /\\.?(svg|html)$/,\n          // Only process HTML and SVG which are known Angular component resources.\n          resourceQuery: /\\?ngResource/,\n          type: 'asset/source',\n        },\n        {\n          // Mark files inside `rxjs/add` as containing side effects.\n          // If this is fixed upstream and the fixed version becomes the minimum\n          // supported version, this can be removed.\n          test: /[/\\\\]rxjs[/\\\\]add[/\\\\].+\\.js$/,\n          sideEffects: true,\n        },\n        {\n          test: /\\.[cm]?[tj]sx?$/,\n          // The below is needed due to a bug in `@babel/runtime`. See: https://github.com/babel/babel/issues/12824\n          resolve: { fullySpecified: false },\n          exclude: [\n            /[\\\\/]node_modules[/\\\\](?:core-js|@babel|tslib|web-animations-js|web-streams-polyfill|whatwg-url)[/\\\\]/,\n          ],\n          use: [\n            {\n              loader: require.resolve('../../babel/webpack-loader'),\n              options: {\n                cacheDirectory: (cache.enabled && path.join(cache.path, 'babel-webpack')) || false,\n                aot: buildOptions.aot,\n                optimize: buildOptions.buildOptimizer,\n                supportedBrowsers: buildOptions.supportedBrowsers,\n                instrumentCode: codeCoverage\n                  ? {\n                      includedBasePath: sourceRoot ?? projectRoot,\n                      excludedPaths: getInstrumentationExcludedPaths(root, codeCoverageExclude),\n                    }\n                  : undefined,\n              } as AngularBabelLoaderOptions,\n            },\n          ],\n        },\n        ...extraRules,\n      ],\n    },\n    experiments: {\n      backCompat: false,\n      syncWebAssembly: true,\n      asyncWebAssembly: true,\n      topLevelAwait: false,\n    },\n    infrastructureLogging: {\n      debug: verbose,\n      level: verbose ? 'verbose' : 'error',\n    },\n    stats: getStatsOptions(verbose),\n    cache: getCacheSettings(wco, NG_VERSION.full),\n    optimization: {\n      minimizer: extraMinimizers,\n      moduleIds: 'deterministic',\n      chunkIds: buildOptions.namedChunks ? 'named' : 'deterministic',\n      emitOnErrors: false,\n      runtimeChunk: isPlatformServer ? false : 'single',\n      splitChunks: {\n        maxAsyncRequests: Infinity,\n        cacheGroups: {\n          default: !!commonChunk && {\n            chunks: 'async',\n            minChunks: 2,\n            priority: 10,\n          },\n          common: !!commonChunk && {\n            name: 'common',\n            chunks: 'async',\n            minChunks: 2,\n            enforce: true,\n            priority: 5,\n          },\n          vendors: false,\n          defaultVendors: !!vendorChunk && {\n            name: 'vendor',\n            chunks: (chunk) => chunk.name === 'main',\n            enforce: true,\n            test: VENDORS_TEST,\n          },\n        },\n      },\n    },\n    plugins: [\n      new NamedChunksPlugin(),\n      new OccurrencesPlugin({\n        aot,\n        scriptsOptimization,\n      }),\n      new DedupeModuleResolvePlugin({ verbose }),\n      ...extraPlugins,\n    ],\n    node: false,\n  };\n}\n"]}

package/src/{webpack → tools/webpack}/configs/dev-server.d.ts

@@ -7,7 +7,7 @@
  */
 import { logging } from '@angular-devkit/core';
 import { Configuration } from 'webpack';
-import { WebpackConfigOptions, WebpackDevServerOptions } from '../../utils/build-options';
+import { WebpackConfigOptions, WebpackDevServerOptions } from '../../../utils/build-options';
 export declare function getDevServerConfig(wco: WebpackConfigOptions<WebpackDevServerOptions>): Promise<Configuration>;
 /**
  * Resolve and build a URL _path_ that will be the root of the server. This resolved base href and