@nx/webpack 17.1.0-beta.4 → 17.1.0-rc.0

package/index.d.ts

@@ -14,3 +14,5 @@ export * from './src/utils/get-css-module-local-ident';
 export * from './src/utils/with-nx';
 export * from './src/utils/with-web';
 export * from './src/utils/module-federation/public-api';
+export { NxWebpackPlugin } from './src/plugins/nx-webpack-plugin/nx-webpack-plugin';
+export { NxTsconfigPathsWebpackPlugin } from './src/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webpackProjectGenerator = exports.configurationGenerator = void 0;
+exports.NxTsconfigPathsWebpackPlugin = exports.NxWebpackPlugin = exports.webpackProjectGenerator = exports.configurationGenerator = void 0;
 const tslib_1 = require("tslib");
 const configuration_1 = require("./src/generators/configuration/configuration");
 Object.defineProperty(exports, "configurationGenerator", { enumerable: true, get: function () { return configuration_1.configurationGenerator; } });
@@ -17,3 +17,7 @@ tslib_1.__exportStar(require("./src/utils/get-css-module-local-ident"), exports)
 tslib_1.__exportStar(require("./src/utils/with-nx"), exports);
 tslib_1.__exportStar(require("./src/utils/with-web"), exports);
 tslib_1.__exportStar(require("./src/utils/module-federation/public-api"), exports);
