@nx/webpack 24.0.0-beta.2 → 24.0.0-beta.4

package/dist/src/plugins/nx-webpack-plugin/nx-app-webpack-plugin.d.ts

@@ -1,5 +1,6 @@
 import type { Compiler } from 'webpack';
 import { NxAppWebpackPluginOptions } from './nx-app-webpack-plugin-options';
+import { READY_SIGNAL_PLUGIN } from '../../utils/dev-server-ready-signal';
 /**
  * This plugin provides features to build Node and Web applications.
  * - TS support (including tsconfig paths)
@@ -12,6 +13,7 @@ import { NxAppWebpackPluginOptions } from './nx-app-webpack-plugin-options';
  */
 export declare class NxAppWebpackPlugin {
     private readonly options;
+    readonly [READY_SIGNAL_PLUGIN] = true;
     constructor(options?: NxAppWebpackPluginOptions);
     apply(compiler: Compiler): void;
 }

package/dist/src/plugins/nx-webpack-plugin/nx-app-webpack-plugin.js

@@ -1,7 +1,9 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NxAppWebpackPlugin = void 0;
 const normalize_options_1 = require("./lib/normalize-options");
+const dev_server_ready_signal_1 = require("../../utils/dev-server-ready-signal");
 /**
  * This plugin provides features to build Node and Web applications.
  * - TS support (including tsconfig paths)
@@ -14,6 +16,7 @@ const normalize_options_1 = require("./lib/normalize-options");
  */
 class NxAppWebpackPlugin {
     constructor(options = {}) {
+        this[_a] = true;
         // If we're building inferred targets, skip normalizing build options.
         if (!global.NX_GRAPH_CREATION) {
             this.options = (0, normalize_options_1.normalizeOptions)(options);
@@ -23,19 +26,32 @@ class NxAppWebpackPlugin {
         // Lazy-required so a generator can load this without the webpack bundler.
         const { applyBaseConfig } = require('./lib/apply-base-config');
         const { applyWebConfig } = require('./lib/apply-web-config');
+        const { applyDevServerReadySignal } = require('../../utils/dev-server-ready-signal');
+        applyDevServerReadySignal(compiler);
         // Defaults to 'web' if not specified to match Webpack's default.
         const target = this.options.target ?? compiler.options.target ?? 'web';
         this.options.outputPath ??= compiler.options.output?.path;
         if (typeof target === 'string') {
             this.options.target = target;
         }
+        // Cypress supplies its own `main` entry and index.html, and license
+        // extraction fails with ENOENT for buildable libraries under component
+        // testing.
+        if (process.env.NX_CYPRESS_COMPONENT_TEST === 'true') {
+            this.options.main = undefined;
+            this.options.generateIndexHtml = false;
+            this.options.extractLicenses = false;
+        }
         applyBaseConfig(this.options, compiler.options, {
             useNormalizedEntry: true,
         });
+        compiler.context = compiler.options.context;
         if (compiler.options.target) {
             this.options.target = compiler.options.target;
         }
-        if (this.options.target === 'web' || this.options.target === 'webworker') {
+        if (this.options.target === 'web' ||
+            this.options.target === 'webworker' ||
+            this.options.ssr) {
             applyWebConfig(this.options, compiler.options, {
                 useNormalizedEntry: true,
             });
@@ -43,3 +59,4 @@ class NxAppWebpackPlugin {
     }
 }
 exports.NxAppWebpackPlugin = NxAppWebpackPlugin;
+_a = dev_server_ready_signal_1.READY_SIGNAL_PLUGIN;

package/dist/src/plugins/plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = void 0;
 const internal_1 = require("@nx/devkit/internal");
+const dev_server_ready_signal_1 = require("../utils/dev-server-ready-signal");
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
@@ -121,6 +122,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             },
         },
     };
+    const devServerReadyWhen = getDevServerReadyWhen(configFilePath, webpackOptions);
     targets[options.serveTargetName] = {
         continuous: true,
         inputs: [...buildInputs],
@@ -129,6 +131,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             cwd: projectRoot,
             env: { NODE_ENV: 'development' },
         },
+        readyWhen: devServerReadyWhen,
         metadata: {
             technologies: ['webpack'],
             description: 'Starts Webpack dev server',
@@ -150,6 +153,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             cwd: projectRoot,
             env: { NODE_ENV: 'production' },
         },
+        readyWhen: devServerReadyWhen,
         metadata: {
             technologies: ['webpack'],
             description: 'Starts Webpack dev server in production mode',
@@ -172,6 +176,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             buildTarget: options.buildTargetName,
             spa: true,
         },
+        readyWhen: { port: '{options.port}', host: '{options.host ?? localhost}' },
     };
     // for `convert-to-inferred` we need to leave the port undefined or the options will not match
     if (webpackConfig.devServer?.port && webpackConfig.devServer?.port !== 4200) {
@@ -255,3 +260,22 @@ function normalizeOptions(options) {
         watchDepsTargetName: 'watch-deps',
     };
 }
+// A dev server whose config loads NxAppWebpackPlugin or NxReadySignalPlugin reports
+// when it listens. Otherwise the check reads the config when the task runs,
+// with the task's env and options, and waits for the dev server's port.
+function getDevServerReadyWhen(configFilePath, configs) {
+    // webpack-cli starts a dev server for each config with devServer. Only the
+    // first one to listen would signal, so several get the check that waits
+    // for each of them.
+    const withDevServer = configs.filter((config) => config.devServer);
+    const signals = withDevServer.length === 1 && (0, dev_server_ready_signal_1.sendsReadySignal)(withDevServer[0]);
+    return signals
+        ? { signal: true }
+        : {
+            // Unquoted: the plugin's glob fixes the file name. Quote it if it ever
+            // becomes user-chosen, since the shell expands $, backticks and %.
+            command: `node -e "require('@nx/webpack/ready-check').waitForDevServer(process.argv[1])" ${(0, path_1.basename)(configFilePath)}`,
+            // Each attempt loads the config
+            interval: 1000,
+        };
+}

package/dist/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.js

@@ -59,6 +59,9 @@ async function useLegacyNxPlugin(fn, executorOptions) {
         apply(compiler) {
             compiler.hooks.beforeCompile.tapPromise('NxLegacyAsyncPlugin', () => {
                 return new Promise((resolve) => {
+                    // Legacy functions are typed to take `Configuration` but mutate the
+                    // normalized options in place. From webpack 5.111 the two types
+                    // conflict (`output.copy`), and the public signature can't widen.
                     fn(compiler.options, ctx).then((updated) => {
                         // Merge options back shallowly since it's a fully functional configuration.
                         // Most likely, the user modified the config in place, but this guarantees that updates are applied if users did something like:

package/dist/src/utils/config.d.ts

@@ -1,6 +1,6 @@
-import { ExecutorContext } from '@nx/devkit';
+import type { ExecutorContext } from '@nx/devkit';
 import type { Configuration } from 'webpack';
-import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
+import type { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
 export declare const nxWebpackComposablePlugin = "nxWebpackComposablePlugin";
 export declare function isNxWebpackComposablePlugin(a: unknown): a is AsyncNxComposableWebpackPlugin;
 export interface NxWebpackExecutionContext {
@@ -15,20 +15,16 @@ export interface AsyncNxComposableWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<Configuration>;
 }
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function composePlugins(...plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>) & {
+export declare function composePlugins(..._plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config?: Configuration, ctx?: NxWebpackExecutionContext) => Promise<Configuration>) & {
     nxWebpackComposablePlugin: boolean;
 };
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
+export declare function composePluginsSync(..._plugins: NxComposableWebpackPlugin[]): ((config?: Configuration, ctx?: NxWebpackExecutionContext) => Configuration) & {
     nxWebpackComposablePlugin: boolean;
 };

package/dist/src/utils/config.js

@@ -4,84 +4,31 @@ exports.nxWebpackComposablePlugin = void 0;
 exports.isNxWebpackComposablePlugin = isNxWebpackComposablePlugin;
 exports.composePlugins = composePlugins;
 exports.composePluginsSync = composePluginsSync;
-const devkit_1 = require("@nx/devkit");
-const internal_1 = require("@nx/js/internal");
 const deprecation_1 = require("./deprecation");
-const internal_2 = require("@nx/devkit/internal");
 exports.nxWebpackComposablePlugin = 'nxWebpackComposablePlugin';
 function isNxWebpackComposablePlugin(a) {
     return a?.[exports.nxWebpackComposablePlugin] === true;
 }
+// TODO(v25): remove the inert config-helper stubs in this file.
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function composePlugins(...plugins) {
+function composePlugins(..._plugins) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return Object.assign(async function combined(config, ctx) {
-        // Webpack may be calling us as a standard config function.
-        // Build up Nx context from environment variables.
-        // This is to enable `@nx/webpack/plugin` to work with existing projects.
-        if (ctx['env']) {
-            ensureNxWebpackExecutionContext(ctx);
-            // Build this from scratch since what webpack passes us is the env, not config,
-            // and `withNX()` creates a new config object anyway.
-            config = {};
-        }
-        for (const plugin of plugins) {
-            const fn = await plugin;
-            config = await fn(config, ctx);
-        }
-        return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
+    return Object.assign(async (config = {}, ctx) => {
+        // Only the legacy Nx executor passes a config; CLIs pass (env, argv).
+        return ctx?.context && typeof ctx.context === 'object' ? config : {};
+    }, { [exports.nxWebpackComposablePlugin]: true });
 }
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function composePluginsSync(...plugins) {
+function composePluginsSync(..._plugins) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return Object.assign(function combined(config, ctx) {
-        for (const plugin of plugins) {
-            config = plugin(config, ctx);
-        }
-        return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
-}
-function ensureNxWebpackExecutionContext(ctx) {
-    const projectName = process.env.NX_TASK_TARGET_PROJECT;
-    const targetName = process.env.NX_TASK_TARGET_TARGET;
-    const configurationName = process.env.NX_TASK_TARGET_CONFIGURATION;
-    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    const projectNode = projectGraph.nodes[projectName];
-    ctx.options ??= {
-        root: devkit_1.workspaceRoot,
-        projectRoot: projectNode.data.root,
-        sourceRoot: (0, internal_1.getProjectSourceRoot)(projectNode.data),
-        // These aren't actually needed since NxWebpackPlugin and withNx both support them being undefined.
-        assets: undefined,
-        outputPath: undefined,
-        tsConfig: undefined,
-        outputFileName: undefined,
-        useTsconfigPaths: undefined,
-    };
-    ctx.context ??= {
-        projectName,
-        targetName,
-        configurationName,
-        projectsConfigurations: (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
-        nxJsonConfiguration: (0, internal_2.readNxJsonFromDisk)(devkit_1.workspaceRoot),
-        cwd: process.cwd(),
-        root: devkit_1.workspaceRoot,
-        isVerbose: process.env['NX_VERBOSE_LOGGING'] === 'true',
-        projectGraph,
-    };
+    return Object.assign((config = {}, ctx) => {
+        // Only the legacy Nx executor passes a config; CLIs pass (env, argv).
+        return ctx?.context && typeof ctx.context === 'object' ? config : {};
+    }, { [exports.nxWebpackComposablePlugin]: true });
 }

package/dist/src/utils/deprecation.d.ts

@@ -1,8 +1,3 @@
-export declare const WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/webpack:webpack` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare const WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/webpack:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare function warnWebpackExecutorDeprecation(): void;
-export declare function warnWebpackDevServerExecutorDeprecation(): void;
-export declare function warnWebpackExecutorGenerating(): void;
-export declare const WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = "The `composePlugins`, `withNx`, and `withWeb` config helpers from `@nx/webpack` are deprecated and will be removed in Nx v24. They produce an Nx-specific config function that only runs under the `@nx/webpack:webpack` executor. Migrate to a standard webpack config that uses `NxAppWebpackPlugin` (from `@nx/webpack/app-plugin`) under the inferred `@nx/webpack/plugin` by running `nx g @nx/webpack:convert-to-inferred`. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare const WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = "The compose config helpers from `@nx/webpack` were removed in Nx v24. The remaining exports are inert compatibility stubs and do not configure builds. Migrate to a standard webpack config using `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`. Follow the config-helper migration instructions generated by `nx migrate`. Executor conversion is a separate migration.";
 export declare function suppressWebpackComposeHelperWarnings<T>(fn: () => T): T;
 export declare function warnWebpackComposeHelpersDeprecation(): void;

package/dist/src/utils/deprecation.js

@@ -1,35 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = void 0;
-exports.warnWebpackExecutorDeprecation = warnWebpackExecutorDeprecation;
-exports.warnWebpackDevServerExecutorDeprecation = warnWebpackDevServerExecutorDeprecation;
-exports.warnWebpackExecutorGenerating = warnWebpackExecutorGenerating;
+exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = void 0;
 exports.suppressWebpackComposeHelperWarnings = suppressWebpackComposeHelperWarnings;
 exports.warnWebpackComposeHelpersDeprecation = warnWebpackComposeHelpersDeprecation;
 const devkit_1 = require("@nx/devkit");
-// TODO(v24): Remove the @nx/webpack:webpack and @nx/webpack:dev-server
-// executors. The inferred plugin (@nx/webpack/plugin) and the
-// convert-to-inferred generator stay supported.
-exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/webpack:webpack` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/webpack:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-function warnWebpackExecutorDeprecation() {
-    devkit_1.logger.warn(exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE);
-}
-function warnWebpackDevServerExecutorDeprecation() {
-    devkit_1.logger.warn(exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
-}
-// Fired when the @nx/webpack:configuration generator is about to generate
-// targets that use the deprecated executors — i.e. when @nx/webpack/plugin
-// isn't registered in nx.json. Surfaces the deprecation at generation time
-// rather than only when the user later runs the generated targets.
-function warnWebpackExecutorGenerating() {
-    devkit_1.logger.warn('Generating targets that use the deprecated `@nx/webpack:webpack` and `@nx/webpack:dev-server` executors. These executors will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` next to migrate these targets to the `@nx/webpack/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
-}
-// TODO(v24): Remove the composePlugins/withNx/withWeb config helpers. They emit
-// an Nx-specific config function that only runs under the @nx/webpack:webpack
-// executor; the inferred @nx/webpack/plugin works with standard webpack configs
-// built around NxAppWebpackPlugin instead.
-exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = 'The `composePlugins`, `withNx`, and `withWeb` config helpers from `@nx/webpack` are deprecated and will be removed in Nx v24. They produce an Nx-specific config function that only runs under the `@nx/webpack:webpack` executor. Migrate to a standard webpack config that uses `NxAppWebpackPlugin` (from `@nx/webpack/app-plugin`) under the inferred `@nx/webpack/plugin` by running `nx g @nx/webpack:convert-to-inferred`. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+// Helper behavior was removed in v24; exports remain only as inert stubs.
+// Keep their exports loadable so old configs do not block graph creation.
+exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = 'The compose config helpers from `@nx/webpack` were removed in Nx v24. The remaining exports are inert compatibility stubs and do not configure builds. Migrate to a standard webpack config using `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`. Follow the config-helper migration instructions generated by `nx migrate`. Executor conversion is a separate migration.';
 let composeHelpersWarned = false;
 let suppressDepth = 0;
 // Nx-internal entry points compose these helpers themselves (e.g. the rspack

package/dist/src/utils/dev-server-ready-check.d.ts

@@ -0,0 +1,48 @@
+export interface ServeFlags {
+    port?: string;
+    host?: string;
+    configNames: string[];
+    configs: string[];
+    merge: boolean;
+    env: Record<string, unknown>;
+    extends: string[];
+}
+/**
+ * The flags `webpack-cli serve` gets from the target's options, in the order
+ * run-commands passes them: named options, `args`, then overrides.
+ */
+export declare function parseServeFlags(options: Record<string, unknown>): ServeFlags;
+/**
+ * The `argv` webpack-cli passes to a function config: its commander options,
+ * with `env` set by the caller. Values stay strings except `--port`, which
+ * webpack-cli converts to a number when it is numeric.
+ */
+export declare function parseServeArgv(options: Record<string, unknown>, env: Record<string, unknown>): Record<string, unknown>;
+export type DevServerAddress = {
+    port: number;
+    host?: string;
+};
+/**
+ * Where a dev server listens, or null when it picks its port or listens on a
+ * socket. Returns null for those, since nothing can be probed ahead of them.
+ */
+export declare function getDevServerAddress(devServer: {
+    port?: unknown;
+    host?: unknown;
+    ipc?: unknown;
+} | undefined, flags: ServeFlags, basePort: string | undefined): DevServerAddress | null;
+/** Resolves once every address accepts a TCP connection. */
+export declare function waitForAddresses(addresses: DevServerAddress[]): Promise<void>;
+export declare function readTaskOptions(): Record<string, unknown> & {
+    cwd?: string;
+};
+export declare function enterTaskCwd(options: {
+    cwd?: string;
+}): void;
+/**
+ * The readyWhen of the inferred serve targets when the config doesn't load the
+ * signal plugin. Runs in the env and with the options of the serve task, reads
+ * the config the way `webpack-cli serve` does, and waits for each dev server it
+ * starts.
+ */
+export declare function waitForWebpackDevServer(configPath: string): Promise<void>;