@nx/rspack 20.2.0-beta.2 → 20.2.0-beta.3

package/app-plugin.d.ts

@@ -0,0 +1,2 @@
+export { NxAppRspackPlugin } from './src/plugins/nx-app-rspack-plugin/nx-app-rspack-plugin';
+export type { NxAppRspackPluginOptions } from './src/plugins/utils/models';

package/app-plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxAppRspackPlugin = void 0;
+var nx_app_rspack_plugin_1 = require("./src/plugins/nx-app-rspack-plugin/nx-app-rspack-plugin");
+Object.defineProperty(exports, "NxAppRspackPlugin", { enumerable: true, get: function () { return nx_app_rspack_plugin_1.NxAppRspackPlugin; } });

package/generators.json

@@ -31,6 +31,16 @@
       "factory": "./src/generators/convert-webpack/convert-webpack",
       "schema": "./src/generators/convert-webpack/schema.json",
       "description": "Convert a webpack application to use rspack."
+    },
+    "convert-config-to-rspack-plugin": {
+      "factory": "./src/generators/convert-config-to-rspack-plugin/convert-config-to-rspack-plugin",
+      "schema": "./src/generators/convert-config-to-rspack-plugin/schema.json",
+      "description": "Convert the project to use the `NxAppRspackPlugin` and `NxReactRspackPlugin`."
+    },
+    "convert-to-inferred": {
+      "factory": "./src/generators/convert-to-inferred/convert-to-inferred#convertToInferred",
+      "schema": "./src/generators/convert-to-inferred/schema.json",
+      "description": "Convert existing Rspack project(s) using `@nx/rspack:rspack` executor to use `@nx/rspack/plugin`."
     }
   }
 }

package/migrations.json

