@nx/webpack 17.0.2 → 17.0.4

package/src/executors/webpack/schema.json

@@ -27,8 +27,7 @@
     "compiler": {
       "type": "string",
       "description": "The compiler to use.",
-      "enum": ["babel", "swc", "tsc"],
-      "default": "babel"
+      "enum": ["babel", "swc", "tsc"]
     },
     "outputPath": {
       "type": "string",
@@ -40,8 +39,7 @@
       "type": "string",
       "alias": "platform",
       "description": "Target platform for the build, same as the Webpack target option.",
-      "enum": ["node", "web", "webworker"],
-      "default": "web"
+      "enum": ["node", "web", "webworker"]
     },
     "deleteOutputPath": {
       "type": "boolean",
@@ -50,8 +48,7 @@
     },
     "watch": {
       "type": "boolean",
-      "description": "Enable re-building when files change.",
-      "default": false
+      "description": "Enable re-building when files change."
     },
     "baseHref": {
       "type": "string",
@@ -63,22 +60,18 @@
     },
     "vendorChunk": {
       "type": "boolean",
-      "description": "Use a separate bundle containing only vendor libraries.",
-      "default": true
+      "description": "Use a separate bundle containing only vendor libraries."
     },
     "commonChunk": {
       "type": "boolean",
-      "description": "Use a separate bundle containing code used across multiple bundles.",
-      "default": true
+      "description": "Use a separate bundle containing code used across multiple bundles."
     },
     "runtimeChunk": {
       "type": "boolean",
-      "description": "Use a separate bundle containing the runtime.",
-      "default": true
+      "description": "Use a separate bundle containing the runtime."
     },
     "sourceMap": {
       "description": "Output sourcemaps. Use 'hidden' for use with error reporting tools without generating sourcemap comment.",
-      "default": true,
       "oneOf": [
         {
           "type": "boolean"
@@ -90,13 +83,11 @@
     },
     "progress": {
       "type": "boolean",
-      "description": "Log progress to the console while building.",
-      "default": false
+      "description": "Log progress to the console while building."
     },
     "assets": {
       "type": "array",
       "description": "List of static application assets.",
-      "default": [],
       "items": {
         "$ref": "#/definitions/assetPattern"
       }
@@ -112,26 +103,22 @@
       "description": "External Scripts which will be included before the main application entry.",
       "items": {
         "$ref": "#/definitions/extraEntryPoint"
-      },
-      "default": []
+      }
     },
     "styles": {
       "type": "array",
       "description": "External Styles which will be included with the application",
       "items": {
         "$ref": "#/definitions/extraEntryPoint"
-      },
-      "default": []
+      }
     },
     "namedChunks": {
       "type": "boolean",
-      "description": "Names the produced bundles according to their entry file.",
-      "default": true
+      "description": "Names the produced bundles according to their entry file."
     },
     "outputHashing": {
       "type": "string",
       "description": "Define the output filename cache-busting hashing mode.",
-      "default": "none",
       "enum": ["none", "all", "media", "bundles"]
     },
     "stylePreprocessorOptions": {
@@ -143,8 +130,7 @@
           "type": "array",
           "items": {
             "type": "string"
-          },
-          "default": []
+          }
         }
       },
       "additionalProperties": false
@@ -175,13 +161,11 @@
     },
     "generatePackageJson": {
       "type": "boolean",
-      "description": "Generates a `package.json` and pruned lock file with the project's `node_module` dependencies populated for installing in a container. If a `package.json` exists in the project's directory, it will be reused with dependencies populated.",
-      "default": false
+      "description": "Generates a `package.json` and pruned lock file with the project's `node_module` dependencies populated for installing in a container. If a `package.json` exists in the project's directory, it will be reused with dependencies populated."
     },
     "transformers": {
       "type": "array",
       "description": "List of TypeScript Compiler Transfomers Plugins.",
-      "default": [],
       "aliases": ["tsPlugins"],
       "items": {
         "$ref": "#/definitions/transformerPattern"
@@ -223,18 +207,15 @@
           }
         }
       ],
