@nx/webpack 0.0.0-pr-22179-271588f

package/src/generators/configuration/configuration.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationGeneratorInternal = exports.configurationGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const init_1 = require("../init/init");
+const has_plugin_1 = require("../../utils/has-plugin");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
+function configurationGenerator(tree, options) {
+    return configurationGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+exports.configurationGenerator = configurationGenerator;
+async function configurationGeneratorInternal(tree, options) {
+    const tasks = [];
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPluginDefault;
+    const initTask = await (0, init_1.webpackInitGenerator)(tree, {
+        ...options,
+        skipFormat: true,
+    });
+    tasks.push(initTask);
+    const depsTask = (0, ensure_dependencies_1.ensureDependencies)(tree, {
+        compiler: options.compiler === 'babel' ? undefined : options.compiler,
+    });
+    tasks.push(depsTask);
+    checkForTargetConflicts(tree, options);
+    if (!(0, has_plugin_1.hasPlugin)(tree)) {
+        addBuildTarget(tree, options);
+        if (options.devServer) {
+            addServeTarget(tree, options);
+        }
+    }
+    createWebpackConfig(tree, options);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.configurationGeneratorInternal = configurationGeneratorInternal;
+function checkForTargetConflicts(tree, options) {
+    if (options.skipValidation)
+        return;
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (project.targets?.build) {
+        throw new Error(`Project "${project.name}" already has a build target. Pass --skipValidation to ignore this error.`);
+    }
+    if (options.devServer && project.targets?.serve) {
+        throw new Error(`Project "${project.name}" already has a serve target. Pass --skipValidation to ignore this error.`);
+    }
+}
+function createWebpackConfig(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const buildOptions = {
+        target: options.target,
+        outputPath: (0, devkit_1.joinPathFragments)('dist', project.root),
+        compiler: options.compiler ?? 'swc',
+        main: options.main ?? (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts'),
+        tsConfig: options.tsConfig ?? (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.app.json'),
+        webpackConfig: (0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'),
+    };
+    if (options.target === 'web') {
+        tree.write((0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'), (0, has_plugin_1.hasPlugin)(tree)
+            ? `
+const { NxWebpackPlugin } = require('@nx/webpack');
+const { join } = require('path');
+
+module.exports = {
+  output: {
+    path: join(__dirname, '${(0, devkit_1.offsetFromRoot)(project.root)}${buildOptions.outputPath}'),
+  },
+  plugins: [
+    new NxWebpackPlugin({
+      target: '${buildOptions.target}',
+      tsConfig: '${buildOptions.tsConfig}',
+      compiler: '${buildOptions.compiler}',
+      main: '${buildOptions.main}',
+      outputHashing: '${buildOptions.target !== 'web' ? 'none' : 'all'}',
+    })
+  ],
+}
+`
+            : `
+const { composePlugins, withNx, withWeb } = require('@nx/webpack');
+
+// Nx plugins for webpack.
+module.exports = composePlugins(withNx(), withWeb(), (config) => {
+  // Update the webpack config as needed here.
+  // e.g. \`config.plugins.push(new MyPlugin())\`
+  return config;
+});
+`);
+    }
+    else {
+        tree.write((0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'), (0, has_plugin_1.hasPlugin)(tree)
+            ? `
+const { NxWebpackPlugin } = require('@nx/webpack');
+const { join } = require('path');
+
+module.exports = {
+  output: {
+    path: join(__dirname, '${(0, devkit_1.offsetFromRoot)(project.root)}${buildOptions.outputPath}'),
+  },
+  plugins: [
+    new NxWebpackPlugin({
+      target: '${buildOptions.target}',
+      tsConfig: '${buildOptions.tsConfig}',
+      compiler: '${buildOptions.compiler}',
+      main: '${buildOptions.main}',
+      outputHashing: '${buildOptions.target !== 'web' ? 'none' : 'all'}',
+    })
+  ],
+}
+`
+            : `
+const { composePlugins, withNx } = require('@nx/webpack');
+
+// Nx plugins for webpack.
+module.exports = composePlugins(withNx(), (config) => {
+  // Update the webpack config as needed here.
+  // e.g. \`config.plugins.push(new MyPlugin())\`
+  return config;
+});
+`);
+    }
+}
+function addBuildTarget(tree, options) {
+    (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/webpack:webpack');
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const buildOptions = {
+        target: options.target,
+        outputPath: (0, devkit_1.joinPathFragments)('dist', project.root),
+        compiler: options.compiler ?? 'swc',
+        main: options.main ?? (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts'),
+        tsConfig: options.tsConfig ?? (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.app.json'),
+        webpackConfig: (0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'),
+    };
+    if (options.webpackConfig) {
+        buildOptions.webpackConfig = options.webpackConfig;
+    }
+    if (options.babelConfig) {
+        buildOptions.babelConfig = options.babelConfig;
+    }
+    else if (options.compiler === 'babel') {
+        // If no babel config file is provided then write a default one, otherwise build will fail.
+        (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(project.root, '.babelrc'), {
+            presets: ['@nx/js/babel'],
+        });
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, {
+        ...project,
+        targets: {
+            ...project.targets,
+            build: {
+                executor: '@nx/webpack:webpack',
+                outputs: ['{options.outputPath}'],
+                defaultConfiguration: 'production',
+                options: buildOptions,
+                configurations: {
+                    production: {
+                        optimization: true,
+                        outputHashing: options.target === 'web' ? 'all' : 'none',
+                        sourceMap: false,
+                        namedChunks: false,
+                        extractLicenses: true,
+                        vendorChunk: false,
+                    },
+                },
+            },
+        },
+    });
+}
+function addServeTarget(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, {
+        ...project,
+        targets: {
+            ...project.targets,
+            serve: {
+                executor: '@nx/webpack:dev-server',
+                options: {
+                    buildTarget: `${options.project}:build`,
+                },
+                configurations: {
+                    production: {
+                        buildTarget: `${options.project}:build:production`,
+                    },
+                },
+            },
+        },
+    });
+}
+exports.default = configurationGenerator;

package/src/generators/configuration/schema.d.ts

@@ -0,0 +1,14 @@
+export interface ConfigurationGeneratorSchema {
+  project: string;
+  main?: string;
+  tsConfig?: string;
+  compiler?: 'babel' | 'swc' | 'tsc';
+  devServer?: boolean;
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  skipValidation?: boolean;
+  target?: 'node' | 'web' | 'webworker';
+  webpackConfig?: string;
+  babelConfig?: string;
+  addPlugin?: boolean;
+}

package/src/generators/configuration/schema.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWebpackProject",
+  "cli": "nx",
+  "title": "Add Webpack Configuration to a project",
+  "description": "Add Webpack Configuration to a project.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-dropdown": "project",
+      "x-prompt": "What is the name of the project to set up a webpack for?",
+      "x-priority": "important"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["babel", "swc", "tsc"],
+      "description": "The compiler to use to build source.",
+      "default": "swc"
+    },
+    "main": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the main entry file. Defaults to '<projectRoot>/src/main.ts'.",
+      "x-priority": "important"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the tsconfig file to build with. Defaults to '<projectRoot>/tsconfig.app.json'.",
+      "x-priority": "important"
+    },
+    "target": {
+      "type": "string",
+      "description": "Target platform for the build, same as the Webpack config option.",
+      "enum": ["node", "web", "webworker"],
+      "default": "web"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "skipValidation": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not perform any validation on existing project.",
+      "x-priority": "internal"
+    },
+    "devServer": {
+      "type": "boolean",
+      "description": "Add a serve target to run a local webpack dev-server",
+      "default": false
+    },
+    "webpackConfig": {
+      "type": "string",
+      "description": "Path relative to workspace root to a custom webpack file that takes a config object and returns an updated config.",
+      "x-priority": "internal"
+    },
+    "babelConfig": {
+      "type": "string",
+      "description": "Optionally specify a path relative to workspace root to the babel configuration file of your project.",
+      "x-completion-type": "file"
+    }
+  },
+  "required": []
+}

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

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function webpackInitGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function webpackInitGeneratorInternal(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default webpackInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackInitGeneratorInternal = exports.webpackInitGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+const versions_1 = require("../../utils/versions");
+function webpackInitGenerator(tree, schema) {
+    return webpackInitGeneratorInternal(tree, { addPlugin: false, ...schema });
+}
+exports.webpackInitGenerator = webpackInitGenerator;
+async function webpackInitGeneratorInternal(tree, schema) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    if (schema.addPlugin) {
+        addPlugin(tree);
+    }
+    let installTask = () => { };
+    if (!schema.skipPackageJson) {
+        const devDependencies = {
+            '@nx/webpack': versions_1.nxVersion,
+            '@nx/web': versions_1.nxVersion,
+        };
+        if (schema.addPlugin) {
+            devDependencies['webpack-cli'] = versions_1.webpackCliVersion;
+        }
+        installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
+    }
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+exports.webpackInitGeneratorInternal = webpackInitGeneratorInternal;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/webpack/plugin'
+            : plugin.plugin === '@nx/webpack/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/webpack/plugin',
+        options: {
+            buildTargetName: 'build',
+            serveTargetName: 'serve',
+            previewTargetName: 'preview',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.default = webpackInitGenerator;

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

@@ -0,0 +1,7 @@
+export interface Schema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWebpackInit",
+  "cli": "nx",
+  "title": "Init Webpack Plugin",
+  "description": "Initialize the Webpack Plugin.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/migrations/update-15-0-0/add-babel-inputs.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-0-0/add-babel-inputs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const add_babel_inputs_1 = require("@nx/js/src/utils/add-babel-inputs");
+async function default_1(tree) {
+    (0, add_babel_inputs_1.addBabelInputs)(tree);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-15-4-5/remove-es2015-polyfills-option.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-4-5/remove-es2015-polyfills-option.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+async function default_1(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    projects.forEach((p) => {
+        let shouldUpdate = false;
+        Object.entries(p.targets).forEach(([name, config]) => {
+            if (p.targets?.[name]?.executor === '@nrwl/webpack:webpack' &&
+                p.targets?.[name]?.options.es2015Polyfills) {
+                delete p.targets?.[name]?.options.es2015Polyfills;
+                shouldUpdate = true;
+            }
+        });
+        if (shouldUpdate) {
+            (0, devkit_1.updateProjectConfiguration)(tree, p.name, p);
+        }
+    });
+}
+exports.default = default_1;

package/src/migrations/update-15-6-3/webpack-config-setup.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-6-3/webpack-config-setup.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const path_1 = require("path");
+async function default_1(tree) {
+    // Since projects can have multiple configurations, we need to know if the default options
+    // need to be migrated or not. If so then the subsequent configurations with `webpackConfig` also need to be.
+    const defaultOptionsUpdated = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/webpack:webpack', (options, projectName, targetName, configurationName) => {
+        const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        const defaultOptions = projectConfiguration.targets[targetName].options;
+        const defaultWasUpdated = defaultOptionsUpdated.has(projectName);
+        // If default was not updated (for different configurations), we don't do anything
+        // If isolatedConfig is set, we don't need to do anything
+        // If project is React, we don't need to do anything
+        if (!defaultWasUpdated &&
+            (defaultOptions?.isolatedConfig ||
+                defaultOptions?.main?.match(/main\.(t|j)sx$/) ||
+                defaultOptions?.webpackConfig === '@nrwl/react/plugins/webpack')) {
+            return;
+        }
+        defaultOptionsUpdated.add(projectName);
+        // If this is not the base options (e.g. for development, production, or something custom),
+        // then skip it unless it specifically configures a webpackConfig file
+        if (configurationName && !options?.webpackConfig) {
+            return;
+        }
+        // If webpackConfig is set, update it with the new options
+        // If webpackConfig is not set, we need to create a new
+        // webpack.config.js file and set the path to it in the
+        // executor options
+        if (options?.webpackConfig) {
+            let oldName = options.webpackConfig;
+            if (options.webpackConfig.endsWith('.js')) {
+                oldName = options.webpackConfig.replace('.js', '.old.js');
+            }
+            if (options.webpackConfig.endsWith('.ts')) {
+                oldName = options.webpackConfig.replace('.ts', '.old.ts');
+            }
+            renameFile(tree, options.webpackConfig, oldName);
+            const justTheFileName = (0, path_1.basename)(oldName);
+            tree.write(options.webpackConfig, `
+        const { composePlugins, withNx } = require('@nrwl/webpack');
+
+        // Nx plugins for webpack.
+        module.exports = composePlugins(withNx(), (config, { options, context }) => {
+          // Note: This was added by an Nx migration.
+          // You should consider inlining the logic into this file.
+          // For more information on webpack config and Nx see:
+          // https://nx.dev/recipes/webpack/webpack-config-setup
+          return require('./${justTheFileName}')(config, context);
+        });
+        `);
+            options.isolatedConfig = true;
+            projectConfiguration.targets[targetName][configurationName ?? 'options'] = options;
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+            devkit_1.logger.info(`
+          ${options.webpackConfig} has been renamed to ${oldName} and a new ${options.webpackConfig} 
+          has been created for your project ${projectName}. 
+          You should consider inlining the logic from ${oldName} into ${options.webpackConfig}.
+          You can read our guide on how to do this here: 
+          
+          https://nx.dev/recipes/webpack/webpack-config-setup
+          `);
+        }
+        else {
+            const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+            if (!options) {
+                options = {};
+            }
+            options.webpackConfig = `${projectConfiguration.root}/webpack.config.js`;
+            options.isolatedConfig = true;
+            tree.write(options.webpackConfig, `
+        const { composePlugins, withNx } = require('@nrwl/webpack');
+      
+        // Nx plugins for webpack.
+        module.exports = composePlugins(withNx(), (config) => {
+          // Update the webpack config as needed here.
+          // e.g. config.plugins.push(new MyPlugin())
+          // For more information on webpack config and Nx see:
+          // https://nx.dev/recipes/webpack/webpack-config-setup
+          return config;
+        });
+        `);
+            projectConfiguration.targets[targetName].options = options;
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function renameFile(tree, from, to) {
+    const buffer = tree.read(from);
+    if (!buffer) {
+        return;
+    }
+    tree.write(to, buffer);
+    tree.delete(from);
+}

package/src/migrations/update-15-7-2/add-babelUpwardRootMode-flag.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-15-7-2/add-babelUpwardRootMode-flag.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/webpack:webpack', (options, projectName, targetName, _configurationName) => {
+        if (options.babelUpwardRootMode !== undefined) {
+            return;
+        }
+        const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        projectConfiguration.targets[targetName].options.babelUpwardRootMode =
+            true;
+        (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/webpack', '@nx/webpack');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-17-2-1/webpack-config-setup.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/src/migrations/update-17-2-1/webpack-config-setup.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function default_1(tree) {
+    const update = (options, projectName, targetName, configurationName) => {
+        // Only handle webpack config for default configuration
+        if (configurationName)
+            return;
+        const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        if (!options.webpackConfig && options.isolatedConfig !== false) {
+            options.webpackConfig = `${projectConfiguration.root}/webpack.config.js`;
+            tree.write(options.webpackConfig, `
+        const { composePlugins, withNx } = require('@nx/webpack');
+
+        // Nx plugins for webpack.
+        module.exports = composePlugins(withNx(), (config) => {
+          // Note: This was added by an Nx migration. Webpack builds are required to have a corresponding Webpack config file.
+          // See: https://nx.dev/recipes/webpack/webpack-config-setup
+          return config;
+        });
+        `);
+            projectConfiguration.targets[targetName].options = options;
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    };
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/webpack:webpack', update);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nrwl/webpack:webpack', update);
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;

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

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