@nx/angular 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

package/src/generators/application/application.js

@@ -6,13 +6,18 @@ const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-projec
 const js_1 = require("@nx/js");
 const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 const init_1 = require("../init/init");
+const convert_to_rspack_1 = require("../convert-to-rspack/convert-to-rspack");
 const setup_ssr_1 = require("../setup-ssr/setup-ssr");
 const setup_tailwind_1 = require("../setup-tailwind/setup-tailwind");
 const ensure_angular_dependencies_1 = require("../utils/ensure-angular-dependencies");
 const lib_1 = require("./lib");
 async function applicationGenerator(tree, schema) {
     (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(tree, 'angular', 'application');
-    const options = await (0, lib_1.normalizeOptions)(tree, schema);
+    const isRspack = schema.bundler === 'rspack';
+    if (isRspack) {
+        schema.bundler = 'webpack';
+    }
+    const options = await (0, lib_1.normalizeOptions)(tree, schema, isRspack);
     const rootOffset = (0, devkit_1.offsetFromRoot)(options.appProjectRoot);
     await (0, js_1.initGenerator)(tree, {
         ...options,
@@ -23,6 +28,7 @@ async function applicationGenerator(tree, schema) {
     await (0, init_1.angularInitGenerator)(tree, {
         ...options,
         skipFormat: true,
+        addPlugin: options.addPlugin,
     });
     if (!options.skipPackageJson) {
         (0, ensure_angular_dependencies_1.ensureAngularDependencies)(tree);
@@ -64,6 +70,19 @@ async function applicationGenerator(tree, schema) {
             serverRouting: options.serverRouting,
         });
     }
+    if (isRspack) {
+        await (0, convert_to_rspack_1.convertToRspack)(tree, {
+            project: options.name,
+            skipInstall: options.skipPackageJson,
+            skipFormat: true,
+        });
+        if (options.ssr) {
+            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/rspack-ssr'), options.appProjectSourceRoot, {
+                pathToDistFolder: (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(options.appProjectRoot), options.outputPath, 'browser'),
+                tmpl: '',
+            });
+        }
+    }
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

package/src/generators/application/files/rspack-ssr/server.ts__tmpl__

@@ -0,0 +1,72 @@
+import 'zone.js/node';
+
+import { APP_BASE_HREF } from '@angular/common';
+import { CommonEngine } from '@angular/ssr/node';
+import * as express from 'express';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import bootstrap from './main.server';
+
+// The Express app is exported so that it can be used by serverless Functions.
+export function app(): express.Express {
+  const server = express();
+  const distFolder = join(process.cwd(), "<%= pathToDistFolder %>");
+  const indexHtml = existsSync(join(distFolder, 'index.original.html'))
+    ? join(distFolder, 'index.original.html')
+    : join(distFolder, 'index.html');
+
+  const commonEngine = new CommonEngine();
+
+  server.set('view engine', 'html');
+  server.set('views', distFolder);
+
+  // Example Express Rest API endpoints
+  // server.get('/api/**', (req, res) => { });
+  // Serve static files from /browser
+  server.get(
+    '*.*',
+    express.static(distFolder, {
+      maxAge: '1y',
+    })
+  );
+
+  // All regular routes use the Angular engine
+  server.get('*', (req, res, next) => {
+    const { protocol, originalUrl, baseUrl, headers } = req;
+
+    commonEngine
+      .render({
+        bootstrap,
+        documentFilePath: indexHtml,
+        url: `${protocol}://${headers.host}${originalUrl}`,
+        publicPath: distFolder,
+        providers: [{ provide: APP_BASE_HREF, useValue: baseUrl }],
+      })
+      .then((html) => res.send(html))
+      .catch((err) => next(err));
+  });
+
+  return server;
+}
+
+function run(): void {
+  const port = process.env['PORT'] || 4000;
+
+  // Start up the Node server
+  const server = app();
+  server.listen(port, () => {
+    console.log(`Node Express server listening on http://localhost:${port}`);
+  });
+}
+
+// Webpack will replace 'require' with '__webpack_require__'
+// '__non_webpack_require__' is a proxy to Node 'require'
+// The below code is to ensure that the server is run only when not requiring the bundle.
+declare const __non_webpack_require__: NodeRequire;
+const mainModule = __non_webpack_require__.main;
+const moduleFilename = (mainModule && mainModule.filename) || '';
+if (moduleFilename === __filename || moduleFilename.includes('iisnode')) {
+  run();
+}
+
+export default bootstrap;

package/src/generators/application/lib/add-e2e.js

@@ -3,12 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addE2e = addE2e;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../../utils/versions");
-const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 async function addE2e(tree, options) {
     // since e2e are separate projects, default to adding plugins
     const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
+    const addPlugin = nxJson['useInferencePlugins'] !== false &&
+        process.env.NX_ADD_PLUGINS !== 'false';
     const e2eWebServerInfo = getAngularE2EWebServerInfo(tree, options.name, options.port);
     if (options.e2eTestRunner === 'cypress') {
         const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
@@ -37,9 +36,6 @@ async function addE2e(tree, options) {
             rootProject: options.rootProject,
             addPlugin,
         });
-        if (addPlugin) {
-            await (0, target_defaults_utils_1.addE2eCiTargetDefaults)(tree, '@nx/cypress/plugin', '^build', (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'cypress.config.ts'));
-        }
     }
     else if (options.e2eTestRunner === 'playwright') {
         const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/playwright', versions_1.nxVersion);
@@ -63,9 +59,6 @@ async function addE2e(tree, options) {
             rootProject: options.rootProject,
             addPlugin,
         });
-        if (addPlugin) {
-            await (0, target_defaults_utils_1.addE2eCiTargetDefaults)(tree, '@nx/playwright/plugin', '^build', (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'playwright.config.ts'));
-        }
     }
     return e2eWebServerInfo.e2ePort;
 }

