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

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);
+}

package/src/generators/convert-config-to-rspack-plugin/schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxRspackConvertConfigToRspackPlugin",
+  "description": "Convert existing Rspack project(s) using `@nx/rspack:rspack` executor that uses `withNx` to use `NxAppRspackPlugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "title": "Convert Rspack project using withNx to NxAppRspackPlugin",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to convert from using the `@nx/rspack:rspack` executor and `withNx` plugin to use `NxAppRspackPlugin`.",
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Whether to format files at the end of the migration.",
+      "default": false
+    }
+  }
+}

package/src/generators/convert-to-inferred/__snapshots__/convert-to-inferred.spec.ts.snap

@@ -0,0 +1,268 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`convert-to-inferred all projects should migrate all projects using the rspack executors 1`] = `
+"const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+const { NxReactRspackPlugin } = require('@nx/rspack/react-plugin');
+const { useLegacyNxPlugin } = require('@nx/rspack');
+
+// These options were migrated by @nx/rspack:convert-to-inferred from
+// the project.json file and merged with the options in this file
+const configValues = {
+  build: {
+    default: {
+      outputPath: '../../dist/apps/app1',
+      index: './src/index.html',
+      main: './src/main.tsx',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/favicon.ico', './src/assets'],
+      styles: ['./src/styles.scss'],
+    },
+    development: {
+      extractLicenses: false,
+      optimization: false,
+      sourceMap: true,
+      vendorChunk: true,
+    },
+    production: {
+      fileReplacements: [
+        {
+          replace: './src/environments/environment.ts',
+          with: './src/environments/environment.prod.ts',
+        },
+      ],
+      optimization: true,
+      outputHashing: 'all',
+      sourceMap: false,
+      namedChunks: false,
+      extractLicenses: true,
+      vendorChunk: false,
+    },
+  },
+  serve: {
+    default: {
+      hmr: true,
+      server: {
+        type: 'https',
+        options: { cert: './server.crt', key: './server.key' },
+      },
+      port: 4200,
+      headers: { 'Access-Control-Allow-Origin': '*' },
+      historyApiFallback: {
+        index: '/index.html',
+        disableDotRule: true,
+        htmlAcceptHeaders: ['text/html', 'application/xhtml+xml'],
+      },
+    },
+    development: { open: true },
+    production: { hmr: false },
+  },
+};
+
+// Determine the correct configValue to use based on the configuration
+const configuration = process.env.NX_TASK_TARGET_CONFIGURATION || 'default';
+
+const buildOptions = {
+  ...configValues.build.default,
+  ...configValues.build[configuration],
+};
+const devServerOptions = {
+  ...configValues.serve.default,
+  ...configValues.serve[configuration],
+};
+
+/**
+ * @type{import('@rspack/core').RspackOptionsNormalized}
+ */
+module.exports = async () => ({
+  devServer: devServerOptions,
+  plugins: [
+    new NxAppRspackPlugin(buildOptions),
+    new NxReactRspackPlugin({
+      // Uncomment this line if you don't want to use SVGR
+      // See: https://react-svgr.com/
+      // svgr: false
+    }),
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    await useLegacyNxPlugin(require('./rspack.config.old'), buildOptions),
+  ],
+});
+"
+`;
+
+exports[`convert-to-inferred all projects should migrate all projects using the rspack executors 2`] = `
+"const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+const { NxReactRspackPlugin } = require('@nx/rspack/react-plugin');
+const { useLegacyNxPlugin } = require('@nx/rspack');
+
+// These options were migrated by @nx/rspack:convert-to-inferred from
+// the project.json file and merged with the options in this file
+const configValues = {
+  build: {
+    default: {
+      outputPath: '../../dist/apps/app2',
+      index: './src/index.html',
+      main: './src/main.tsx',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/favicon.ico', './src/assets'],
+      styles: ['./src/styles.scss'],
+    },
+    development: {
+      extractLicenses: false,
+      optimization: false,
+      sourceMap: true,
+      vendorChunk: true,
+    },
+    production: {
+      fileReplacements: [
+        {
+          replace: './src/environments/environment.ts',
+          with: './src/environments/environment.prod.ts',
+        },
+      ],
+      optimization: true,
+      outputHashing: 'all',
+      sourceMap: false,
+      namedChunks: false,
+      extractLicenses: true,
+      vendorChunk: false,
+    },
+  },
+  serve: {
+    default: {
+      hmr: true,
+      server: {
+        type: 'https',
+        options: { cert: './server.crt', key: './server.key' },
+      },
+      port: 4200,
+      headers: { 'Access-Control-Allow-Origin': '*' },
+      historyApiFallback: {
+        index: '/index.html',
+        disableDotRule: true,
+        htmlAcceptHeaders: ['text/html', 'application/xhtml+xml'],
+      },
+    },
+    development: { open: true },
+    production: { hmr: false },
+  },
+};
+
+// Determine the correct configValue to use based on the configuration
+const configuration = process.env.NX_TASK_TARGET_CONFIGURATION || 'default';
+
+const buildOptions = {
+  ...configValues.build.default,
+  ...configValues.build[configuration],
+};
+const devServerOptions = {
+  ...configValues.serve.default,
+  ...configValues.serve[configuration],
+};
+
+/**
+ * @type{import('@rspack/core').RspackOptionsNormalized}
+ */
+module.exports = async () => ({
+  devServer: devServerOptions,
+  plugins: [
+    new NxAppRspackPlugin(buildOptions),
+    new NxReactRspackPlugin({
+      // Uncomment this line if you don't want to use SVGR
+      // See: https://react-svgr.com/
+      // svgr: false
+    }),
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    await useLegacyNxPlugin(require('./rspack.config.old'), buildOptions),
+  ],
+});
+"
+`;
+
+exports[`convert-to-inferred all projects should migrate all projects using the rspack executors 3`] = `
+"const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+const { NxReactRspackPlugin } = require('@nx/rspack/react-plugin');
+const { useLegacyNxPlugin } = require('@nx/rspack');
+
+// These options were migrated by @nx/rspack:convert-to-inferred from
+// the project.json file and merged with the options in this file
+const configValues = {
+  build: {
+    default: {
+      outputPath: '../../dist/apps/app3',
+      index: './src/index.html',
+      main: './src/main.tsx',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/favicon.ico', './src/assets'],
+      styles: ['./src/styles.scss'],
+    },
+    development: {
+      extractLicenses: false,
+      optimization: false,
+      sourceMap: true,
+      vendorChunk: true,
+    },
+    production: {
+      fileReplacements: [
+        {
+          replace: './src/environments/environment.ts',
+          with: './src/environments/environment.prod.ts',
+        },
+      ],
+      optimization: true,
+      outputHashing: 'all',
+      sourceMap: false,
+      namedChunks: false,
+      extractLicenses: true,
+      vendorChunk: false,
+    },
+  },
+  serve: {
+    default: {
+      hmr: true,
+      server: {
+        type: 'https',
+        options: { cert: './server.crt', key: './server.key' },
+      },
+      port: 4200,
+      headers: { 'Access-Control-Allow-Origin': '*' },
+      historyApiFallback: {
+        index: '/index.html',
+        disableDotRule: true,
+        htmlAcceptHeaders: ['text/html', 'application/xhtml+xml'],
+      },
+    },
+    development: { open: true },
+    production: { hmr: false },
+  },
+};
+
+// Determine the correct configValue to use based on the configuration
+const configuration = process.env.NX_TASK_TARGET_CONFIGURATION || 'default';
+
+const buildOptions = {
+  ...configValues.build.default,
+  ...configValues.build[configuration],
+};
+const devServerOptions = {
+  ...configValues.serve.default,
+  ...configValues.serve[configuration],
+};
+
+/**
+ * @type{import('@rspack/core').RspackOptionsNormalized}
+ */
+module.exports = async () => ({
+  devServer: devServerOptions,
+  plugins: [
+    new NxAppRspackPlugin(buildOptions),
+    new NxReactRspackPlugin({
+      // Uncomment this line if you don't want to use SVGR
+      // See: https://react-svgr.com/
+      // svgr: false
+    }),
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    await useLegacyNxPlugin(require('./rspack.config.old'), buildOptions),
+  ],
+});
+"
+`;

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

@@ -0,0 +1,12 @@
+import { type Tree } from '@nx/devkit';
+import { logger as devkitLogger } from 'nx/src/devkit-exports';
+interface Schema {
+    project?: string;
+    skipFormat?: boolean;
+}
+export declare function convertToInferred(tree: Tree, options: Schema): Promise<import("@nx/devkit").GeneratorCallback>;
+export declare function createCollectingLogger(): typeof devkitLogger & {
+    loggedMessages: Map<string, string[]>;
+    flushLogs: (filter?: (message: string) => boolean) => void;
+};
+export {};