@nx/webpack 20.4.0-beta.1 → 20.4.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "20.4.0-beta.1",
+  "version": "20.4.0-beta.2",
   "private": false,
   "description": "The Nx Plugin for Webpack contains executors and generators that support building applications using Webpack.",
   "repository": {
@@ -65,8 +65,8 @@
     "webpack-dev-server": "^5.0.4",
     "webpack-node-externals": "^3.0.0",
     "webpack-subresource-integrity": "^5.1.0",
-    "@nx/devkit": "20.4.0-beta.1",
-    "@nx/js": "20.4.0-beta.1"
+    "@nx/devkit": "20.4.0-beta.2",
+    "@nx/js": "20.4.0-beta.2"
   },
   "publishConfig": {
     "access": "public"

package/src/plugins/plugin.js

@@ -77,7 +77,12 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
     const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const webpackConfig = (0, resolve_user_defined_webpack_config_1.resolveUserDefinedWebpackConfig)((0, path_1.join)(context.workspaceRoot, configFilePath), (0, js_1.getRootTsConfigPath)(), true);
     const webpackOptions = await (0, read_webpack_options_1.readWebpackOptions)(webpackConfig);
-    const outputPath = normalizeOutputPath(webpackOptions.output?.path, projectRoot);
+    const outputs = [];
+    for (const config of webpackOptions) {
+        if (config.output?.path) {
+            outputs.push(normalizeOutputPath(config.output.path, projectRoot));
+        }
+    }
     const targets = {};
     targets[options.buildTargetName] = {
         command: `webpack-cli build`,
@@ -99,7 +104,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
                     externalDependencies: ['webpack-cli'],
                 },
             ],
-        outputs: [outputPath],
+        outputs,
         metadata: {
             technologies: ['webpack'],
             description: 'Runs Webpack build',

package/src/utils/webpack/read-webpack-options.d.ts

@@ -3,8 +3,9 @@ import { Configuration } from 'webpack';
  * Reads the webpack options from a give webpack configuration. The configuration can be:
  * 1. A standard config object
  * 2. A standard function that returns a config object (webpack.js.org/configuration/configuration-types/#exporting-a-function)
- * 3. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
+ * 3. An array of standard config objects (multi-configuration mode)
+ * 4. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
  *
  * @param webpackConfig
  */
-export declare function readWebpackOptions(webpackConfig: unknown): Promise<Configuration>;
+export declare function readWebpackOptions(webpackConfig: unknown): Promise<Configuration[]>;

package/src/utils/webpack/read-webpack-options.js

@@ -8,42 +8,70 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
  * Reads the webpack options from a give webpack configuration. The configuration can be:
  * 1. A standard config object
  * 2. A standard function that returns a config object (webpack.js.org/configuration/configuration-types/#exporting-a-function)
- * 3. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
+ * 3. An array of standard config objects (multi-configuration mode)
+ * 4. A Nx-specific composable function that takes Nx context, webpack config, and returns the config object.
  *
  * @param webpackConfig
  */
 async function readWebpackOptions(webpackConfig) {
-    let config;
-    if ((0, config_1.isNxWebpackComposablePlugin)(webpackConfig)) {
-        config = await webpackConfig({}, {
-            // These values are only used during build-time, so passing stubs here just to read out
-            // the returned config object.
-            options: {
-                root: devkit_1.workspaceRoot,
-                projectRoot: '',
-                sourceRoot: '',
-                outputFileName: undefined,
-                outputPath: undefined,
-                assets: undefined,
-                useTsconfigPaths: undefined,
-            },
-            context: {
-                root: devkit_1.workspaceRoot,
-                cwd: undefined,
-                isVerbose: false,
-                projectsConfigurations: null,
-                projectGraph: null,
-                nxJsonConfiguration: (0, devkit_internals_1.readNxJsonFromDisk)(devkit_1.workspaceRoot),
-            },
-        });
-    }
-    else if (typeof webpackConfig === 'function') {
-        config = await webpackConfig({
-            production: true, // we want the production build options
-        }, {});
+    const configs = [];
+    const resolveConfig = async (config) => {
+        if ((0, config_1.isNxWebpackComposablePlugin)(config)) {
+            return await config({}, {
+                // These values are only used during build-time, so passing stubs here just to read out
+                options: {
+                    root: devkit_1.workspaceRoot,
+                    projectRoot: '',
+                    sourceRoot: '',
+                    outputFileName: undefined,
+                    outputPath: undefined,
+                    assets: undefined,
+                    useTsconfigPaths: undefined,
+                },
+                context: {
+                    root: devkit_1.workspaceRoot,
+                    cwd: undefined,
+                    isVerbose: false,
+                    projectsConfigurations: null,
+                    projectGraph: null,
+                    nxJsonConfiguration: (0, devkit_internals_1.readNxJsonFromDisk)(devkit_1.workspaceRoot),
+                },
+            });
+        }
+        else if (typeof config === 'function') {
+            const resolved = await config({
+                production: true, // we want the production build options
+            }, {});
+            // If the resolved configuration is an array, resolve each configuration
+            return Array.isArray(resolved)
+                ? await Promise.all(resolved.map(resolveConfig))
+                : resolved;
+        }
+        else if (Array.isArray(config)) {
+            // If the config passed is an array, resolve each configuration
+            const resolvedConfigs = await Promise.all(config.map(resolveConfig));
+            return resolvedConfigs.flat();
+        }
+        else {
+            // Return plain configuration
+            return config;
+        }
+    };
+    // Since configs can have nested arrays, we need to flatten them
+    const flattenConfigs = (resolvedConfigs) => {
+        return Array.isArray(resolvedConfigs)
+            ? resolvedConfigs.flatMap((cfg) => flattenConfigs(cfg))
+            : [resolvedConfigs];
+    };
+    if (Array.isArray(webpackConfig)) {
+        for (const config of webpackConfig) {
+            const resolved = await resolveConfig(config);
+            configs.push(...flattenConfigs(resolved));
+        }
     }
     else {
-        config = webpackConfig;
+        const resolved = await resolveConfig(webpackConfig);
+        configs.push(...flattenConfigs(resolved));
     }
-    return config;
+    return configs;
 }