-      "description": "Dependencies to keep external to the bundle. (`all` (default), `none`, or an array of module names)",
-      "default": "all"
+      "description": "Dependencies to keep external to the bundle. (`all` (default), `none`, or an array of module names)"
     },
     "extractCss": {
       "type": "boolean",
-      "description": "Extract CSS into a `.css` file.",
-      "default": true
+      "description": "Extract CSS into a `.css` file."
     },
     "subresourceIntegrity": {
       "type": "boolean",
-      "description": "Enables the use of subresource integrity validation.",
-      "default": false
+      "description": "Enables the use of subresource integrity validation."
     },
     "polyfills": {
       "type": "string",
@@ -244,28 +225,30 @@
     },
     "verbose": {
       "type": "boolean",
-      "description": "Emits verbose output",
-      "default": false
+      "description": "Emits verbose output"
     },
     "statsJson": {
       "type": "boolean",
-      "description": "Generates a 'stats.json' file which can be analyzed using tools such as: 'webpack-bundle-analyzer' or `<https://webpack.github.io/analyse>`.",
-      "default": false
+      "description": "Generates a 'stats.json' file which can be analyzed using tools such as: 'webpack-bundle-analyzer' or `<https://webpack.github.io/analyse>`."
     },
     "isolatedConfig": {
       "type": "boolean",
       "description": "Do not apply Nx webpack plugins automatically. Plugins need to be applied in the project's webpack.config.js file (e.g. withNx, withReact, etc.).",
+      "default": true,
+      "x-deprecated": "Automatic configuration of Webpack is deprecated in favor of an explicit 'webpack.config.js' file. This option will be removed in Nx 19. See https://nx.dev/recipes/webpack/webpack-config-setup."
+    },
+    "standardWebpackConfigFunction": {
+      "type": "boolean",
+      "description": "Set to true if the webpack config exports a standard webpack function, not an Nx-specific one. See: https://webpack.js.org/configuration/configuration-types/#exporting-a-function",
       "default": false
     },
     "extractLicenses": {
       "type": "boolean",
-      "description": "Extract all licenses in a separate file, in the case of production builds only.",
-      "default": false
+      "description": "Extract all licenses in a separate file, in the case of production builds only."
     },
     "memoryLimit": {
       "type": "number",
-      "description": "Memory limit for type checking service process in `MB`.",
-      "default": 2048
+      "description": "Memory limit for type checking service process in `MB`."
     },
     "fileReplacements": {
       "description": "Replace files with other files in the build.",
@@ -286,18 +269,16 @@
         },
         "additionalProperties": false,
         "required": ["replace", "with"]
-      },
-      "default": []
+      }
     },
     "buildLibsFromSource": {
       "type": "boolean",
-      "description": "Read buildable libraries from source instead of building them separately.",
+      "description": "Read buildable libraries from source instead of building them separately. If set to `false`, the `tsConfig` option must also be set to remap paths.",
       "default": true
     },
     "generateIndexHtml": {
       "type": "boolean",
-      "description": "Generates `index.html` file to the output path. This can be turned off if using a webpack plugin to generate HTML such as `html-webpack-plugin`.",
-      "default": true
+      "description": "Generates `index.html` file to the output path. This can be turned off if using a webpack plugin to generate HTML such as `html-webpack-plugin`."
     },
     "postcssConfig": {
       "type": "string",
@@ -312,8 +293,7 @@
     },
     "babelUpwardRootMode": {
       "type": "boolean",
-      "description": "Whether to set rootmode to upward. See https://babeljs.io/docs/en/options#rootmode",
-      "default": false
+      "description": "Whether to set rootmode to upward. See https://babeljs.io/docs/en/options#rootmode"
     },
     "babelConfig": {
       "type": "string",
@@ -321,7 +301,7 @@
       "x-completion-type": "file"
     }
   },
