@nx/webpack 23.0.0-beta.22 → 23.0.0-beta.24

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const FROM_PREFIX = '@nx/webpack/src/';
+const TO_PUBLIC = '@nx/webpack';
+const TO_INTERNAL = '@nx/webpack/internal';
+// Symbols exported from `@nx/webpack`'s public entry (packages/webpack/index.ts).
+// A named import/export of one of these from `@nx/webpack/src/*` is routed to
+// the public `@nx/webpack` entry; everything else goes to `@nx/webpack/internal`.
+const PUBLIC_SYMBOLS = new Set([
+    'AssetGlobPattern',
+    'AsyncNxComposableWebpackPlugin',
+    'FileReplacement',
+    'MergedOptions',
+    'NormalizedWebpackExecutorOptions',
+    'NxComposableWebpackPlugin',
+    'NxWebpackExecutionContext',
+    'NxWebpackPlugin',
+    'WebDevServerOptions',
+    'WebpackExecutorEvent',
+    'WebpackExecutorOptions',
+    'WithNxOptions',
+    'WithWebOptions',
+    'composePlugins',
+    'composePluginsSync',
+    'configurationGenerator',
+    'convertConfigToWebpackPluginGenerator',
+    'createCopyPlugin',
+    'devServerExecutor',
+    'getCSSModuleLocalIdent',
+    'getWebpackE2EWebServerInfo',
+    'isNxWebpackComposablePlugin',
+    'normalizeOptions',
+    'normalizePluginPath',
+    'nxWebpackComposablePlugin',
+    'useLegacyNxPlugin',
+    'webpackExecutor',
+    'webpackInitGenerator',
+    'webpackProjectGenerator',
+    'withNx',
+    'withWeb',
+]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(FROM_PREFIX)) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/webpack/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/webpack, internals to @nx/webpack/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text.startsWith(FROM_PREFIX);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/webpack`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && literal.text.startsWith(FROM_PREFIX)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/{src → dist/src}/plugins/generate-package-json-plugin.d.ts

@@ -15,4 +15,3 @@ export declare class GeneratePackageJsonPlugin implements WebpackPluginInstance
     private resolveRuntimeDependencies;
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=generate-package-json-plugin.d.ts.map

package/{src → dist/src}/plugins/nx-typescript-webpack-plugin/nx-tsconfig-paths-webpack-plugin.d.ts

@@ -6,4 +6,3 @@ export declare class NxTsconfigPathsWebpackPlugin {
     apply(compiler: Compiler): void;
     handleBuildLibsFromSource(config: Partial<WebpackOptionsNormalized | Configuration>, options: NormalizedNxAppWebpackPluginOptions): void;
 }
-//# sourceMappingURL=nx-tsconfig-paths-webpack-plugin.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-base-config.d.ts

@@ -3,4 +3,3 @@ import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-op
 export declare function applyBaseConfig(options: NormalizedNxAppWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;
-//# sourceMappingURL=apply-base-config.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/apply-web-config.d.ts

@@ -3,4 +3,3 @@ import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-op
 export declare function applyWebConfig(options: NormalizedNxAppWebpackPluginOptions, config?: Partial<WebpackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;
-//# sourceMappingURL=apply-web-config.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/compiler-loaders.d.ts

@@ -53,4 +53,3 @@ export declare function createLoaderFromCompiler(options: NormalizedNxAppWebpack
         jsc?: undefined;
     };
 };
-//# sourceMappingURL=compiler-loaders.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/get-terser-ecma-version.d.ts

@@ -1,2 +1 @@
 export declare function getTerserEcmaVersion(projectRoot: string): 2020 | 5;
-//# sourceMappingURL=get-terser-ecma-version.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/instantiate-script-plugins.d.ts

@@ -1,4 +1,3 @@
 import { WebpackPluginInstance } from 'webpack';
 import { NormalizedNxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-options';
 export declare function instantiateScriptPlugins(options: NormalizedNxAppWebpackPluginOptions): WebpackPluginInstance[];
-//# sourceMappingURL=instantiate-script-plugins.d.ts.map

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

@@ -2,4 +2,3 @@ import { AssetGlobPattern, FileReplacement, NormalizedNxAppWebpackPluginOptions,
 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[];
-//# sourceMappingURL=normalize-options.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/stylesheet-loaders.d.ts

@@ -71,4 +71,3 @@ export declare function getCommonLoadersForGlobalStyle(options: NormalizedNxAppW
     };
 })[];
 export {};
-//# sourceMappingURL=stylesheet-loaders.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/lib/utils.d.ts

@@ -24,4 +24,3 @@ export declare function getAllTransitiveDeps(graph: ProjectGraph, targetName: st
  * @returns A list of all non-buildable libraries that the project depends on, including transitive dependencies.
  */
 export declare function getNonBuildableLibs(graph: ProjectGraph, projectName: string): (string | RegExp)[];
-//# sourceMappingURL=utils.d.ts.map

package/{src → dist/src}/plugins/nx-webpack-plugin/nx-app-webpack-plugin-options.d.ts

@@ -271,4 +271,3 @@ export interface NormalizedNxAppWebpackPluginOptions extends NxAppWebpackPluginO
     outputFileName: string;
     assets: AssetGlobPattern[];
 }
-//# sourceMappingURL=nx-app-webpack-plugin-options.d.ts.map

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

@@ -15,4 +15,3 @@ export declare class NxAppWebpackPlugin {
     constructor(options?: NxAppWebpackPluginOptions);
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=nx-app-webpack-plugin.d.ts.map

package/{src → dist/src}/plugins/plugin.d.ts

@@ -1,4 +1,4 @@
-import { CreateDependencies, CreateNodesV2 } from '@nx/devkit';
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
 export interface WebpackPluginOptions {
     buildTargetName?: string;
     serveTargetName?: string;
@@ -11,6 +11,5 @@ export interface WebpackPluginOptions {
  * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
  */
 export declare const createDependencies: CreateDependencies;
-export declare const createNodes: CreateNodesV2<WebpackPluginOptions>;
-export declare const createNodesV2: CreateNodesV2<WebpackPluginOptions>;
-//# sourceMappingURL=plugin.d.ts.map
+export declare const createNodes: CreateNodes<WebpackPluginOptions>;
+export declare const createNodesV2: CreateNodes<WebpackPluginOptions>;

package/{src → dist/src}/plugins/plugin.js

@@ -88,7 +88,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
     const targets = {};
     targets[options.buildTargetName] = {
         command: `webpack-cli build`,
-        options: { cwd: projectRoot, args: ['--node-env=production'] },
+        options: { cwd: projectRoot, env: { NODE_ENV: 'production' } },
         cache: true,
         dependsOn: [`^${options.buildTargetName}`],
         inputs: 'production' in namedInputs
@@ -128,7 +128,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
         command: `webpack-cli serve`,
         options: {
             cwd: projectRoot,
-            args: ['--node-env=development'],
+            env: { NODE_ENV: 'development' },
         },
         metadata: {
             technologies: ['webpack'],
@@ -148,7 +148,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
         command: `webpack-cli serve`,
         options: {
             cwd: projectRoot,
-            args: ['--node-env=production'],
+            env: { NODE_ENV: 'production' },
         },
         metadata: {
             technologies: ['webpack'],

package/{src → dist/src}/plugins/stats-json-plugin.d.ts

@@ -2,4 +2,3 @@ import { Compiler } from 'webpack';
 export declare class StatsJsonPlugin {
     apply(compiler: Compiler): void;
 }
-//# sourceMappingURL=stats-json-plugin.d.ts.map

package/{src → dist/src}/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.d.ts

@@ -29,4 +29,3 @@ module.exports = async () => ({
 export declare function useLegacyNxPlugin(fn: (config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>, executorOptions: NxAppWebpackPluginOptions): Promise<{
     apply(compiler: Compiler): void;
 }>;
-//# sourceMappingURL=use-legacy-nx-plugin.d.ts.map

package/{src → dist/src}/plugins/webpack-nx-build-coordination-plugin.d.ts

@@ -19,4 +19,3 @@ export declare class WebpackNxBuildCoordinationPlugin {
     private createFileWatcher;
 }
 export {};
-//# sourceMappingURL=webpack-nx-build-coordination-plugin.d.ts.map

package/{src → dist/src}/plugins/write-index-html-plugin.d.ts

@@ -20,4 +20,3 @@ export declare class WriteIndexHtmlPlugin {
     private generateSriAttributes;
     private filterAndMapBuildFiles;
 }
-//# sourceMappingURL=write-index-html-plugin.d.ts.map

package/{src → dist/src}/utils/config.d.ts

@@ -14,10 +14,21 @@ export interface NxComposableWebpackPlugin {
 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.
+ */
 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.
+ */
 export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
     nxWebpackComposablePlugin: boolean;
 };
-//# sourceMappingURL=config.d.ts.map

package/{src → dist/src}/utils/config.js

@@ -7,11 +7,19 @@ exports.composePluginsSync = composePluginsSync;
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/js/internal");
 const configuration_1 = require("nx/src/config/configuration");
+const deprecation_1 = require("./deprecation");
 exports.nxWebpackComposablePlugin = 'nxWebpackComposablePlugin';
 function isNxWebpackComposablePlugin(a) {
     return a?.[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.
+ */
 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.
@@ -31,7 +39,14 @@ function composePlugins(...plugins) {
         [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.
+ */
 function composePluginsSync(...plugins) {
+    (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
     return Object.assign(function combined(config, ctx) {
         for (const plugin of plugins) {
             config = plugin(config, ctx);

package/{src → dist/src}/utils/create-copy-plugin.d.ts

@@ -1,4 +1,3 @@
 import CopyWebpackPlugin from 'copy-webpack-plugin';
 import { AssetGlobPattern } from '../executors/webpack/schema';
 export declare function createCopyPlugin(assets: AssetGlobPattern[]): CopyWebpackPlugin;
-//# sourceMappingURL=create-copy-plugin.d.ts.map

package/{src → dist/src}/utils/deprecation.d.ts

@@ -3,4 +3,6 @@ export declare const WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx
 export declare function warnWebpackExecutorDeprecation(): void;
 export declare function warnWebpackDevServerExecutorDeprecation(): void;
 export declare function warnWebpackExecutorGenerating(): void;
-//# sourceMappingURL=deprecation.d.ts.map
+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 function suppressWebpackComposeHelperWarnings<T>(fn: () => T): T;
+export declare function warnWebpackComposeHelpersDeprecation(): void;

package/{src → dist/src}/utils/deprecation.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = void 0;
+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.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
@@ -23,3 +25,31 @@ function warnWebpackDevServerExecutorDeprecation() {
 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.';
+let composeHelpersWarned = false;
+let suppressDepth = 0;
+// Nx-internal entry points compose these helpers themselves (e.g. the rspack
+// executor, the storybook/component-testing presets). They wrap their
+// synchronous composition in this so the warning fires only for user-authored
+// configs, not for users who never touched the compose helpers.
+function suppressWebpackComposeHelperWarnings(fn) {
+    suppressDepth++;
+    try {
+        return fn();
+    }
+    finally {
+        suppressDepth--;
+    }
+}
+// Warn once per process so a `composePlugins(withNx(), withWeb())` chain logs a
+// single line, not one per helper, and HMR reloads don't repeat it.
+function warnWebpackComposeHelpersDeprecation() {
+    if (suppressDepth > 0 || composeHelpersWarned)
+        return;
+    composeHelpersWarned = true;
+    devkit_1.logger.warn(exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE);
+}

package/{src → dist/src}/utils/e2e-web-server-info-utils.d.ts

@@ -1,3 +1,2 @@
 import { type Tree } from '@nx/devkit';
 export declare function getWebpackE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;
-//# sourceMappingURL=e2e-web-server-info-utils.d.ts.map

package/{src → dist/src}/utils/ensure-dependencies.d.ts

@@ -4,4 +4,3 @@ export type EnsureDependenciesOptions = {
     uiFramework?: 'none' | 'react';
 };
 export declare function ensureDependencies(tree: Tree, options: EnsureDependenciesOptions): GeneratorCallback;
-//# sourceMappingURL=ensure-dependencies.d.ts.map

package/{src → dist/src}/utils/ensure-dependencies.js

@@ -21,6 +21,6 @@ function ensureDependencies(tree, options) {
         devDependencies['@svgr/webpack'] = versions_1.svgrWebpackVersion;
         devDependencies['react-refresh'] = versions_1.reactRefreshVersion;
     }
-    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true));
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }

package/{src → dist/src}/utils/fs.d.ts

@@ -4,4 +4,3 @@ export declare function findAllNodeModules(from: string, root?: string): string[
  * Delete an output directory, but error out if it's the root of the project.
  */
 export declare function deleteOutputDir(root: string, outputPath: string): void;
-//# sourceMappingURL=fs.d.ts.map

package/{src → dist/src}/utils/get-client-environment.d.ts

@@ -3,4 +3,3 @@ export declare function getClientEnvironment(mode?: string): {
         'process.env': {};
     };
 };
-//# sourceMappingURL=get-client-environment.d.ts.map

package/{src → dist/src}/utils/get-css-module-local-ident.d.ts

@@ -1,2 +1 @@
 export declare function getCSSModuleLocalIdent(ctx: any, localIdentName: any, localName: any, options: any): any;
-//# sourceMappingURL=get-css-module-local-ident.d.ts.map

package/{src → dist/src}/utils/has-plugin.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export declare function hasPlugin(tree: Tree): boolean;
-//# sourceMappingURL=has-plugin.d.ts.map

package/{src → dist/src}/utils/hash-format.d.ts

@@ -5,4 +5,3 @@ export interface HashFormat {
     script: string;
 }
 export declare function getOutputHashFormat(option: string, length?: number): HashFormat;
-//# sourceMappingURL=hash-format.d.ts.map

package/{src → dist/src}/utils/models.d.ts

@@ -21,4 +21,3 @@ export interface CreateWebpackConfigOptions<T = any> {
     tsConfig: any;
     tsConfigPath: string;
 }
-//# sourceMappingURL=models.d.ts.map

package/{src → dist/src}/utils/run-webpack.d.ts

@@ -3,4 +3,3 @@ export declare function runWebpackDevServer(config: any, webpack: typeof import(
     stats: any;
     baseUrl: string;
 }>;
-//# sourceMappingURL=run-webpack.d.ts.map

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

@@ -0,0 +1,12 @@
+import { type Tree } from '@nx/devkit';
+export declare const nxVersion: any;
+export declare const swcLoaderVersion = "0.1.15";
+export declare const tsLibVersion = "^2.3.0";
+export declare const minSupportedWebpackVersion = "5.0.0";
+export declare const webpackVersion = "^5.101.3";
+export declare const webpackDevServerVersion = "^5.2.1";
+export declare const webpackCliVersion = "^7.0.0";
+export declare const reactRefreshWebpackPluginVersion = "^0.5.7";
+export declare const svgrWebpackVersion = "^8.0.1";
+export declare const reactRefreshVersion = "^0.10.0";
+export declare function assertSupportedWebpackVersion(tree: Tree): void;

package/dist/src/utils/versions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactRefreshVersion = exports.svgrWebpackVersion = exports.reactRefreshWebpackPluginVersion = exports.webpackCliVersion = exports.webpackDevServerVersion = exports.webpackVersion = exports.minSupportedWebpackVersion = exports.tsLibVersion = exports.swcLoaderVersion = exports.nxVersion = void 0;
+exports.assertSupportedWebpackVersion = assertSupportedWebpackVersion;
+const path_1 = require("path");
+const internal_1 = require("@nx/devkit/internal");
+exports.nxVersion = require((0, path_1.join)('@nx/webpack', 'package.json')).version;
+exports.swcLoaderVersion = '0.1.15';
+exports.tsLibVersion = '^2.3.0';
+// Floor for the generator-level support check. The plugin's runtime code uses
+// webpack 5-only APIs (e.g. `ids.HashedModuleIdsPlugin`, `webpack.sources`,
+// `experiments.cacheUnaffected`), so webpack 5 is the supported floor.
+exports.minSupportedWebpackVersion = '5.0.0';
+// Fresh-install versions written when the package is not already present.
+exports.webpackVersion = '^5.101.3';
+exports.webpackDevServerVersion = '^5.2.1';
+exports.webpackCliVersion = '^7.0.0';
+// React apps
+exports.reactRefreshWebpackPluginVersion = '^0.5.7';
+exports.svgrWebpackVersion = '^8.0.1';
+exports.reactRefreshVersion = '^0.10.0';
+function assertSupportedWebpackVersion(tree) {
+    (0, internal_1.assertSupportedPackageVersion)(tree, 'webpack', exports.minSupportedWebpackVersion);
+}

package/dist/src/utils/web-babel-loader.d.ts

@@ -0,0 +1 @@
+export {};

package/{src → dist/src}/utils/web-babel-loader.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 module.exports = require('babel-loader').custom(() => {
     return {
         customOptions({ isTest, isModern, emitDecoratorMetadata, ...loader }) {

package/{src → dist/src}/utils/webpack/interpolate-env-variables-to-index.d.ts

@@ -1,2 +1 @@
 export declare function interpolateEnvironmentVariablesToIndex(contents: string, deployUrl?: string): string;
-//# sourceMappingURL=interpolate-env-variables-to-index.d.ts.map

package/{src → dist/src}/utils/webpack/normalize-entry.d.ts

@@ -1,3 +1,2 @@
 import { ExtraEntryPoint, NormalizedEntryPoint } from '../models';
 export declare function normalizeExtraEntryPoints(extraEntryPoints: ExtraEntryPoint[], defaultBundleName: string): NormalizedEntryPoint[];
-//# sourceMappingURL=normalize-entry.d.ts.map

package/{src → dist/src}/utils/webpack/package-chunk-sort.d.ts

@@ -3,4 +3,3 @@ export declare function generateEntryPoints(appConfig: {
     styles: ExtraEntryPoint[];
     scripts: ExtraEntryPoint[];
 }): string[];
-//# sourceMappingURL=package-chunk-sort.d.ts.map

package/{src → dist/src}/utils/webpack/plugins/postcss-cli-resources.d.ts

@@ -12,4 +12,3 @@ export declare function PostcssCliResources(options: PostcssCliResourcesOptions)
     postcssPlugin: string;
     Once(root: any): Promise<void[]>;
 };
-//# sourceMappingURL=postcss-cli-resources.d.ts.map

package/{src → dist/src}/utils/webpack/plugins/scripts-webpack-plugin.d.ts

@@ -15,4 +15,3 @@ export declare class ScriptsWebpackPlugin {
     private _insertOutput;
     apply(compiler: webpack.Compiler): void;
 }
-//# sourceMappingURL=scripts-webpack-plugin.d.ts.map

package/{src → dist/src}/utils/webpack/read-webpack-options.d.ts

@@ -9,4 +9,3 @@ import { Configuration } from 'webpack';
  * @param webpackConfig
  */
 export declare function readWebpackOptions(webpackConfig: unknown): Promise<Configuration[]>;
-//# sourceMappingURL=read-webpack-options.d.ts.map