+var nx_webpack_plugin_1 = require("./src/plugins/nx-webpack-plugin/nx-webpack-plugin");
+Object.defineProperty(exports, "NxWebpackPlugin", { enumerable: true, get: function () { return nx_webpack_plugin_1.NxWebpackPlugin; } });
+var nx_tsconfig_paths_webpack_plugin_1 = require("./src/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin");
+Object.defineProperty(exports, "NxTsconfigPathsWebpackPlugin", { enumerable: true, get: function () { return nx_tsconfig_paths_webpack_plugin_1.NxTsconfigPathsWebpackPlugin; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "17.1.0-beta.4",
+  "version": "17.1.0-rc.0",
   "private": false,
   "description": "The Nx Plugin for Webpack contains executors and generators that support building applications using Webpack.",
   "repository": {
@@ -62,9 +62,9 @@
     "webpack-dev-server": "^4.9.3",
     "webpack-node-externals": "^3.0.0",
     "webpack-subresource-integrity": "^5.1.0",
-    "@nx/devkit": "17.1.0-beta.4",
-    "@nx/js": "17.1.0-beta.4",
-    "@nrwl/webpack": "17.1.0-beta.4"
+    "@nx/devkit": "17.1.0-rc.0",
+    "@nx/js": "17.1.0-rc.0",
+    "@nrwl/webpack": "17.1.0-rc.0"
   },
   "publishConfig": {
     "access": "public"

package/src/executors/dev-server/dev-server.impl.js

@@ -34,11 +34,24 @@ async function* devServerExecutor(serveOptions, context) {
         if (typeof customWebpack.then === 'function') {
             customWebpack = await customWebpack;
         }
-        config = await customWebpack(config, {
-            options: buildOptions,
-            context,
-            configuration: serveOptions.buildTarget.split(':')[2],
-        });
+        if (typeof customWebpack === 'function') {
+            // Old behavior, call the webpack function that is specific to Nx
+            config = await customWebpack(config, {
+                options: buildOptions,
+                context,
+                configuration: serveOptions.buildTarget.split(':')[2],
+            });
+        }
+        else if (customWebpack) {
+            // New behavior, use the config object as is with devServer defaults
+            config = {
+                devServer: {
+                    ...customWebpack.devServer,
+                    ...config.devServer,
+                },
+                ...customWebpack,
+            };
+        }
     }
     return yield* (0, rxjs_for_await_1.eachValueFrom)((0, run_webpack_1.runWebpackDevServer)(config, webpack, WebpackDevServer).pipe((0, operators_1.tap)(({ stats }) => {
         console.info(stats.toString(config.stats));

package/src/executors/webpack/lib/normalize-options.d.ts

@@ -1,4 +1,3 @@
-import type { AssetGlobPattern, NormalizedWebpackExecutorOptions, WebpackExecutorOptions } from '../schema';
+import type { NormalizedWebpackExecutorOptions, WebpackExecutorOptions } from '../schema';
 export declare function normalizeOptions(options: WebpackExecutorOptions, root: string, projectRoot: string, sourceRoot: string): NormalizedWebpackExecutorOptions;
 export declare function normalizePluginPath(pluginPath: void | string, root: string): string;
-export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string): AssetGlobPattern[];

package/src/executors/webpack/lib/normalize-options.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAssets = exports.normalizePluginPath = exports.normalizeOptions = void 0;
+exports.normalizePluginPath = exports.normalizeOptions = void 0;
 const path_1 = require("path");
-const fs_1 = require("fs");
-const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../../../plugins/nx-webpack-plugin/lib/normalize-options");
 function normalizeOptions(options, root, projectRoot, sourceRoot) {
     return {
         ...options,
@@ -11,12 +10,8 @@ function normalizeOptions(options, root, projectRoot, sourceRoot) {
         projectRoot,
         sourceRoot,
         target: options.target ?? 'web',
-        main: (0, path_1.resolve)(root, options.main),
-        outputPath: (0, path_1.resolve)(root, options.outputPath),
         outputFileName: options.outputFileName ?? 'main.js',
-        tsConfig: (0, path_1.resolve)(root, options.tsConfig),
-        fileReplacements: normalizeFileReplacements(root, options.fileReplacements),
-        assets: normalizeAssets(options.assets, root, sourceRoot),
+        assets: (0, normalize_options_1.normalizeAssets)(options.assets, root, sourceRoot),
         webpackConfig: normalizePluginPath(options.webpackConfig, root),
         optimization: typeof options.optimization !== 'object'
             ? {
@@ -24,16 +19,9 @@ function normalizeOptions(options, root, projectRoot, sourceRoot) {
                 styles: options.optimization,
             }
             : options.optimization,
-        polyfills: options.polyfills ? (0, path_1.resolve)(root, options.polyfills) : undefined,
     };
 }
 exports.normalizeOptions = normalizeOptions;
-function normalizeFileReplacements(root, fileReplacements) {
-    return fileReplacements.map((fileReplacement) => ({
-        replace: (0, path_1.resolve)(root, fileReplacement.replace),
-        with: (0, path_1.resolve)(root, fileReplacement.with),
-    }));
-}
 function normalizePluginPath(pluginPath, root) {
     if (!pluginPath) {
         return '';
@@ -46,40 +34,3 @@ function normalizePluginPath(pluginPath, root) {
     }
 }
 exports.normalizePluginPath = normalizePluginPath;
-function normalizeAssets(assets, root, sourceRoot) {
-    return assets.map((asset) => {
-        if (typeof asset === 'string') {
-            const assetPath = (0, devkit_1.normalizePath)(asset);
-            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
-            const resolvedSourceRoot = (0, path_1.resolve)(root, sourceRoot);
-            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
-                throw new Error(`The ${resolvedAssetPath} asset path must start with the project source root: ${sourceRoot}`);
-            }
-            const isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
-            const input = isDirectory
-                ? resolvedAssetPath
-                : (0, path_1.dirname)(resolvedAssetPath);
-            const output = (0, path_1.relative)(resolvedSourceRoot, (0, path_1.resolve)(root, input));
-            const glob = isDirectory ? '**/*' : (0, path_1.basename)(resolvedAssetPath);
-            return {
-                input,
-                output,
-                glob,
-            };
-        }
-        else {
-            if (asset.output.startsWith('..')) {
-                throw new Error('An asset cannot be written to a location outside of the output path.');
-            }
-            const assetPath = (0, devkit_1.normalizePath)(asset.input);
-            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
-            return {
-                ...asset,
-                input: resolvedAssetPath,
-                // Now we remove starting slash to make Webpack place it from the output root.
-                output: asset.output.replace(/^\//, ''),
-            };
-        }
-    });
-}
-exports.normalizeAssets = normalizeAssets;

package/src/executors/webpack/schema.d.ts

@@ -86,8 +86,8 @@ export interface WebpackExecutorOptions {
 export interface NormalizedWebpackExecutorOptions
   extends WebpackExecutorOptions {
   outputFileName: string;
-  assets?: AssetGlobPattern[];
-  root?: string;
-  projectRoot?: string;
-  sourceRoot?: string;
+  assets: AssetGlobPattern[];
+  root: string;
+  projectRoot: string;
+  sourceRoot: string;
 }

package/src/executors/webpack/webpack.impl.js

@@ -17,7 +17,7 @@ async function getWebpackConfigs(options, projectRoot, context) {
         throw new Error(`Using "isolatedConfig" without a "webpackConfig" is not supported.`);
     }
     let customWebpack = null;
-    if (options.webpackConfig) {
+    if (options.webpackConfig && options.tsConfig) {
         customWebpack = (0, custom_webpack_1.resolveCustomWebpackConfig)(options.webpackConfig, options.tsConfig.startsWith(context.root)
             ? options.tsConfig
             : (0, path_1.join)(context.root, options.tsConfig));
@@ -28,19 +28,26 @@ async function getWebpackConfigs(options, projectRoot, context) {
     const config = options.isolatedConfig
         ? {}
         : (0, get_webpack_config_1.getWebpackConfig)(context, options);
-    if (customWebpack) {
+    if (typeof customWebpack === 'function') {
+        // Old behavior, call the Nx-specific webpack config function that user exports
         return await customWebpack(config, {
             options,
             context,
             configuration: context.configurationName, // backwards compat
         });
     }
+    else if (customWebpack) {
+        // New behavior, we want the webpack config to export object
+        return customWebpack;
+    }
     else {
-        // If the user has no webpackConfig specified then we always have to apply
+        // Fallback case, if we cannot find a webpack config path
         return config;
     }
 }
 async function* webpackExecutor(_options, context) {
+    // Pass to NxWebpackPlugin so we can get the CLI overrides.
+    process.env['NX_WEBPACK_EXECUTOR_RAW_OPTIONS'] = JSON.stringify(_options);
     const metadata = context.projectsConfigurations.projects[context.projectName];
     const sourceRoot = metadata.sourceRoot;
     const options = (0, normalize_options_1.normalizeOptions)(_options, context.root, metadata.root, sourceRoot);
@@ -71,7 +78,7 @@ async function* webpackExecutor(_options, context) {
         options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, context.root, metadata.root, dependencies);
     }
     // Delete output path before bundling
-    if (options.deleteOutputPath) {
+    if (options.deleteOutputPath && options.outputPath) {
         (0, fs_1.deleteOutputDir)(context.root, options.outputPath);
     }
     if (options.generatePackageJson && metadata.projectType !== 'application') {

package/src/plugins/generate-package-json-plugin.d.ts

@@ -1,12 +1,14 @@
 import { type Compiler, type WebpackPluginInstance } from 'webpack';
-import { ExecutorContext } from '@nx/devkit';
+import { type ProjectGraph } from '@nx/devkit';
 export declare class GeneratePackageJsonPlugin implements WebpackPluginInstance {
     private readonly options;
-    private readonly context;
-    private readonly projectGraph;
     constructor(options: {
         tsConfig: string;
         outputFileName: string;
-    }, context: ExecutorContext);
+        root: string;
+        projectName: string;
+        targetName: string;
+        projectGraph: ProjectGraph;
+    });
     apply(compiler: Compiler): void;
 }

package/src/plugins/generate-package-json-plugin.js

@@ -4,13 +4,10 @@ exports.GeneratePackageJsonPlugin = void 0;
 const webpack_1 = require("webpack");
 const js_1 = require("@nx/js");
 const devkit_1 = require("@nx/devkit");
-const js_2 = require("@nx/js");
 const pluginName = 'GeneratePackageJsonPlugin';
 class GeneratePackageJsonPlugin {
-    constructor(options, context) {
+    constructor(options) {
         this.options = options;
-        this.context = context;
-        this.projectGraph = context.projectGraph;
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
@@ -18,28 +15,28 @@ class GeneratePackageJsonPlugin {
                 name: pluginName,
                 stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
             }, () => {
-                const helperDependencies = (0, js_2.getHelperDependenciesFromProjectGraph)(this.context.root, this.context.projectName, this.projectGraph);
-                const importHelpers = !!(0, js_2.readTsConfig)(this.options.tsConfig).options
+                const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(this.options.root, this.options.projectName, this.options.projectGraph);
+                const importHelpers = !!(0, js_1.readTsConfig)(this.options.tsConfig).options
                     .importHelpers;
                 const shouldAddHelperDependency = importHelpers &&
-                    helperDependencies.every((dep) => dep.target !== js_2.HelperDependency.tsc);
+                    helperDependencies.every((dep) => dep.target !== js_1.HelperDependency.tsc);
                 if (shouldAddHelperDependency) {
                     helperDependencies.push({
                         type: 'static',
-                        source: this.context.projectName,
-                        target: js_2.HelperDependency.tsc,
+                        source: this.options.projectName,
+                        target: js_1.HelperDependency.tsc,
                     });
                 }
-                const packageJson = (0, js_1.createPackageJson)(this.context.projectName, this.projectGraph, {
-                    target: this.context.targetName,
-                    root: this.context.root,
+                const packageJson = (0, js_1.createPackageJson)(this.options.projectName, this.options.projectGraph, {
+                    target: this.options.targetName,
+                    root: this.options.root,
                     isProduction: true,
                     helperDependencies: helperDependencies.map((dep) => dep.target),
                 });
                 packageJson.main = packageJson.main ?? this.options.outputFileName;
                 compilation.emitAsset('package.json', new webpack_1.sources.RawSource((0, devkit_1.serializeJson)(packageJson)));
-                const packageManager = (0, devkit_1.detectPackageManager)(this.context.root);
-                compilation.emitAsset((0, js_2.getLockFileName)(packageManager), new webpack_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.projectGraph, packageManager)));
+                const packageManager = (0, devkit_1.detectPackageManager)(this.options.root);
+                compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new webpack_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.options.projectGraph, packageManager)));
             });
         });
     }

package/src/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Compiler } from 'webpack';
+export declare class NxTsconfigPathsWebpackPlugin {
+    private options;
+    constructor(options: {
+        tsConfig: string;
+    });
+    apply(compiler: Compiler): void;
+}

package/src/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxTsconfigPathsWebpackPlugin = void 0;
+const path = require("path");
+const tsconfig_paths_webpack_plugin_1 = require("tsconfig-paths-webpack-plugin");
+const devkit_1 = require("@nx/devkit");
+class NxTsconfigPathsWebpackPlugin {
+    constructor(options) {
+        this.options = options;
+        if (!this.options.tsConfig)
+            throw new Error(`Missing "tsConfig" option. Set this option in your Nx webpack plugin.`);
+    }
+    apply(compiler) {
+        const extensions = new Set([
+            ...['.ts', '.tsx', '.mjs', '.js', '.jsx'],
+            ...(compiler.options?.resolve?.extensions ?? []),
+        ]);
+        compiler.options.resolve = {
+            ...compiler.options.resolve,
+            plugins: compiler.options.resolve?.plugins ?? [],
+        };
+        compiler.options.resolve.plugins.push(new tsconfig_paths_webpack_plugin_1.TsconfigPathsPlugin({
+            configFile: !path.isAbsolute(this.options.tsConfig)
+                ? path.join(devkit_1.workspaceRoot, this.options.tsConfig)
+                : this.options.tsConfig,
+            extensions: Array.from(extensions),
+            mainFields: ['module', 'main'],
+        }));
+    }
+}
+exports.NxTsconfigPathsWebpackPlugin = NxTsconfigPathsWebpackPlugin;

package/src/plugins/nx-webpack-plugin/lib/apply-base-config.d.ts

@@ -0,0 +1,3 @@
+import { Configuration, WebpackOptionsNormalized } from 'webpack';
+import { NormalizedNxWebpackPluginOptions } from '../nx-webpack-plugin-options';
+export declare function applyBaseConfig(options: NormalizedNxWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>): void;

package/src/plugins/nx-webpack-plugin/lib/apply-base-config.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBaseConfig = void 0;
+const path = require("path");
+const license_webpack_plugin_1 = require("license-webpack-plugin");
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+const webpack_1 = require("webpack");
+const stats_json_plugin_1 = require("../../stats-json-plugin");
+const generate_package_json_plugin_1 = require("../../generate-package-json-plugin");
+const hash_format_1 = require("../../../utils/hash-format");
+const nx_tsconfig_paths_webpack_plugin_1 = require("../../nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin");
+const get_terser_ecma_version_1 = require("./get-terser-ecma-version");
+const compiler_loaders_1 = require("./compiler-loaders");
+const TerserPlugin = require("terser-webpack-plugin");
+const nodeExternals = require("webpack-node-externals");
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+const IGNORED_WEBPACK_WARNINGS = [
+    /The comment file/i,
+    /could not find any license/i,
+];
+const extensions = ['.ts', '.tsx', '.mjs', '.js', '.jsx'];
+const mainFields = ['module', 'main'];
+function applyBaseConfig(options, config = {}) {
+    const plugins = [
+        new nx_tsconfig_paths_webpack_plugin_1.NxTsconfigPathsWebpackPlugin(options),
+    ];
+    const executorContext = {
+        projectName: options.projectName,
+        targetName: options.targetName,
+        projectGraph: options.projectGraph,
+        configurationName: options.configurationName,
+        root: options.root,
+    };
+    if (!options?.skipTypeChecking) {
+        plugins.push(new ForkTsCheckerWebpackPlugin({
+            typescript: {
+                configFile: path.isAbsolute(options.tsConfig)
+                    ? options.tsConfig
+                    : path.join(options.root, options.tsConfig),
+                memoryLimit: options.memoryLimit || 2018,
+            },
+        }));
+    }
+    const entries = [];
+    if (options.main) {
+        const mainEntry = options.outputFileName
+            ? path.parse(options.outputFileName).name
+            : 'main';
+        entries.push({
+            name: mainEntry,
+            import: [path.resolve(options.root, options.main)],
+        });
+    }
+    if (options.additionalEntryPoints) {
+        for (const { entryName, entryPath } of options.additionalEntryPoints) {
+            entries.push({
+                name: entryName,
+                import: [path.resolve(options.root, entryPath)],
+            });
+        }
+    }
+    if (options.polyfills) {
+        entries.push({
+            name: 'polyfills',
+            import: [path.resolve(options.root, options.polyfills)],
+        });
+    }
+    config.entry ??= {};
+    entries.forEach((entry) => {
+        config.entry[entry.name] = { import: entry.import };
+    });
+    if (options.progress) {
+        plugins.push(new webpack_1.ProgressPlugin({ profile: options.verbose }));
+    }
+    if (options.extractLicenses) {
+        plugins.push(new license_webpack_plugin_1.LicenseWebpackPlugin({
+            stats: {
+                warnings: false,
+                errors: false,
+            },
+            perChunkOutput: false,
+            outputFilename: `3rdpartylicenses.txt`,
+        }));
+    }
+    if (Array.isArray(options.assets) && options.assets.length > 0) {
+        plugins.push(new CopyWebpackPlugin({
+            patterns: options.assets.map((asset) => {
+                return {
+                    context: asset.input,
+                    // Now we remove starting slash to make Webpack place it from the output root.
+                    to: asset.output,
+                    from: asset.glob,
+                    globOptions: {
+                        ignore: [
+                            '.gitkeep',
+                            '**/.DS_Store',
+                            '**/Thumbs.db',
+                            ...(asset.ignore ?? []),
+                        ],
+                        dot: true,
+                    },
+                };
+            }),
+        }));
+    }
+    if (options.generatePackageJson && executorContext) {
+        plugins.push(new generate_package_json_plugin_1.GeneratePackageJsonPlugin(options));
+    }
+    if (options.statsJson) {
+        plugins.push(new stats_json_plugin_1.StatsJsonPlugin());
+    }
+    const externals = [];
+    if (options.target === 'node' && options.externalDependencies === 'all') {
+        const modulesDir = `${options.root}/node_modules`;
+        externals.push(nodeExternals({ modulesDir }));
+    }
+    else if (Array.isArray(options.externalDependencies)) {
+        externals.push(function (ctx, callback) {
+            if (options.externalDependencies.includes(ctx.request)) {
+                // not bundled
+                return callback(null, `commonjs ${ctx.request}`);
+            }
+            // bundled
+            callback();
+        });
+    }
+    const hashFormat = (0, hash_format_1.getOutputHashFormat)(options.outputHashing);
+    config.context = path.join(options.root, options.projectRoot);
+    config.target ??= options.target;
+    config.node = false;
+    config.mode =
+        // When the target is Node avoid any optimizations, such as replacing `process.env.NODE_ENV` with build time value.
+        config.target === 'node'
+            ? 'none'
+            : // Otherwise, make sure it matches `process.env.NODE_ENV`.
+                // When mode is development or production, webpack will automatically
+                // configure DefinePlugin to replace `process.env.NODE_ENV` with the
+                // build-time value. Thus, we need to make sure it's the same value to
+                // avoid conflicts.
+                //
+                // When the NODE_ENV is something else (e.g. test), then set it to none
+                // to prevent extra behavior from webpack.
+                process.env.NODE_ENV === 'development' ||
+                    process.env.NODE_ENV === 'production'
+                    ? process.env.NODE_ENV
+                    : 'none';
+    // When target is Node, the Webpack mode will be set to 'none' which disables in memory caching and causes a full rebuild on every change.
+    // So to mitigate this we enable in memory caching when target is Node and in watch mode.
+    config.cache =
+        options.target === 'node' && options.watch ? { type: 'memory' } : undefined;
+    config.devtool =
+        options.sourceMap === 'hidden'
+            ? 'hidden-source-map'
+            : options.sourceMap
+                ? 'source-map'
+                : false;
+    config.output = {
+        ...config.output,
+        path: config.output?.path ??
+            (options.outputPath
+                ? path.join(options.root, options.outputPath)
+                : undefined),
+        filename: config.output?.filename ?? options.outputHashing
+            ? `[name]${hashFormat.script}.js`
+            : '[name].js',
+        chunkFilename: config.output?.chunkFilename ?? options.outputHashing
+            ? `[name]${hashFormat.chunk}.js`
+            : '[name].js',
+        hashFunction: config.output?.hashFunction ?? 'xxhash64',
+        // Disabled for performance
+        pathinfo: config.output?.pathinfo ?? false,
+        // Use CJS for Node since it has the widest support.
+        scriptType: config.output?.scriptType ?? options.target === 'node'
+            ? undefined
+            : 'module',
+    };
+    config.watch = options.watch;
+    config.watchOptions = {
+        poll: options.poll,
+    };
+    config.profile = options.statsJson;
+    config.resolve = {
+        ...config.resolve,
+        extensions: [...extensions, ...(config?.resolve?.extensions ?? [])],
+        alias: options.fileReplacements.reduce((aliases, replacement) => ({
+            ...aliases,
+            [replacement.replace]: replacement.with,
+        }), {}),
+        mainFields,
+    };
+    config.externals = externals;
+    config.optimization = {
+        ...config.optimization,
+        sideEffects: true,
+        minimize: typeof options.optimization === 'object'
+            ? !!options.optimization.scripts
+            : !!options.optimization,
+        minimizer: [
+            options.compiler !== 'swc'
+                ? new TerserPlugin({
+                    parallel: true,
+                    terserOptions: {
+                        keep_classnames: true,
+                        ecma: (0, get_terser_ecma_version_1.getTerserEcmaVersion)(path.join(options.root, options.projectRoot)),
+                        safari10: true,
+                        format: {
+                            ascii_only: true,
+                            comments: false,
+                            webkit: true,
+                        },
+                    },
+                    extractComments: false,
+                })
+                : new TerserPlugin({
+                    minify: TerserPlugin.swcMinify,
+                    // `terserOptions` options will be passed to `swc`
+                    terserOptions: {
+                        module: true,
+                        mangle: false,
+                    },
+                }),
+        ],
+        runtimeChunk: false,
+        concatenateModules: true,
+    };
+    config.performance = {
+        ...config.performance,
+        hints: false,
+    };
+    config.experiments = { ...config.experiments, cacheUnaffected: true };
+    config.ignoreWarnings = [
+        (x) => IGNORED_WEBPACK_WARNINGS.some((r) => typeof x === 'string' ? r.test(x) : r.test(x.message)),
+    ];
+    config.module = {
+        ...config.module,
+        // Enabled for performance
+        unsafeCache: true,
+        rules: [
+            ...(config?.module?.rules ?? []),
+            options.sourceMap && {
+                test: /\.js$/,
+                enforce: 'pre',
+                loader: require.resolve('source-map-loader'),
+            },
+            {
+                // There's an issue resolving paths without fully specified extensions
+                // See: https://github.com/graphql/graphql-js/issues/2721
+                // TODO(jack): Add a flag to turn this option on like Next.js does via experimental flag.
+                // See: https://github.com/vercel/next.js/pull/29880
+                test: /\.m?jsx?$/,
+                resolve: {
+                    fullySpecified: false,
+                },
+            },
+            // There's an issue when using buildable libs and .js files (instead of .ts files),
+            // where the wrong type is used (commonjs vs esm) resulting in export-imports throwing errors.
+            // See: https://github.com/nrwl/nx/issues/10990
+            {
+                test: /\.js$/,
+                type: 'javascript/auto',
+            },
+            (0, compiler_loaders_1.createLoaderFromCompiler)(options),
+        ].filter((r) => !!r),
+    };
+    config.stats = {
+        hash: true,
+        timings: false,
+        cached: false,
+        cachedAssets: false,
+        modules: false,
+        warnings: true,
+        errors: true,
+        colors: !options.verbose && !options.statsJson,
+        chunks: !options.verbose,
+        assets: !!options.verbose,
+        chunkOrigins: !!options.verbose,
+        chunkModules: !!options.verbose,
+        children: !!options.verbose,
+        reasons: !!options.verbose,
+        version: !!options.verbose,
+        errorDetails: !!options.verbose,
+        moduleTrace: !!options.verbose,
+        usedExports: !!options.verbose,
+    };
+    config.plugins ??= [];
+    config.plugins.push(...plugins);
+}
+exports.applyBaseConfig = applyBaseConfig;

package/src/plugins/nx-webpack-plugin/lib/apply-web-config.d.ts

@@ -0,0 +1,3 @@
+import { Configuration, WebpackOptionsNormalized } from 'webpack';
+import { NormalizedNxWebpackPluginOptions } from '../nx-webpack-plugin-options';
+export declare function applyWebConfig(options: NormalizedNxWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>): void;