package/src/generators/application/lib/add-linting.js

@@ -16,5 +16,6 @@ async function addLinting(host, options) {
         skipPackageJson: options.skipPackageJson,
         unitTestRunner: options.unitTestRunner,
         skipFormat: true,
+        addPlugin: options.addPlugin,
     });
 }

package/src/generators/application/lib/add-serve-static-target.js

@@ -13,6 +13,7 @@ function addFileServerTarget(tree, options, targetName, e2ePort) {
     const isUsingApplicationBuilder = options.bundler === 'esbuild';
     const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.name);
     projectConfig.targets[targetName] = {
+        continuous: true,
         executor: '@nx/web:file-server',
         options: {
             buildTarget: `${options.name}:build`,

package/src/generators/application/lib/add-unit-test-runner.js

@@ -12,6 +12,7 @@ async function addUnitTestRunner(host, options) {
                 projectRoot: options.appProjectRoot,
                 skipPackageJson: options.skipPackageJson,
                 strict: options.strict,
+                addPlugin: options.addPlugin,
             });
             break;
         case test_runners_1.UnitTestRunner.Vitest:
@@ -20,6 +21,7 @@ async function addUnitTestRunner(host, options) {
                 projectRoot: options.appProjectRoot,
                 skipPackageJson: options.skipPackageJson,
                 strict: options.strict,
+                addPlugin: options.addPlugin,
             });
             break;
     }

package/src/generators/application/lib/create-project.js