@@ -1,5 +1,12 @@
 {
-  "generators": {},
+  "generators": {
+    "update-20-2-0-update-with-module-federation-import": {
+      "cli": "nx",
+      "version": "20.2.0-beta.3",
+      "description": "Update the withModuleFederation import use @nx/module-federation/rspack.",
+      "factory": "./src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package"
+    }
+  },
   "packageJsonUpdates": {
     "18.1.0": {
       "version": "18.1.0-beta.0",
@@ -68,6 +75,19 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "20.2.0": {
+      "version": "20.2.0-beta.3",
+      "packages": {
+        "@rspack/core": {
+          "version": "^1.1.2",
+          "alwaysAddToPackageJson": false
+        },
+        "@rspack/dev-server": {
+          "version": "^1.0.9",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   },
   "version": "0.1"

package/module-federation.d.ts

@@ -1 +1,4 @@
-export * from './src/utils/module-federation/public-api';
+/**
+ * @deprecated Use `@nx/module-federation/rspack` instead. This will be removed in Nx v22.
+ */
+export { withModuleFederation, withModuleFederationForSSR, } from '@nx/module-federation/rspack';

package/module-federation.js

@@ -1,4 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./src/utils/module-federation/public-api"), exports);
+exports.withModuleFederationForSSR = exports.withModuleFederation = void 0;
+/**
+ * @deprecated Use `@nx/module-federation/rspack` instead. This will be removed in Nx v22.
+ */
+var rspack_1 = require("@nx/module-federation/rspack");
+Object.defineProperty(exports, "withModuleFederation", { enumerable: true, get: function () { return rspack_1.withModuleFederation; } });
+Object.defineProperty(exports, "withModuleFederationForSSR", { enumerable: true, get: function () { return rspack_1.withModuleFederationForSSR; } });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/rspack",
   "description": "The Nx Plugin for Rspack contains executors and generators that support building applications using Rspack.",
-  "version": "20.2.0-beta.2",
+  "version": "20.2.0-beta.3",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -24,12 +24,13 @@
   "generators": "./generators.json",
   "executors": "./executors.json",
   "dependencies": {
-    "@nx/js": "20.2.0-beta.2",
-    "@nx/devkit": "20.2.0-beta.2",
-    "@nx/web": "20.2.0-beta.2",
+    "@nx/js": "20.2.0-beta.3",
+    "@nx/devkit": "20.2.0-beta.3",
+    "@nx/web": "20.2.0-beta.3",
+    "@nx/module-federation": "20.2.0-beta.3",
     "@phenomnomnominal/tsquery": "~5.0.1",
-    "@rspack/core": "^1.0.4",
-    "@rspack/dev-server": "^1.0.4",
+    "@rspack/core": "^1.1.2",
+    "@rspack/dev-server": "^1.0.9",
     "@rspack/plugin-react-refresh": "^1.0.0",
     "autoprefixer": "^10.4.9",
     "browserslist": "^4.21.4",
@@ -50,11 +51,12 @@
     "postcss-loader": "^8.1.1",
     "postcss": "^8.4.38",
     "tslib": "^2.3.0",
+    "webpack": "^5.80.0",
     "webpack-node-externals": "^3.0.0"
   },
   "peerDependencies": {
-    "@module-federation/enhanced": "~0.6.0",
-    "@module-federation/node": "~2.5.10"
+    "@module-federation/enhanced": "~0.7.6",
+    "@module-federation/node": "~2.6.11"
   },
   "nx-migrations": {
     "migrations": "./migrations.json"

package/react-plugin.d.ts

@@ -0,0 +1 @@
+export { NxReactRspackPlugin } from './src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin';

package/react-plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxReactRspackPlugin = void 0;
+var nx_react_rspack_plugin_1 = require("./src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin");
+Object.defineProperty(exports, "NxReactRspackPlugin", { enumerable: true, get: function () { return nx_react_rspack_plugin_1.NxReactRspackPlugin; } });

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.js

@@ -8,10 +8,8 @@ const file_server_impl_1 = tslib_1.__importDefault(require("@nx/web/src/executor
 const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
 const fs_1 = require("fs");
 const path_1 = require("path");
-const module_federation_1 = require("../../utils/module-federation");
+const utils_1 = require("@nx/module-federation/src/utils");
 const build_static_remotes_1 = require("../../utils/module-federation/build-static.remotes");
-const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
-const start_remote_proxies_1 = require("../../utils/module-federation/start-remote-proxies");
 const dev_server_impl_1 = tslib_1.__importDefault(require("../dev-server/dev-server.impl"));
 function getBuildOptions(buildTarget, context) {
     const target = (0, devkit_1.parseTargetString)(buildTarget, context);
@@ -121,9 +119,9 @@ async function* moduleFederationDevServer(options, context) {
     if (!options.isInitialHost) {
         return yield* currIter;
     }
-    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, p.root, 'react');
+    const moduleFederationConfig = (0, utils_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, p.root, 'react');
     const remoteNames = options.devRemotes?.map((r) => typeof r === 'string' ? r : r.remoteName);
-    const remotes = (0, module_federation_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
+    const remotes = (0, utils_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
         projectName: context.projectName,
         projectGraph: context.projectGraph,
         root: context.root,
@@ -134,11 +132,11 @@ async function* moduleFederationDevServer(options, context) {
         ...(remotes.devRemotes.map((r) => typeof r === 'string' ? r : r.remoteName) ?? []).map((r) => r.replace(/-/g, '_')),
         p.name.replace(/-/g, '_'),
     ]);
-    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    const staticRemotesConfig = (0, utils_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
     const mappedLocationsOfStaticRemotes = await (0, build_static_remotes_1.buildStaticRemotes)(staticRemotesConfig, nxBin, context, options);
     const devRemoteIters = await startRemotes(remotes.devRemotes, context, options, 'serve');
     const staticRemotesIter = startStaticRemotesFileServer(staticRemotesConfig, context, options);
-    (0, start_remote_proxies_1.startRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
+    (0, utils_1.startRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
         ? {
             pathToCert: (0, path_1.join)(devkit_1.workspaceRoot, options.sslCert),
             pathToKey: (0, path_1.join)(devkit_1.workspaceRoot, options.sslKey),

package/src/executors/module-federation-ssr-dev-server/module-federation-ssr-dev-server.impl.js

@@ -4,16 +4,14 @@ exports.default = moduleFederationSsrDevServer;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
-const module_federation_1 = require("../../utils/module-federation");
+const utils_1 = require("@nx/module-federation/src/utils");
 const ssr_dev_server_impl_1 = tslib_1.__importDefault(require("../ssr-dev-server/ssr-dev-server.impl"));
 const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
-const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
 const file_server_impl_1 = tslib_1.__importDefault(require("@nx/web/src/executors/file-server/file-server.impl"));
 const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-const start_ssr_remote_proxies_1 = require("../../utils/module-federation/start-ssr-remote-proxies");
 function normalizeOptions(options) {
     return {
         ...options,
@@ -159,9 +157,9 @@ async function* moduleFederationSsrDevServer(ssrDevServerOptions, context) {
     if (!options.isInitialHost) {
         return yield* iter;
     }
-    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, projectConfig.root, 'react');
+    const moduleFederationConfig = (0, utils_1.getModuleFederationConfig)(buildOptions.tsConfig, context.root, projectConfig.root, 'react');
     const remoteNames = options.devRemotes?.map((remote) => typeof remote === 'string' ? remote : remote.remoteName);
-    const remotes = (0, module_federation_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
+    const remotes = (0, utils_1.getRemotes)(remoteNames, options.skipRemotes, moduleFederationConfig, {
         projectName: context.projectName,
         projectGraph: context.projectGraph,
         root: context.root,
@@ -171,11 +169,11 @@ async function* moduleFederationSsrDevServer(ssrDevServerOptions, context) {
         ...(remotes.devRemotes.map((r) => typeof r === 'string' ? r : r.remoteName) ?? []).map((r) => r.replace(/-/g, '_')),
         projectConfig.name.replace(/-/g, '_'),
     ]);
-    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticSsrRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    const staticRemotesConfig = (0, utils_1.parseStaticSsrRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
     const mappedLocationsOfStaticRemotes = await buildSsrStaticRemotes(staticRemotesConfig, nxBin, context, options);
     const devRemoteIters = await startRemotes(remotes.devRemotes, context, options);
     const staticRemotesIter = startSsrStaticRemotesFileServer(staticRemotesConfig, context, options);
-    (0, start_ssr_remote_proxies_1.startSsrRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
+    (0, utils_1.startSsrRemoteProxies)(staticRemotesConfig, mappedLocationsOfStaticRemotes, options.ssl
         ? {
             pathToCert: options.sslCert,
             pathToKey: options.sslKey,

package/src/executors/module-federation-static-server/module-federation-static-server.impl.d.ts

@@ -1,5 +1,5 @@
 import { ExecutorContext } from 'nx/src/config/misc-interfaces';
-import { StaticRemotesConfig } from '../../utils/module-federation/parse-static-remotes-config';
+import { StaticRemotesConfig } from '@nx/module-federation/src/utils';
 import { ModuleFederationDevServerOptions } from '../module-federation-dev-server/schema';
 import { ModuleFederationStaticServerSchema } from './schema';
 export declare function startProxies(staticRemotesConfig: StaticRemotesConfig, hostServeOptions: ModuleFederationDevServerOptions, mappedLocationOfHost: string, mappedLocationsOfRemotes: Record<string, string>, sslOptions?: {

package/src/executors/module-federation-static-server/module-federation-static-server.impl.js

@@ -10,9 +10,8 @@ const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
-const module_federation_1 = require("../../utils/module-federation");
+const utils_1 = require("@nx/module-federation/src/utils");
 const build_static_remotes_1 = require("../../utils/module-federation/build-static.remotes");
-const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
 function getBuildAndServeOptionsFromServeTarget(serveTarget, context) {
     const target = (0, devkit_1.parseTargetString)(serveTarget, context);
     const serveOptions = (0, devkit_1.readTargetOptions)(target, context);
@@ -170,13 +169,13 @@ async function* moduleFederationStaticServer(schema, context) {
     // Get the remotes from the module federation config
     const p = context.projectsConfigurations.projects[context.projectName];
     const options = getBuildAndServeOptionsFromServeTarget(schema.serveTarget, context);
-    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(options.buildOptions.tsConfig, context.root, p.root, 'react');
-    const remotes = (0, module_federation_1.getRemotes)([], options.serveOptions.skipRemotes, moduleFederationConfig, {
+    const moduleFederationConfig = (0, utils_1.getModuleFederationConfig)(options.buildOptions.tsConfig, context.root, p.root, 'react');
+    const remotes = (0, utils_1.getRemotes)([], options.serveOptions.skipRemotes, moduleFederationConfig, {
         projectName: context.projectName,
         projectGraph: context.projectGraph,
         root: context.root,
     }, options.pathToManifestFile);
-    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    const staticRemotesConfig = (0, utils_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
     options.serveOptions.staticRemotesPort ??= remotes.staticRemotePort;
     const mappedLocationsOfStaticRemotes = await (0, build_static_remotes_1.buildStaticRemotes)(staticRemotesConfig, nxBin, context, options.serveOptions);
     // Build the host

package/src/executors/rspack/schema.d.ts

@@ -28,7 +28,7 @@ export interface RspackExecutorSchema {
   progress?: boolean;
   publicPath?: string;
   rebaseRootRelative?: boolean;
-  rspackConfig: string;
+  rspackConfig?: string;
   runtimeChunk?: boolean;
   scripts?: Array<ExtraEntryPointClass | string>;
   skipTypeChecking?: boolean;

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

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertConfigToRspackPluginGenerator(tree: Tree, options: Schema): Promise<void>;
+export default convertConfigToRspackPluginGenerator;

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertConfigToRspackPluginGenerator = convertConfigToRspackPluginGenerator;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const extract_rspack_options_1 = require("./lib/extract-rspack-options");
+const normalize_path_options_1 = require("./lib/normalize-path-options");
+const path_1 = require("path");
+const validate_project_1 = require("./lib/validate-project");
+// Make text JSON compatible
+const preprocessText = (text) => {
+    return text
+        .replace(/(\w+):/g, '"$1":') // Quote property names
+        .replace(/'/g, '"') // Convert single quotes to double quotes
+        .replace(/,(\s*[}\]])/g, '$1') // Remove trailing commas
+        .replace(/(\r\n|\n|\r|\t)/gm, ''); // Remove newlines and tabs
+};
+async function convertConfigToRspackPluginGenerator(tree, options) {
+    let migrated = 0;
+    const projects = (0, devkit_1.getProjects)(tree);
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rspack:rspack', (currentTargetOptions, projectName, targetName, configurationName) => {
+        if (options.project && projectName !== options.project) {
+            return;
+        }
+        if (!configurationName) {
+            const project = projects.get(projectName);
+            const target = project.targets[targetName];
+            const hasError = (0, validate_project_1.validateProject)(tree, project);
+            if (hasError) {
+                throw new Error(hasError);
+            }
+            const rspackConfigPath = currentTargetOptions?.rspackConfig || '';
+            if (rspackConfigPath && tree.exists(rspackConfigPath)) {
+                let { withNxConfig: rspackOptions, withReactConfig } = (0, extract_rspack_options_1.extractRspackOptions)(tree, rspackConfigPath);
+                // if rspackOptions === undefined
+                // withNx was not found in the rspack.config.js file so we should skip this project
+                if (rspackOptions !== undefined) {
+                    let parsedOptions = {};
+                    if (rspackOptions) {
+                        parsedOptions = JSON.parse(preprocessText(rspackOptions.getText()));
+                        parsedOptions = (0, normalize_path_options_1.normalizePathOptions)(project.root, parsedOptions);
+                    }
+                    target.options.standardRspackConfigFunction = true;
+                    (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+                    const { dir, name, ext } = (0, path_1.parse)(rspackConfigPath);
+                    tree.rename(rspackConfigPath, `${(0, devkit_1.joinPathFragments)(dir, `${name}.old${ext}`)}`);
+                    tree.write(rspackConfigPath, (0, devkit_1.stripIndents) `
+            const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+            const { NxReactRspackPlugin } = require('@nx/rspack/react-plugin');
+            const { useLegacyNxPlugin } = require('@nx/rspack');
+            
+            // This file was migrated using @nx/rspack:convert-config-to-rspack-plugin from your './rspack.config.old.js'
+            // Please check that the options here are correct as they were moved from the old rspack.config.js to this file.
+            const options = ${rspackOptions ? JSON.stringify(parsedOptions, null, 2) : '{}'};
+
+            /**
+              * @type{import('@rspack/core').RspackOptionsNormalized}
+            */
+            module.exports = async () => ({
+              plugins: [
+                ${rspackOptions
+                        ? 'new NxAppRspackPlugin(options)'
+                        : 'new NxAppRspackPlugin()'},
+                ${withReactConfig
+                        ? `new NxReactRspackPlugin(${withReactConfig.getText()})`
+                        : `new NxReactRspackPlugin({
+                  // Uncomment this line if you don't want to use SVGR
+                  // See: https://react-svgr.com/
+                  // svgr: false
+                  })`},
+                // NOTE: useLegacyNxPlugin ensures that the non-standard Rspack configuration file previously used still works.
+                // To remove its usage, move options such as "plugins" into this file as standard Rspack configuration options.
+                // To enhance configurations after Nx plugins have applied, you can add a new plugin with the \`apply\` method.
+                // e.g. \`{ apply: (compiler) => { /* modify compiler.options */ }\`
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                await useLegacyNxPlugin(require('./rspack.config.old'), options),
+              ],
+              });
+          `);
+                    migrated++;
+                }
+            }
+        }
+    });
+    if (migrated === 0) {
+        throw new Error('Could not find any projects to migrate.');
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = convertConfigToRspackPluginGenerator;

package/src/generators/convert-config-to-rspack-plugin/lib/extract-rspack-options.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+import * as ts from 'typescript';
+export declare function extractRspackOptions(tree: Tree, rspackConfigPath: string): {
+    withNxConfig: "" | ts.Node;
+    withReactConfig: "" | ts.Node;
+};

package/src/generators/convert-config-to-rspack-plugin/lib/extract-rspack-options.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRspackOptions = extractRspackOptions;
+const tslib_1 = require("tslib");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = tslib_1.__importStar(require("typescript"));
+function extractRspackOptions(tree, rspackConfigPath) {
+    const source = tree.read(rspackConfigPath).toString('utf-8');
+    const ast = tsquery_1.tsquery.ast(source);
+    const withNxQuery = 'CallExpression:has(Identifier[name="withNx"])';
+    const withReactQuery = 'CallExpression:has(Identifier[name="withReact"])';
+    const withWebQuery = 'CallExpression:has(Identifier[name="withWeb"])';
+    const withNxCall = (0, tsquery_1.tsquery)(ast, withNxQuery);
+    const withReactCall = (0, tsquery_1.tsquery)(ast, withReactQuery);
+    const withWebCall = (0, tsquery_1.tsquery)(ast, withWebQuery);
+    // If the config is empty set to empty string to avoid undefined. Undefined is used to check if the withNx exists inside of the config file.
+    let withNxConfig, withReactConfig;
+    withWebCall.forEach((node) => {
+        const argument = node.arguments[0] || '';
+        withNxConfig = argument; // Since withWeb and withNx use the same config object and both should not exist in the same file, we can reuse the withNxConfig variable.
+    });
+    withNxCall.forEach((node) => {
+        const argument = node.arguments[0] || ''; // The first argument is the config object
+        withNxConfig = argument;
+    });
+    withReactCall.forEach((node) => {
+        const argument = node.arguments[0] || '';
+        withReactConfig = argument;
+    });
+    if (withNxConfig !== undefined) {
+        // Only remove the withNx and withReact calls if they exist
+        let updatedSource = removeCallExpressions(source, [
+            'withNx',
+            'withReact',
+            'withWeb',
+        ]);
+        updatedSource = removeImportDeclarations(updatedSource, 'withNx', '@nx/rspack');
+        updatedSource = removeImportDeclarations(updatedSource, 'withWeb', '@nx/rspack');
+        updatedSource = removeImportDeclarations(updatedSource, 'withReact', '@nx/rspack');
+        tree.write(rspackConfigPath, updatedSource);
+    }
+    return { withNxConfig, withReactConfig };
+}
+function removeCallExpressions(source, functionNames) {
+    let modifiedSource = source;
+    functionNames.forEach((functionName) => {
+        const callExpressionQuery = `CallExpression:has(Identifier[name="composePlugins"]) > CallExpression:has(Identifier[name="${functionName}"])`;
+        modifiedSource = tsquery_1.tsquery.replace(modifiedSource, callExpressionQuery, () => {
+            return ''; // Removes the entire CallExpression
+        });
+    });
+    return modifiedSource;
+}
+function removeImportDeclarations(source, importName, moduleName) {
+    const sourceFile = tsquery_1.tsquery.ast(source);
+    const modifiedStatements = sourceFile.statements
+        .map((statement) => {
+        if (!ts.isVariableStatement(statement))
+            return statement;
+        const declarationList = statement.declarationList;
+        const newDeclarations = declarationList.declarations
+            .map((declaration) => {
+            if (!ts.isVariableDeclaration(declaration) ||
+                !declaration.initializer)
+                return declaration;
+            if (ts.isCallExpression(declaration.initializer) &&
+                ts.isIdentifier(declaration.initializer.expression)) {
+                const callExpr = declaration.initializer.expression;
+                if (callExpr.text === 'require' &&
+                    declaration.initializer.arguments[0]
+                        ?.getText()
+                        .replace(/['"]/g, '') === moduleName) {
+                    if (ts.isObjectBindingPattern(declaration.name)) {
+                        const bindingElements = declaration.name.elements.filter((element) => {
+                            const elementName = element.name.getText();
+                            return elementName !== importName;
+                        });
+                        if (bindingElements.length > 0) {
+                            const newBindingPattern = ts.factory.updateObjectBindingPattern(declaration.name, bindingElements);
+                            // Update the variable declaration with the new binding pattern without the specified import name
+                            return ts.factory.updateVariableDeclaration(declaration, newBindingPattern, declaration.exclamationToken, declaration.type, declaration.initializer);
+                        }
+                        else {
+                            return null; // Remove this declaration entirely if no bindings remain
+                        }
+                    }
+                }
+            }
+            return declaration;
+        })
+            .filter(Boolean);
+        if (newDeclarations.length > 0) {
+            const newDeclarationList = ts.factory.updateVariableDeclarationList(declarationList, newDeclarations);
+            return ts.factory.updateVariableStatement(statement, statement.modifiers, newDeclarationList);
+        }
+        else {
+            return null; // Remove the entire statement
+        }
+    })
+        .filter(Boolean);
+    // Use printer to format the source code and rewrite the modified
+    const newSourceFile = ts.factory.updateSourceFile(sourceFile, modifiedStatements);
+    const printer = ts.createPrinter();
+    const formattedSource = printer.printFile(newSourceFile);
+    return formattedSource;
+}

package/src/generators/convert-config-to-rspack-plugin/lib/normalize-path-options.d.ts

@@ -0,0 +1,2 @@
+import { RspackExecutorSchema } from '../../../executors/rspack/schema';
+export declare function normalizePathOptions(projectRoot: string, options: Partial<RspackExecutorSchema>): Partial<RspackExecutorSchema>;

package/src/generators/convert-config-to-rspack-plugin/lib/normalize-path-options.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePathOptions = normalizePathOptions;
+const utils_1 = require("./utils");
+const executorFieldsToNormalize = [
+    'outputPath',
+    'index',
+    'main',
+    'assets',
+    'tsConfig',
+    'styles',
+    'additionalEntryPoints',
+    'scripts',
+    'fileReplacements',
+    'postcssConfig',
+    'stylePreprocessorOptions',
+    'publicPath',
+];
+function normalizePathOptions(projectRoot, options) {
+    for (const [key, value] of Object.entries(options)) {
+        if (!executorFieldsToNormalize.includes(key)) {
+            continue;
+        }
+        options[key] = normalizePath(projectRoot, key, value);
+    }
+    return options;
+}
+function normalizePath(projectRoot, key, value) {
+    if (!value)
+        return value;
+    switch (key) {
+        case 'assets':
+            return value.map((asset) => {
+                if (typeof asset === 'string') {
+                    return (0, utils_1.toProjectRelativePath)(asset, projectRoot);
+                }
+                return {
+                    ...asset,
+                    input: (0, utils_1.toProjectRelativePath)(asset.input, projectRoot),
+                    output: (0, utils_1.toProjectRelativePath)(asset.output, projectRoot),
+                };
+            });
+        case 'styles':
+        case 'scripts':
+            return value.map((item) => {
+                if (typeof item === 'string') {
+                    return (0, utils_1.toProjectRelativePath)(item, projectRoot);
+                }
+                return {
+                    ...item,
+                    input: (0, utils_1.toProjectRelativePath)(item.input, projectRoot),
+                };
+            });
+        case 'additionalEntryPoints':
+            return value.map((entry) => {
+                return {
+                    ...entry,
+                    entryPath: (0, utils_1.toProjectRelativePath)(entry.entryPath, projectRoot),
+                };
+            });
+        case 'fileReplacements':
+            return value.map((replacement) => {
+                return {
+                    replace: (0, utils_1.toProjectRelativePath)(replacement.replace, projectRoot),
+                    with: (0, utils_1.toProjectRelativePath)(replacement.with, projectRoot),
+                };
+            });
+        default:
+            return Array.isArray(value)
+                ? value.map((item) => (0, utils_1.toProjectRelativePath)(item, projectRoot))
+                : (0, utils_1.toProjectRelativePath)(value, projectRoot);
+    }
+}

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

@@ -0,0 +1 @@
+export declare function toProjectRelativePath(path: string, projectRoot: string): string;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toProjectRelativePath = toProjectRelativePath;
+const posix_1 = require("path/posix");
+const devkit_1 = require("@nx/devkit");
+function toProjectRelativePath(path, projectRoot) {
+    if (projectRoot === '.') {
+        // workspace and project root are the same, we normalize it to ensure it
+        return path.startsWith('.') ? path : `./${path}`;
+    }
+    const relativePath = (0, posix_1.relative)((0, posix_1.resolve)(devkit_1.workspaceRoot, projectRoot), (0, posix_1.resolve)(devkit_1.workspaceRoot, path));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}

package/src/generators/convert-config-to-rspack-plugin/lib/validate-project.d.ts

@@ -0,0 +1,9 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+/**
+ * Validates the project to ensure it can be migrated
+ *
+ * @param tree The virtual file system
+ * @param project the project configuration object for the project
+ * @returns A string if there is an error, otherwise undefined
+ */
+export declare function validateProject(tree: Tree, project: ProjectConfiguration): string;

package/src/generators/convert-config-to-rspack-plugin/lib/validate-project.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProject = validateProject;
+function hasAnotherRspackConfig(tree, projectRoot) {
+    const files = tree.children(projectRoot);
+    const projectJsonString = tree.read(`${projectRoot}/project.json`, 'utf-8');
+    for (const file of files) {
+        if (file !== 'rspack.config.js' &&
+            file.endsWith('.js') &&
+            file.includes('rspack.config') &&
+            projectJsonString.includes(file) &&
+            tree.exists(`${projectRoot}/rspack.config.js`)) {
+            return 'Cannot convert a project with multiple rspack config files. Please consolidate them into a single rspack.config.js file.';
+        }
+    }
+}
+function isNestProject(project) {
+    for (const target in project.targets) {
+        if (project.targets[target].executor === '@nx/js:node') {
+            return `The project ${project.name} is using the '@nx/js:node' executor. At the moment, we do not support migrating such projects.`;
+        }
+    }
+}
+/**
+ * Validates the project to ensure it can be migrated
+ *
+ * @param tree The virtual file system
+ * @param project the project configuration object for the project
+ * @returns A string if there is an error, otherwise undefined
+ */
+function validateProject(tree, project) {
+    const containsMfeExecutor = Object.keys(project.targets).some((target) => {
+        return ['@nx/rspack:module-federation-dev-server'].includes(project.targets[target].executor);
+    });
+    if (containsMfeExecutor) {
+        return `The project ${project.name} is using Module Federation. At the moment, we don't support migrating projects that use Module Federation.`;
+    }
+    const hasAnotherConfig = hasAnotherRspackConfig(tree, project.root);
+    return hasAnotherConfig || isNestProject(project);
+}