-  "required": ["tsConfig", "main"],
+  "required": [],
   "definitions": {
     "assetPattern": {
       "oneOf": [

package/src/executors/webpack/webpack.impl.js

@@ -7,40 +7,52 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const path_1 = require("path");
 const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
-const get_webpack_config_1 = require("./lib/get-webpack-config");
 const run_webpack_1 = require("./lib/run-webpack");
 const fs_1 = require("../../utils/fs");
-const custom_webpack_1 = require("../../utils/webpack/custom-webpack");
+const resolve_user_defined_webpack_config_1 = require("../../utils/webpack/resolve-user-defined-webpack-config");
 const normalize_options_1 = require("./lib/normalize-options");
-async function getWebpackConfigs(options, projectRoot, context) {
+const config_1 = require("../../utils/config");
+const with_nx_1 = require("../../utils/with-nx");
+const js_1 = require("@nx/js");
+const with_web_1 = require("../../utils/with-web");
+async function getWebpackConfigs(options, context) {
     if (options.isolatedConfig && !options.webpackConfig) {
         throw new Error(`Using "isolatedConfig" without a "webpackConfig" is not supported.`);
     }
-    let customWebpack = null;
+    let userDefinedWebpackConfig = null;
     if (options.webpackConfig) {
-        customWebpack = (0, custom_webpack_1.resolveCustomWebpackConfig)(options.webpackConfig, options.tsConfig.startsWith(context.root)
-            ? options.tsConfig
-            : (0, path_1.join)(context.root, options.tsConfig));
-        if (typeof customWebpack.then === 'function') {
-            customWebpack = await customWebpack;
+        userDefinedWebpackConfig = (0, resolve_user_defined_webpack_config_1.resolveUserDefinedWebpackConfig)(options.webpackConfig, (0, js_1.getRootTsConfigPath)());
+        if (typeof userDefinedWebpackConfig.then === 'function') {
+            userDefinedWebpackConfig = await userDefinedWebpackConfig;
         }
     }
     const config = options.isolatedConfig
         ? {}
-        : (0, get_webpack_config_1.getWebpackConfig)(context, options);
-    if (customWebpack) {
-        return await customWebpack(config, {
+        : (options.target === 'web'
+            ? (0, config_1.composePluginsSync)((0, with_nx_1.withNx)(options), (0, with_web_1.withWeb)(options))
+            : (0, with_nx_1.withNx)(options))({}, { options, context });
+    if (typeof userDefinedWebpackConfig === 'function' &&
+        ((0, config_1.isNxWebpackComposablePlugin)(userDefinedWebpackConfig) ||
+            !options.standardWebpackConfigFunction)) {
+        // Old behavior, call the Nx-specific webpack config function that user exports
+        return await userDefinedWebpackConfig(config, {
             options,
             context,
             configuration: context.configurationName, // backwards compat
         });
     }
+    else if (userDefinedWebpackConfig) {
+        // New behavior, we want the webpack config to export object
+        return userDefinedWebpackConfig;
+    }
     else {
-        // If the user has no webpackConfig specified then we always have to apply
+        // Fallback case, if we cannot find a webpack config path
         return config;
     }
 }
 async function* webpackExecutor(_options, context) {
+    // Default to production build.
+    process.env['NODE_ENV'] ||= 'production';
     const metadata = context.projectsConfigurations.projects[context.projectName];
     const sourceRoot = metadata.sourceRoot;
     const options = (0, normalize_options_1.normalizeOptions)(_options, context.root, metadata.root, sourceRoot);
@@ -52,6 +64,12 @@ async function* webpackExecutor(_options, context) {
     process.env.NODE_ENV ||= isScriptOptimizeOn
         ? 'production'
         : 'development';
+    process.env.NX_BUILD_LIBS_FROM_SOURCE = `${options.buildLibsFromSource}`;
+    process.env.NX_BUILD_TARGET = (0, devkit_1.targetToTargetString)({
+        project: context.projectName,
+        target: context.targetName,
+        configuration: context.configurationName,
+    });
     if (options.compiler === 'swc') {
         try {
             require.resolve('swc-loader');
@@ -61,7 +79,6 @@ async function* webpackExecutor(_options, context) {
             devkit_1.logger.error(`Missing SWC dependencies: @swc/core, swc-loader. Make sure you install them first.`);
             return {
                 success: false,
-                outfile: (0, path_1.resolve)(context.root, options.outputPath, options.outputFileName),
                 options,
             };
         }
@@ -69,16 +86,17 @@ async function* webpackExecutor(_options, context) {
     if (!options.buildLibsFromSource && context.targetName) {
         const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
         options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, context.root, metadata.root, dependencies);
+        process.env.NX_TSCONFIG_PATH = options.tsConfig;
     }
     // Delete output path before bundling
-    if (options.deleteOutputPath) {
+    if (options.deleteOutputPath && options.outputPath) {
         (0, fs_1.deleteOutputDir)(context.root, options.outputPath);
     }
     if (options.generatePackageJson && metadata.projectType !== 'application') {
         devkit_1.logger.warn((0, devkit_1.stripIndents) `The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.
         For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks).`);
     }
-    const configs = await getWebpackConfigs(options, metadata.root, context);
+    const configs = await getWebpackConfigs(options, context);
     return yield* (0, rxjs_for_await_1.eachValueFrom)((0, rxjs_1.of)(configs).pipe((0, operators_1.mergeMap)((config) => (Array.isArray(config) ? (0, rxjs_1.from)(config) : (0, rxjs_1.of)(config))), 
     // Run build sequentially and bail when first one fails.
     (0, operators_1.mergeScan)((acc, config) => {
@@ -94,6 +112,8 @@ async function* webpackExecutor(_options, context) {
     // Collect build results as an array.
     (0, operators_1.bufferCount)(Array.isArray(configs) ? configs.length : 1), (0, operators_1.switchMap)(async (results) => {
         const success = results.every((result) => Boolean(result) && !result.hasErrors());
+        // TODO(jack): This should read output from webpack config if provided.
+        // The outfile is only used by NestJS, where `@nx/js:node` executor requires it to run the file.
         return {
             success,
             outfile: (0, path_1.resolve)(context.root, options.outputPath, options.outputFileName),

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

@@ -1,4 +1,5 @@
-import type { Tree } from '@nx/devkit';
+import { GeneratorCallback, Tree } from '@nx/devkit';
 import { ConfigurationGeneratorSchema } from './schema';
-export declare function configurationGenerator(tree: Tree, options: ConfigurationGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;
+export declare function configurationGenerator(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
+export declare function configurationGeneratorInternal(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
 export default configurationGenerator;

package/src/generators/configuration/configuration.js

@@ -1,24 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configurationGenerator = void 0;
+exports.configurationGeneratorInternal = exports.configurationGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
 const init_1 = require("../init/init");
-async function configurationGenerator(tree, options) {
-    const task = await (0, init_1.webpackInitGenerator)(tree, {
+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);
-    addBuildTarget(tree, options);
-    if (options.devServer) {
-        addServeTarget(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 task;
+    return (0, devkit_1.runTasksInSerial)(...tasks);
 }
-exports.configurationGenerator = configurationGenerator;
+exports.configurationGeneratorInternal = configurationGeneratorInternal;
 function checkForTargetConflicts(tree, options) {
     if (options.skipValidation)
         return;
@@ -30,7 +50,7 @@ function checkForTargetConflicts(tree, options) {
         throw new Error(`Project "${project.name}" already has a serve target. Pass --skipValidation to ignore this error.`);
     }
 }
-function addBuildTarget(tree, options) {
+function createWebpackConfig(tree, options) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const buildOptions = {
         target: options.target,
@@ -40,20 +60,28 @@ function addBuildTarget(tree, options) {
         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'],
-        });
-    }
     if (options.target === 'web') {
-        tree.write((0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'), `
+        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.
@@ -65,7 +93,27 @@ module.exports = composePlugins(withNx(), withWeb(), (config) => {
 `);
     }
     else {
-        tree.write((0, devkit_1.joinPathFragments)(project.root, 'webpack.config.js'), `
+        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.
@@ -76,6 +124,30 @@ module.exports = composePlugins(withNx(), (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: {

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

@@ -10,4 +10,5 @@ export interface ConfigurationGeneratorSchema {
   target?: 'node' | 'web' | 'webworker';
   webpackConfig?: string;
   babelConfig?: string;
+  addPlugin?: boolean;
 }

package/src/generators/configuration/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxWebpackProject",
   "cli": "nx",
   "title": "Add Webpack Configuration to a project",

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

@@ -1,4 +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

@@ -1,35 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webpackInitGenerator = void 0;
+exports.webpackInitGeneratorInternal = exports.webpackInitGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
-const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+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");
-async function webpackInitGenerator(tree, schema) {
-    const tasks = [];
-    const devDependencies = {
-        '@nx/webpack': versions_1.nxVersion,
-    };
-    if (schema.compiler === 'swc') {
-        devDependencies['swc-loader'] = versions_1.swcLoaderVersion;
-        const addSwcTask = (0, add_swc_dependencies_1.addSwcDependencies)(tree);
-        tasks.push(addSwcTask);
+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);
     }
-    if (schema.compiler === 'tsc') {
-        devDependencies['tslib'] = versions_1.tsLibVersion;
+    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.uiFramework === 'react') {
-        devDependencies['@pmmmwh/react-refresh-webpack-plugin'] =
-            versions_1.reactRefreshWebpackPluginVersion;
-        devDependencies['@svgr/webpack'] = versions_1.svgrWebpackVersion;
-        devDependencies['react-refresh'] = versions_1.reactRefreshVersion;
-        devDependencies['url-loader'] = versions_1.urlLoaderVersion;
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(tree, plugin_1.createNodes);
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
-    const baseInstalTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies);
-    tasks.push(baseInstalTask);
-    return (0, devkit_1.runTasksInSerial)(...tasks);
+    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.webpackInitGenerator = webpackInitGenerator;
 exports.default = webpackInitGenerator;

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

@@ -1,5 +1,7 @@
 export interface Schema {
-  compiler?: 'babel' | 'swc' | 'tsc';
-  uiFramework?: 'react' | 'none';
   skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+  addPlugin?: boolean;
 }