@@ -82,6 +82,7 @@ function createProject(tree, options) {
                 defaultConfiguration: 'production',
             },
             serve: {
+                continuous: true,
                 executor: '@angular-devkit/build-angular:dev-server',
                 options: options.port
                     ? {

package/src/generators/application/lib/normalize-options.d.ts

@@ -1,4 +1,4 @@
 import { type Tree } from '@nx/devkit';
 import type { Schema } from '../schema';
 import type { NormalizedSchema } from './normalized-schema';
-export declare function normalizeOptions(host: Tree, options: Partial<Schema>): Promise<NormalizedSchema>;
+export declare function normalizeOptions(host: Tree, options: Partial<Schema>, isRspack?: boolean): Promise<NormalizedSchema>;

package/src/generators/application/lib/normalize-options.js

@@ -5,8 +5,13 @@ const devkit_1 = require("@nx/devkit");
 const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
 const eslint_1 = require("@nx/eslint");
 const test_runners_1 = require("../../../utils/test-runners");
-async function normalizeOptions(host, options) {
-    await (0, project_name_and_root_utils_1.ensureProjectName)(host, options, 'application');
+function arePluginsExplicitlyDisabled(host) {
+    const { useInferencePlugins } = (0, devkit_1.readNxJson)(host);
+    const addPluginEnvVar = process.env.NX_ADD_PLUGINS;
+    return useInferencePlugins === false || addPluginEnvVar === 'false';
+}
+async function normalizeOptions(host, options, isRspack) {
+    await (0, project_name_and_root_utils_1.ensureRootProjectName)(options, 'application');
     const { projectName: appProjectName, projectRoot: appProjectRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
         name: options.name,
         projectType: 'application',
@@ -20,8 +25,10 @@ async function normalizeOptions(host, options) {
         ? options.tags.split(',').map((s) => s.trim())
         : [];
     const bundler = options.bundler ?? 'esbuild';
+    const addPlugin = options.addPlugin ?? (!arePluginsExplicitlyDisabled(host) && isRspack);
     // Set defaults and then overwrite with user options
     return {
+        addPlugin,
         style: 'css',
         routing: true,
         inlineStyle: false,

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

@@ -20,15 +20,15 @@ export interface Schema {
   e2eTestRunner?: E2eTestRunner;
   backendProject?: string;
   strict?: boolean;
-  standaloneConfig?: boolean;
   port?: number;
   setParserOptionsProject?: boolean;
   skipPackageJson?: boolean;
   standalone?: boolean;
   rootProject?: boolean;
   minimal?: boolean;
-  bundler?: 'webpack' | 'esbuild';
+  bundler?: 'webpack' | 'esbuild' | 'rspack';
   ssr?: boolean;
   serverRouting?: boolean;
   nxCloudToken?: string;
+  addPlugin?: boolean;
 }

package/src/generators/application/schema.json

@@ -130,12 +130,6 @@
       "description": "Create an application with stricter type checking and build optimization options.",
       "default": true
     },
-    "standaloneConfig": {
-      "description": "Split the project configuration into `<projectRoot>/project.json` rather than including it inside `workspace.json`.",
-      "type": "boolean",
-      "default": true,
-      "x-deprecated": "Nx only supports standaloneConfig"
-    },
     "port": {
       "type": "number",
       "description": "The port at which the remote application should be served."
@@ -171,7 +165,7 @@
     "bundler": {
       "description": "Bundler to use to build the application.",
       "type": "string",
-      "enum": ["esbuild", "webpack"],
+      "enum": ["esbuild", "rspack", "webpack"],
       "default": "esbuild",
       "x-prompt": "Which bundler do you want to use to build the application?",
       "x-priority": "important"

package/src/generators/component-test/component-test.js

@@ -6,7 +6,7 @@ const versions_1 = require("../../utils/versions");
 const storybook_inputs_1 = require("../utils/storybook-ast/storybook-inputs");
 async function componentTestGenerator(tree, options) {
     (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
-    const { assertMinimumCypressVersion } = require('@nx/cypress/src/utils/cypress-version');
+    const { assertMinimumCypressVersion } = require('@nx/cypress/src/utils/versions');
     assertMinimumCypressVersion(10);
     const { root } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const componentDirPath = (0, devkit_1.joinPathFragments)(root, options.componentDir);

package/src/generators/convert-to-rspack/convert-to-rspack.d.ts

@@ -0,0 +1,4 @@
+import { type Tree, GeneratorCallback } from '@nx/devkit';
+import type { ConvertToRspackSchema } from './schema';
+export declare function convertToRspack(tree: Tree, schema: ConvertToRspackSchema): Promise<GeneratorCallback>;
+export default convertToRspack;

package/src/generators/convert-to-rspack/convert-to-rspack.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToRspack = convertToRspack;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const create_config_1 = require("./lib/create-config");
+const get_custom_webpack_config_1 = require("./lib/get-custom-webpack-config");
+const update_tsconfig_1 = require("./lib/update-tsconfig");
+const validate_supported_executor_1 = require("./lib/validate-supported-executor");
+const posix_1 = require("path/posix");
+const path_1 = require("path");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const enquirer_1 = require("enquirer");
+const SUPPORTED_EXECUTORS = [
+    '@angular-devkit/build-angular:browser',
+    '@angular-devkit/build-angular:dev-server',
+    '@angular-devkit/build-angular:server',
+    '@nx/angular:webpack-browser',
+    '@nx/angular:webpack-server',
+    '@nx/angular:dev-server',
+    '@nx/angular:module-federation-dev-server',
+];
+const RENAMED_OPTIONS = {
+    main: 'browser',
+    ngswConfigPath: 'serviceWorker',
+};
+const REMOVED_OPTIONS = ['buildOptimizer', 'buildTarget', 'browserTarget'];
+function normalizeFromProjectRoot(tree, path, projectRoot) {
+    if (projectRoot === '.') {
+        if (!path.startsWith('./')) {
+            return `./${path}`;
+        }
+        else {
+            return path;
+        }
+    }
+    else if (path.startsWith(projectRoot)) {
+        return path.replace(projectRoot, '.');
+    }
+    else if (!path.startsWith('./')) {
+        if (tree.exists(path)) {
+            const pathWithWorkspaceRoot = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, path);
+            const projectRootWithWorkspaceRoot = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot);
+            return (0, path_1.relative)(projectRootWithWorkspaceRoot, pathWithWorkspaceRoot);
+        }
+        return `./${path}`;
+    }
+    return path;
+}
+const defaultNormalizer = (tree, path, root) => normalizeFromProjectRoot(tree, path, root);
+const PATH_NORMALIZER = {
+    index: (tree, path, root) => {
+        if (typeof path === 'string') {
+            return normalizeFromProjectRoot(tree, path, root);
+        }
+        return {
+            input: normalizeFromProjectRoot(tree, path.input, root),
+            output: path.output ?? 'index.html',
+        };
+    },
+    indexHtmlTransformer: defaultNormalizer,
+    main: defaultNormalizer,
+    server: defaultNormalizer,
+    tsConfig: defaultNormalizer,
+    outputPath: (tree, path, root) => {
+        const relativePathFromWorkspaceRoot = (0, path_1.relative)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, root), devkit_1.workspaceRoot);
+        return (0, devkit_1.joinPathFragments)(relativePathFromWorkspaceRoot, path);
+    },
+    proxyConfig: defaultNormalizer,
+    polyfills: (tree, paths, root) => {
+        const normalizedPaths = [];
+        const normalizeFn = (path) => {
+            try {
+                const resolvedPath = require.resolve(path, {
+                    paths: [(0, posix_1.join)(devkit_1.workspaceRoot, 'node_modules')],
+                });
+                normalizedPaths.push(path);
+            }
+            catch {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+        };
+        if (typeof paths === 'string') {
+            normalizeFn(paths);
+        }
+        else {
+            for (const path of paths) {
+                normalizeFn(path);
+            }
+        }
+        return normalizedPaths;
+    },
+    styles: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                    bundleName: path.bundleName,
+                    inject: path.inject ?? true,
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    scripts: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                    bundleName: path.bundleName,
+                    inject: path.inject ?? true,
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    assets: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    ...path,
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    fileReplacements: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            normalizedPaths.push({
+                replace: normalizeFromProjectRoot(tree, 'src' in path ? path.src : path.replace, root),
+                with: normalizeFromProjectRoot(tree, 'replaceWith' in path ? path.replaceWith : path.with, root),
+            });
+        }
+        return normalizedPaths;
+    },
+};
+function handleBuildTargetOptions(tree, options, newConfigurationOptions, root) {
+    let customWebpackConfigPath;
+    if (!options || Object.keys(options).length === 0) {
+        return customWebpackConfigPath;
+    }
+    if (options.customWebpackConfig) {
+        customWebpackConfigPath = options.customWebpackConfig.path;
+        delete options.customWebpackConfig;
+    }
+    if (options.outputs) {
+        // handled by the Rspack inference plugin
+        delete options.outputs;
+    }
+    for (const [key, value] of Object.entries(options)) {
+        let optionName = key;
+        let optionValue = key in PATH_NORMALIZER ? PATH_NORMALIZER[key](tree, value, root) : value;
+        if (REMOVED_OPTIONS.includes(key)) {
+            continue;
+        }
+        if (key in RENAMED_OPTIONS) {
+            optionName = RENAMED_OPTIONS[key];
+        }
+        newConfigurationOptions[optionName] = optionValue;
+    }
+    if (typeof newConfigurationOptions.polyfills === 'string') {
+        newConfigurationOptions.polyfills = [newConfigurationOptions.polyfills];
+    }
+    let outputPath = newConfigurationOptions.outputPath;
+    if (typeof outputPath === 'string') {
+        if (!/\/browser\/?$/.test(outputPath)) {
+            console.warn(`The output location of the browser build has been updated from "${outputPath}" to ` +
+                `"${(0, posix_1.join)(outputPath, 'browser')}". ` +
+                'You might need to adjust your deployment pipeline or, as an alternative, ' +
+                'set outputPath.browser to "" in order to maintain the previous functionality.');
+        }
+        else {
+            outputPath = outputPath.replace(/\/browser\/?$/, '');
+        }
+        newConfigurationOptions['outputPath'] = {
+            base: outputPath,
+        };
+        if (typeof newConfigurationOptions.resourcesOutputPath === 'string') {
+            const media = newConfigurationOptions.resourcesOutputPath.replaceAll('/', '');
+            if (media && media !== 'media') {
+                newConfigurationOptions['outputPath'] = {
+                    base: outputPath,
+                    media,
+                };
+            }
+        }
+    }
+    return customWebpackConfigPath;
+}
+function handleDevServerTargetOptions(tree, options, newConfigurationOptions, root) {
+    for (const [key, value] of Object.entries(options)) {
+        let optionName = key;
+        let optionValue = key in PATH_NORMALIZER ? PATH_NORMALIZER[key](tree, value, root) : value;
+        if (REMOVED_OPTIONS.includes(key)) {
+            continue;
+        }
+        if (key in RENAMED_OPTIONS) {
+            optionName = RENAMED_OPTIONS[key];
+        }
+        newConfigurationOptions[optionName] = optionValue;
+    }
+}
+async function getProjectToConvert(tree) {
+    const projects = new Set();
+    for (const executor of SUPPORTED_EXECUTORS) {
+        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (_, project) => {
+            projects.add(project);
+        });
+    }
+    const { project } = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'project',
+        message: 'Which project would you like to convert to rspack?',
+        choices: Array.from(projects),
+    });
+    return project;
+}
+async function convertToRspack(tree, schema) {
+    let { project: projectName } = schema;
+    if (!projectName) {
+        projectName = await getProjectToConvert(tree);
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const tasks = [];
+    const createConfigOptions = {
+        root: project.root,
+    };
+    const configurationOptions = {};
+    const buildTargetNames = [];
+    const serveTargetNames = [];
+    let customWebpackConfigPath;
+    (0, validate_supported_executor_1.validateSupportedBuildExecutor)(Object.values(project.targets));
+    for (const [targetName, target] of Object.entries(project.targets)) {
+        if (target.executor === '@angular-devkit/build-angular:browser' ||
+            target.executor === '@nx/angular:webpack-browser') {
+            customWebpackConfigPath = handleBuildTargetOptions(tree, target.options, createConfigOptions, project.root);
+            if (target.configurations) {
+                for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                    configurationOptions[configurationName] = {};
+                    handleBuildTargetOptions(tree, configuration, configurationOptions[configurationName], project.root);
+                }
+            }
+            buildTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:server' ||
+            target.executor === '@nx/angular:webpack-server') {
+            createConfigOptions.ssr ??= {};
+            createConfigOptions.ssr.entry ??= normalizeFromProjectRoot(tree, target.options.main, project.root);
+            createConfigOptions.server = './src/main.server.ts';
+            buildTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:dev-server' ||
+            target.executor === '@nx/angular:dev-server' ||
+            target.executor === '@nx/angular:module-federation-dev-server') {
+            createConfigOptions.devServer = {};
+            if (target.options) {
+                handleDevServerTargetOptions(tree, target.options, createConfigOptions.devServer, project.root);
+            }
+            if (target.configurations) {
+                for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                    configurationOptions[configurationName] ??= {};
+                    configurationOptions[configurationName].devServer ??= {};
+                    handleDevServerTargetOptions(tree, configuration, configurationOptions[configurationName].devServer, project.root);
+                }
+            }
+            serveTargetNames.push(targetName);
+        }
+    }
+    const customWebpackConfigInfo = customWebpackConfigPath
+        ? await (0, get_custom_webpack_config_1.getCustomWebpackConfig)(tree, project.root, customWebpackConfigPath)
+        : undefined;
+    (0, create_config_1.createConfig)(tree, createConfigOptions, configurationOptions, customWebpackConfigInfo?.normalizedPathToCustomWebpackConfig, customWebpackConfigInfo?.isWebpackConfigFunction);
+    (0, update_tsconfig_1.updateTsconfig)(tree, project.root);
+    for (const targetName of [...buildTargetNames, ...serveTargetNames]) {
+        delete project.targets[targetName];
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+    const { rspackInitGenerator } = (0, devkit_1.ensurePackage)('@nx/rspack', versions_1.nxVersion);
+    await rspackInitGenerator(tree, {
+        addPlugin: true,
+    });
+    // This is needed to prevent a circular execution of the build target
+    const rootPkgJson = (0, devkit_1.readJson)(tree, 'package.json');
+    if (rootPkgJson.scripts?.build === 'nx build') {
+        delete rootPkgJson.scripts.build;
+        (0, devkit_1.writeJson)(tree, 'package.json', rootPkgJson);
+    }
+    if (!schema.skipInstall) {
+        const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/angular-rspack': versions_1.angularRspackVersion,
+            'ts-node': versions_1.tsNodeVersion,
+        });
+        tasks.push(installTask);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = convertToRspack;

package/src/generators/convert-to-rspack/lib/create-config.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function createConfig(tree: Tree, opts: Record<string, any>, configurationOptions?: Record<string, Record<string, any>>, existingWebpackConfigPath?: string, isExistingWebpackConfigFunction?: boolean): void;

package/src/generators/convert-to-rspack/lib/create-config.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = createConfig;
+const devkit_1 = require("@nx/devkit");
+function createConfig(tree, opts, configurationOptions = {}, existingWebpackConfigPath, isExistingWebpackConfigFunction) {
+    const { root, ...createConfigOptions } = opts;
+    const hasConfigurations = Object.keys(configurationOptions).length > 0;
+    const expandedConfigurationOptions = hasConfigurations
+        ? Object.entries(configurationOptions)
+            .map(([configurationName, configurationOptions]) => {
+            return `
+      ${configurationName}: {
+        options: {
+          ${JSON.stringify(configurationOptions, undefined, 2).slice(1, -1)}
+        }
+      }`;
+        })
+            .join(',\n')
+        : '';
+    const configContents = `
+  import { createConfig }from '@nx/angular-rspack';
+  ${existingWebpackConfigPath
+        ? `import baseWebpackConfig from '${existingWebpackConfigPath}';
+      ${isExistingWebpackConfigFunction
+            ? ''
+            : `import webpackMerge from 'webpack-merge';`}`
+        : ''}
+  
+  ${existingWebpackConfigPath ? 'const baseConfig = ' : 'export default '}createConfig({ 
+    options: {
+      root: __dirname,
+      ${JSON.stringify(createConfigOptions, undefined, 2).slice(1, -1)}
+    }
+  }${hasConfigurations ? `, {${expandedConfigurationOptions}}` : ''});
+  ${existingWebpackConfigPath
+        ? `
+    export default ${isExistingWebpackConfigFunction
+            ? `async function (env, argv) { 
+        const oldConfig = await baseWebpackConfig;
+        const browserConfig = baseConfig[0];
+        return oldConfig(browserConfig);
+        }`
+            : 'webpackMerge(baseConfig[0], baseWebpackConfig);'}
+  `
+        : ''}
+  `;
+    tree.write((0, devkit_1.joinPathFragments)(root, 'rspack.config.ts'), configContents);
+}

package/src/generators/convert-to-rspack/lib/get-custom-webpack-config.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+export declare function getCustomWebpackConfig(tree: Tree, projectRoot: string, pathToCustomWebpackConfig: string): Promise<{
+    isWebpackConfigFunction: boolean;
+    normalizedPathToCustomWebpackConfig: string;
+}>;
+export declare function convertWebpackConfigToUseNxModuleFederationPlugin(webpackConfigContents: string): string;