@nx/webpack 24.0.0-beta.1 → 24.0.0-beta.3

package/dist/src/generators/convert-to-inferred/utils/serve-post-target-transformer.js

@@ -16,7 +16,7 @@ function servePostTargetTransformerFactory(migrationContext) {
             projectName: projectDetails.projectName,
             projectRoot: projectDetails.root,
         };
-        const { devServerOptions, webpackConfigPath } = await processOptions(tree, target, context);
+        const { devServerOptions, webpackConfigPath } = await processOptions(target, context);
         updateWebpackConfig(tree, webpackConfigPath, devServerOptions, context);
         if (target.outputs) {
             (0, internal_1.processTargetOutputs)(target, [], inferredTarget, {
@@ -27,20 +27,14 @@ function servePostTargetTransformerFactory(migrationContext) {
         return target;
     };
 }
-async function processOptions(tree, target, context) {
-    const executorContext = {
-        cwd: process.cwd(),
-        nxJsonConfiguration: (0, devkit_1.readJson)(tree, 'nx.json'),
-        projectGraph: context.projectGraph,
-        projectName: context.projectName,
-        projectsConfigurations: Object.entries(context.projectGraph.nodes).reduce((acc, [projectName, project]) => {
-            acc.projects[projectName] = project.data;
-            return acc;
-        }, { version: 1, projects: {} }),
-        root: context.workspaceRoot,
+async function processOptions(target, context) {
+    const buildTarget = (0, devkit_1.parseTargetString)(target.options.buildTarget, context.projectGraph);
+    const buildConfiguration = context.projectGraph.nodes[buildTarget.project].data.targets[buildTarget.target];
+    // The build executor is removed in v24; do not resolve its schema.
+    const buildOptions = {
+        ...buildConfiguration.options,
+        ...buildConfiguration.configurations?.[buildTarget.configuration ?? buildConfiguration.defaultConfiguration],
     };
-    const buildTarget = (0, devkit_1.parseTargetString)(target.options.buildTarget, executorContext);
-    const buildOptions = (0, devkit_1.readTargetOptions)(buildTarget, executorContext);
     // it must exist, we validated it in the project filter
     const webpackConfigPath = buildOptions.webpackConfig;
     const defaultOptions = extractDevServerOptions(target.options, context);

package/dist/src/generators/init/init.js

@@ -7,71 +7,62 @@ const devkit_1 = require("@nx/devkit");
 const plugin_1 = require("../../plugins/plugin");
 const versions_1 = require("../../utils/versions");
 function webpackInitGenerator(tree, schema) {
-    return webpackInitGeneratorInternal(tree, { addPlugin: false, ...schema });
+    return webpackInitGeneratorInternal(tree, schema);
 }
 async function webpackInitGeneratorInternal(tree, schema) {
     (0, versions_1.assertSupportedWebpackVersion)(tree);
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    schema.addPlugin ??= addPluginDefault;
-    if (schema.addPlugin) {
-        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/webpack/plugin', plugin_1.createNodesV2, {
-            buildTargetName: [
-                'build',
-                'webpack:build',
-                'build:webpack',
-                'webpack-build',
-                'build-webpack',
-            ],
-            serveTargetName: [
-                'serve',
-                'webpack:serve',
-                'serve:webpack',
-                'webpack-serve',
-                'serve-webpack',
-            ],
-            previewTargetName: [
-                'preview',
-                'webpack:preview',
-                'preview:webpack',
-                'webpack-preview',
-                'preview-webpack',
-            ],
-            buildDepsTargetName: [
-                'build-deps',
-                'webpack:build-deps',
-                'webpack-build-deps',
-            ],
-            watchDepsTargetName: [
-                'watch-deps',
-                'webpack:watch-deps',
-                'webpack-watch-deps',
-            ],
-            serveStaticTargetName: [
-                'serve-static',
-                'webpack:serve-static',
-                'serve-static:webpack',
-                'webpack-serve-static',
-                'serve-static-webpack',
-            ],
-        }, schema.updatePackageScripts);
-    }
+    await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/webpack/plugin', plugin_1.createNodesV2, {
+        buildTargetName: [
+            'build',
+            'webpack:build',
+            'build:webpack',
+            'webpack-build',
+            'build-webpack',
+        ],
+        serveTargetName: [
+            'serve',
+            'webpack:serve',
+            'serve:webpack',
+            'webpack-serve',
+            'serve-webpack',
+        ],
+        previewTargetName: [
+            'preview',
+            'webpack:preview',
+            'preview:webpack',
+            'webpack-preview',
+            'preview-webpack',
+        ],
+        buildDepsTargetName: [
+            'build-deps',
+            'webpack:build-deps',
+            'webpack-build-deps',
+        ],
+        watchDepsTargetName: [
+            'watch-deps',
+            'webpack:watch-deps',
+            'webpack-watch-deps',
+        ],
+        serveStaticTargetName: [
+            'serve-static',
+            'webpack:serve-static',
+            'serve-static:webpack',
+            'webpack-serve-static',
+            'serve-static-webpack',
+        ],
+    }, schema.updatePackageScripts);
     let installTask = () => { };
     if (!schema.skipPackageJson) {
-        // webpack and webpack-dev-server are peer dependencies, so ensure they are
-        // installed (both the executor and inferred-plugin paths need them at the
-        // user's runtime).
+        // webpack and webpack-dev-server are peer dependencies needed at the
+        // user's runtime.
         const devDependencies = {
             '@nx/webpack': versions_1.nxVersion,
             '@nx/web': versions_1.nxVersion,
             webpack: versions_1.webpackVersion,
             'webpack-dev-server': versions_1.webpackDevServerVersion,
-        };
-        if (schema.addPlugin) {
             // The inferred plugin runs the `webpack-cli` binary.
-            devDependencies['webpack-cli'] = versions_1.webpackCliVersion;
-        }
+            'webpack-cli': versions_1.webpackCliVersion,
+        };
         // @nx/webpack depends on sass, which pulls in @parcel/watcher. Its install
         // script only builds from source when npm_config_build_from_source is set,
         // so skip it.

package/dist/src/generators/init/schema.d.ts

@@ -3,5 +3,4 @@ export interface Schema {
   skipPackageJson?: boolean;
   keepExistingVersions?: boolean;
   updatePackageScripts?: boolean;
-  addPlugin?: boolean;
 }

package/dist/src/migrations/update-24-0-0/finish-inferred-conversion.md

@@ -0,0 +1,11 @@
+# Replace removed @nx/webpack executors with inferred tasks
+
+Nx 24 removed `@nx/webpack:webpack`, `@nx/webpack:dev-server` (including old `@nrwl` aliases).
+
+Before changing anything, check for leftover work: a project target, a package.json target or a `targetDefaults` entry still uses a removed executor, or the advisory context reports a conversion error. If none applies, make no changes and stop. Treat each advisory-context item as pending work.
+
+1. Inspect all affected projects and workspace defaults. Repair config-loading errors first. Do not restore executor registrations or install older Nx packages.
+2. Register `@nx/webpack/plugin` with options/includes that preserve custom target names and mixed inferred/explicit projects. Replace remaining removed-executor targets, including those in package.json and filtered targetDefaults. Transfer their behavior before removing obsolete defaults. Preserve configurations, dependencies, cache inputs/outputs and environment behavior. Do not silently delete unsupported options or unrelated targets. Migrate old @nrwl aliases too.
+3. Run project graph creation with the daemon and graph cache disabled (`NX_DAEMON=false NX_CACHE_PROJECT_GRAPH=false`), using the workspace package manager. Inspect resolved project targets and verify each migrated entrypoint exists and is inferred (a thin alias to an inferred target is acceptable). Resolve graph errors before completing this migration, even if task validation was skipped. Configs must load for subsequent migrations.
+4. By default run relevant real builds/tests with task cache disabled, including alternate configurations. Honor an existing preference to skip expensive task validation; otherwise offer that option when validation is slow. Skipping expensive tasks never skips conversion or the graph check. Report each skipped task as unverified. Never weaken assertions or change application behavior to make checks pass.
+5. Report converted projects, graph validation, task results and any skipped checks. Unconverted targets or a broken graph mean the migration is incomplete. Investigate task failures and distinguish missing environment prerequisites from conversion regressions; do not claim a working workspace with unresolved regressions.

package/dist/src/migrations/update-24-0-0/inventory.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export interface HelperUsage {
+    name: string;
+    root: string;
+    configPaths: string[];
+    usesHelpers: boolean;
+    usesExecutor: boolean;
+}
+export declare function inventoryComposePlugins(tree: Tree): HelperUsage[];

package/dist/src/migrations/update-24-0-0/inventory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inventoryComposePlugins = inventoryComposePlugins;
+const devkit_1 = require("@nx/devkit");
+const CONFIG_EXTENSIONS = ['js', 'cjs', 'mjs', 'ts', 'cts', 'mts'];
+const REMOVED_HELPERS = /\b(composePlugins|composePluginsSync|withNx|withWeb|withReact)\b/;
+// Left by an earlier conversion; the wrapped `.old` config still calls the helpers.
+const LEGACY_WRAPPER = /\buseLegacyNxPlugin\b/;
+function inventoryComposePlugins(tree) {
+    const usages = [];
+    for (const [name, project] of (0, devkit_1.getProjects)(tree)) {
+        const configs = [...collectConfigPaths(tree, project)].map((path) => ({
+            path,
+            source: tree.read(path, 'utf-8') ?? '',
+        }));
+        const configPaths = configs
+            .filter(({ source }) => REMOVED_HELPERS.test(source) || LEGACY_WRAPPER.test(source))
+            .map(({ path }) => path);
+        if (!configPaths.length)
+            continue;
+        usages.push({
+            name,
+            root: project.root,
+            configPaths: configPaths.sort(),
+            usesHelpers: configs.some(({ source }) => REMOVED_HELPERS.test(source)),
+            usesExecutor: Object.values(project.targets ?? {}).some((target) => target.executor === '@nx/webpack:webpack'),
+        });
+    }
+    return usages;
+}
+function collectConfigPaths(tree, project) {
+    const paths = new Set();
+    for (const target of Object.values(project.targets ?? {})) {
+        for (const options of [
+            target.options,
+            ...Object.values(target.configurations ?? {}),
+        ]) {
+            const configured = options?.webpackConfig;
+            // A package path such as `@nx/react/plugins/webpack` resolves to the stubs
+            // rather than a workspace file; the prompt gives those projects a config.
+            if (typeof configured === 'string' && tree.exists(configured)) {
+                paths.add(configured);
+            }
+        }
+    }
+    for (const extension of CONFIG_EXTENSIONS) {
+        const conventional = `${project.root}/webpack.config.${extension}`;
+        if (tree.exists(conventional)) {
+            paths.add(conventional);
+        }
+    }
+    return paths;
+}

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.d.ts

@@ -0,0 +1,10 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateComposePlugins(tree: Tree): Promise<{
+    skipAgentic: boolean;
+    nextSteps?: undefined;
+    agentContext?: undefined;
+} | {
+    skipAgentic?: undefined;
+    nextSteps: string[];
+    agentContext: string[];
+}>;

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateComposePlugins;
+const devkit_1 = require("@nx/devkit");
+const convert_config_to_webpack_plugin_1 = require("../../generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin");
+const inventory_1 = require("./inventory");
+const CONVERTER = '@nx/webpack:convert-config-to-webpack-plugin';
+async function migrateComposePlugins(tree) {
+    const usages = (0, inventory_1.inventoryComposePlugins)(tree);
+    if (!usages.length) {
+        return { skipAgentic: true };
+    }
+    const converted = [];
+    const remaining = [];
+    for (const usage of usages) {
+        if (!usage.usesHelpers) {
+            converted.push(usage);
+            continue;
+        }
+        try {
+            await (0, convert_config_to_webpack_plugin_1.convertConfigToWebpackPluginGenerator)(tree, {
+                project: usage.name,
+                skipFormat: true,
+            });
+            converted.push(usage);
+        }
+        catch (e) {
+            remaining.push({ usage, reason: e.message });
+        }
+    }
+    if (converted.length) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return {
+        nextSteps: nextSteps(converted, remaining),
+        agentContext: agentContext(converted, remaining),
+    };
+}
+function nextSteps(converted, remaining) {
+    const steps = [];
+    if (converted.length) {
+        steps.push(`Inline the \`webpack.config.old.*\` files that ${CONVERTER} left behind in ${converted.length} project(s), then drop \`useLegacyNxPlugin\`.`);
+    }
+    if (remaining.length) {
+        steps.push(`Migrate ${remaining.length} project(s) off the removed webpack config helpers by hand: ${remaining
+            .map(({ usage }) => usage.name)
+            .join(', ')}.`);
+    }
+    return steps;
+}
+function agentContext(converted, remaining) {
+    const context = [];
+    if (converted.length) {
+        context.push(`${CONVERTER} converted these projects. Each one now has a standard config whose \`useLegacyNxPlugin\` call still loads the renamed \`.old\` config, so the helper callbacks it holds have to move into the new config before the \`.old\` file can go:`, ...converted.map((usage) => `- ${usage.name} (${usage.root}): ${usage.configPaths.join(', ')}`));
+    }
+    if (remaining.length) {
+        context.push(`${CONVERTER} could not convert these projects, so their configs are untouched and still call the removed helpers. Rewrite each one by hand:`, ...remaining.map(({ usage, reason }) => `- ${usage.name} (${usage.root}): ${usage.configPaths.join(', ')} - ${reason}`));
+    }
+    return context;
+}

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.md

@@ -0,0 +1,98 @@
+# Migrate webpack compose helpers
+
+Nx v24 removed `composePlugins`, `composePluginsSync`, `withNx`, `withWeb`, and webpack
+`withReact`. Their exports remain as inert stubs so existing configs still load while Nx
+builds the project graph. They do not configure builds, and a config that loads is not a
+working build.
+
+`@nx/webpack:convert-config-to-webpack-plugin` already ran. The agent context lists the
+projects it converted, including configs an earlier conversion left wrapped in
+`useLegacyNxPlugin`, and, separately, the projects it could not convert with the reason
+for each. Work only on those projects and the files they import. Do not re-inventory the
+workspace, and do not run the converter again.
+
+Preserve the installed webpack version, bundler, targets, configurations, and commands.
+Nx 24 also removed the `@nx/webpack:webpack` executor. Its targets are converted to inferred
+`@nx/webpack/plugin` tasks by a separate migration, so do not add it back or keep a target on it.
+
+## Baseline
+
+This workspace is already on v24, so the old helpers no longer build here. To compare
+against the previous behavior, check out the commit before the upgrade in a separate git
+worktree, install with its lockfile, and build there. Do not downgrade this workspace. If
+you cannot build a baseline, say so in your report rather than calling the comparison a
+pass. Record build commands, output locations, assets, entry points, and any observable
+custom behavior.
+
+## Projects the converter handled
+
+Each one now has a standard config built around `NxAppWebpackPlugin`, plus a
+`useLegacyNxPlugin(require('./webpack.config.old.*'), options)` entry that still loads the
+renamed old config. The old config composes its remaining callbacks through a local
+`composeLegacyPlugins` helper the converter inlined. Two things are left:
+
+- Move what the old config still does into the new config, then delete the `.old` file and
+  drop `useLegacyNxPlugin`.
+- `useLegacyNxPlugin` runs at `beforeCompile`. That is too late to register rules, entries,
+  or plugins, so anything the old config set through those is already not applying the way
+  it used to. Check each one against the baseline instead of trusting the converted build.
+
+Also check the options the converter copied into the new config. It reads them out of the
+old `withNx` call as written, so values that depended on the executor or on environment
+variables are not represented, and workspace-relative paths may need adjusting: native
+plugin options resolve against the project and config directory, while executor options
+were workspace-relative.
+
+## Projects the converter skipped
+
+The agent context gives a reason per project. Those configs are untouched and still call
+the removed helpers, so rewrite each one.
+
+Use a standard webpack configuration with `NxAppWebpackPlugin` from
+`@nx/webpack/app-plugin`. For React apps also use `NxReactWebpackPlugin` from
+`@nx/react/webpack-plugin`. Do not add React configuration to Node or plain web apps, and
+do not change frameworks or upgrade dependencies to simplify the rewrite.
+
+Map the effective old options onto those plugins and standard webpack properties, reading
+the installed plugin types rather than assuming. Preserve precedence between target
+options, named configurations, helper options, and custom callbacks. Preserve compiler
+choice, aliases, CSS, SVG rules, assets, externals, file replacements, source maps,
+optimization, public paths, output filenames, and dev-server behavior. Set output hashing
+explicitly where the old helper defaults differ from the plugin defaults; a build that
+succeeds with renamed entry files is not output parity.
+
+A `webpackConfig` target option naming a package path rather than a local file, such as
+`@nx/react/plugins/webpack`, resolves to the stubs. Give that project its own config file.
+
+Inferred targets run the webpack CLI, which calls a function export with `(env, argv)`.
+Represent the options the executor used to supply in the config itself. Use config
+functions or separate configs where values vary by configuration.
+
+For custom composable functions, move the function into user-owned code and supply the
+options and context it needs explicitly. A local adapter exposing `apply(compiler)` can
+work, but an `apply` object belongs in `config.plugins`; exporting it as the whole config
+is invalid, and a top-level config function must return a config object or supported array.
+Preserve execution order and whether each callback mutates its input or returns a
+replacement. Await asynchronous transforms and propagate failures rather than leaving a
+pending promise.
+
+## Module Federation
+
+Projects using Nx Module Federation are out of scope here. `@nx/module-federation` ships
+its own v24 migration; follow that one. Do not remove federation, disable the project, or
+report success for it from this migration.
+
+## Verify and finish
+
+1. Rebuild the project graph without its disk cache and confirm the same projects and
+   targets are still discoverable.
+2. Run each affected build, development and production and any alternate configurations,
+   without reusing cached task outputs. Exercise Node startup where it applies, plus tests
+   and dev-server or HMR behavior.
+3. Compare emitted files against the baseline: custom assets and markers, entry points,
+   aliases, CSS and SVG handling, externals, and output paths. Compare content where hashes
+   differ. A zero exit code is not enough.
+4. Search the active configs and their imports for the removed helpers again. An already
+   migrated config needs no further change.
+5. Report the commands you ran, the output you checked, and anything still unresolved. Do
+   not delete tests, custom behavior, or targets to get a green result.

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.d.ts

@@ -0,0 +1,6 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+    skipAgentic?: boolean;
+}>;

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const convert_config_to_webpack_plugin_1 = require("../../generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin");
+const inventory_1 = require("./inventory");
+function update(tree) {
+    return (0, internal_1.migrateRemovedExecutors)(tree, [
+        '@nx/webpack:webpack',
+        '@nx/webpack:dev-server',
+        '@nrwl/webpack:webpack',
+        '@nrwl/webpack:dev-server',
+    ], async (tree, options) => {
+        await convertHelperConfigs(tree);
+        const { convertToInferred } = require('../../generators/convert-to-inferred/convert-to-inferred');
+        return convertToInferred(tree, options);
+    });
+}
+// convert-to-inferred skips configs built on the removed helpers, so convert
+// those first. migrate-compose-plugins reports the `.old` configs left behind.
+async function convertHelperConfigs(tree) {
+    for (const usage of (0, inventory_1.inventoryComposePlugins)(tree)) {
+        if (!usage.usesExecutor || !usage.usesHelpers)
+            continue;
+        try {
+            await (0, convert_config_to_webpack_plugin_1.convertConfigToWebpackPluginGenerator)(tree, {
+                project: usage.name,
+                skipFormat: true,
+            });
+        }
+        catch (e) {
+            devkit_1.logger.warn(`Could not convert the webpack config helpers in ${usage.name}: ${e.message}`);
+        }
+    }
+}

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md

@@ -0,0 +1,92 @@
+#### Convert `@nx/webpack` build and dev-server targets to inferred tasks
+
+Nx 24 removes the `@nx/webpack:webpack` and `@nx/webpack:dev-server` executors and their `@nrwl` aliases. The migration registers `@nx/webpack/plugin` in `nx.json` and converts the targets that use those executors to inferred tasks. It moves the executor options into `webpack.config.*`. A target with nothing left to override is removed from project configuration. When several projects share the same remaining options, those options move to a `targetDefaults` entry scoped to the plugin. `targetDefaults` entries keyed by a removed executor are removed once no target uses that executor.
+
+The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
+
+The `@nx/webpack:ssr-dev-server` executor stays.
+
+#### Sample code changes
+
+The example shows the `build` target. Its options move into `webpack.config.*`, so only the configuration names stay on the target.
+
+##### Before
+
+```json title="apps/app1/project.json"
+{
+  "name": "app1",
+  "targets": {
+    "build": {
+      "executor": "@nx/webpack:webpack",
+      "options": {
+        "webpackConfig": "apps/app1/webpack.config.js",
+        "outputPath": "dist/apps/app1",
+        "index": "apps/app1/src/index.html",
+        "main": "apps/app1/src/main.tsx",
+        "tsConfig": "apps/app1/tsconfig.app.json",
+        "assets": ["apps/app1/src/favicon.ico", "apps/app1/src/assets"],
+        "styles": ["apps/app1/src/styles.scss"],
+        "scripts": [],
+        "compiler": "babel",
+        "baseHref": "/"
+      },
+      "configurations": {
+        "development": {
+          "extractLicenses": false,
+          "optimization": false,
+          "sourceMap": true,
+          "vendorChunk": true
+        },
+        "production": {
+          "fileReplacements": [
+            {
+              "replace": "apps/app1/src/environments/environment.ts",
+              "with": "apps/app1/src/environments/environment.prod.ts"
+            }
+          ],
+          "optimization": true,
+          "outputHashing": "all",
+          "sourceMap": false,
+          "namedChunks": false,
+          "extractLicenses": true,
+          "vendorChunk": false
+        }
+      },
+      "defaultConfiguration": "production"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="apps/app1/project.json"
+{
+  "name": "app1",
+  "targets": {
+    "build": {
+      "configurations": {
+        "development": {},
+        "production": {}
+      },
+      "defaultConfiguration": "production"
+    }
+  }
+}
+```
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/webpack/plugin",
+      "options": {
+        "buildTargetName": "build",
+        "previewTargetName": "preview",
+        "serveStaticTargetName": "serve-static",
+        "serveTargetName": "serve"
+      }
+    }
+  ]
+}
+```

package/dist/src/plugins/nx-webpack-plugin/lib/normalize-options.d.ts

@@ -1,4 +1,10 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { type Target } from '@nx/devkit';
 import { AssetGlobPattern, FileReplacement, NormalizedNxAppWebpackPluginOptions, NxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-options';
+export declare const webpackExecutorContext: AsyncLocalStorage<{
+    options: Partial<NxAppWebpackPluginOptions>;
+    target: Target;
+}>;
 export declare function normalizeOptions(options: NxAppWebpackPluginOptions): NormalizedNxAppWebpackPluginOptions;
 export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string, projectRoot: string, resolveRelativePathsToProjectRoot?: boolean): AssetGlobPattern[];
 export declare function normalizeFileReplacements(root: string, fileReplacements: FileReplacement[]): FileReplacement[];

package/dist/src/plugins/nx-webpack-plugin/lib/normalize-options.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackExecutorContext = void 0;
 exports.normalizeOptions = normalizeOptions;
 exports.normalizeAssets = normalizeAssets;
 exports.normalizeFileReplacements = normalizeFileReplacements;
+const node_async_hooks_1 = require("node:async_hooks");
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/js/internal");
 const fs_1 = require("fs");
 const path_1 = require("path");
+exports.webpackExecutorContext = new node_async_hooks_1.AsyncLocalStorage();
 function normalizeOptions(options) {
     const combinedPluginAndMaybeExecutorOptions = {};
     const isProd = process.env.NODE_ENV === 'production';
     // Since this is invoked by the executor, the graph has already been created and cached.
     const projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    const taskDetailsFromBuildTarget = process.env.NX_BUILD_TARGET
-        ? (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph)
-        : undefined;
+    const executorContext = exports.webpackExecutorContext.getStore();
+    const taskDetailsFromBuildTarget = executorContext?.target ??
+        (process.env.NX_BUILD_TARGET
+            ? (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph)
+            : undefined);
     const projectName = taskDetailsFromBuildTarget
         ? taskDetailsFromBuildTarget.project
         : process.env.NX_TASK_TARGET_PROJECT;
@@ -29,26 +34,15 @@ function normalizeOptions(options) {
     normalizeRelativePaths(projectNode.data.root, options);
     // Merge options from `@nx/webpack:webpack` into plugin options.
     // Options from `@nx/webpack:webpack` take precedence.
-    const originalTargetOptions = targetConfig.options;
-    if (configurationName) {
-        Object.assign(originalTargetOptions, targetConfig.configurations?.[configurationName]);
-    }
-    // This could be called from dev-server which means we need to read `buildTarget` to get actual build options.
-    // Otherwise, the options are passed from the `@nx/webpack:webpack` executor.
-    if (originalTargetOptions.buildTarget) {
-        const buildTargetOptions = targetConfig.options;
-        if (configurationName) {
-            Object.assign(buildTargetOptions, targetConfig.configurations?.[configurationName]);
-        }
-        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
-        // executor options take precedence (especially for overriding with CLI args)
-        buildTargetOptions);
-    }
-    else {
-        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
-        // executor options take precedence (especially for overriding with CLI args)
-        originalTargetOptions);
-    }
+    const targetOptions = {
+        ...targetConfig.options,
+        ...(configurationName
+            ? targetConfig.configurations?.[configurationName]
+            : undefined),
+    };
+    Object.assign(combinedPluginAndMaybeExecutorOptions, options, targetOptions);
+    const executorOptions = executorContext?.options;
+    Object.assign(combinedPluginAndMaybeExecutorOptions, Object.fromEntries(Object.entries(executorOptions ?? {}).filter(([key, value]) => value !== undefined && !isExecutorSchemaDefault(key, value))));
     const sourceRoot = (0, internal_1.getProjectSourceRoot)(projectNode.data);
     if (!combinedPluginAndMaybeExecutorOptions.main) {
         throw new Error(`Missing "main" option for the entry file. Set this option in your Nx webpack plugin.`);
@@ -56,7 +50,7 @@ function normalizeOptions(options) {
     return {
         ...combinedPluginAndMaybeExecutorOptions,
         assets: combinedPluginAndMaybeExecutorOptions.assets
-            ? normalizeAssets(combinedPluginAndMaybeExecutorOptions.assets, devkit_1.workspaceRoot, sourceRoot, projectNode.data.root)
+            ? normalizeAssets(combinedPluginAndMaybeExecutorOptions.assets, devkit_1.workspaceRoot, sourceRoot, projectNode.data.root, executorOptions?.assets === undefined)
             : [],
         baseHref: combinedPluginAndMaybeExecutorOptions.baseHref ?? '/',
         buildLibsFromSource: combinedPluginAndMaybeExecutorOptions.buildLibsFromSource ?? true,
@@ -163,6 +157,17 @@ function normalizeRelativePaths(projectRoot, options) {
         }
     }
 }
+// Executor-style callers pass options with the removed @nx/webpack:webpack
+// schema defaults applied. Those defaults must not override the plugin's own
+// options; target options still apply above.
+const executorSchemaDefaults = {
+    outputFileName: 'main.js',
+    standardWebpackConfigFunction: false,
+    buildLibsFromSource: true,
+};
+function isExecutorSchemaDefault(key, value) {
+    return key in executorSchemaDefaults && executorSchemaDefaults[key] === value;
+}
 function isRelativePath(val) {
     return (typeof val === 'string' &&
         (val.startsWith('./') ||