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

package/src/generators/convert-to-inferred/utils/build-post-target-transformer.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPostTargetTransformerFactory = buildPostTargetTransformerFactory;
+const tslib_1 = require("tslib");
+const plugin_migration_utils_1 = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = tslib_1.__importStar(require("typescript"));
+const ast_1 = require("./ast");
+function buildPostTargetTransformerFactory(migrationContext) {
+    return function buildPostTargetTransformer(target, tree, projectDetails, inferredTarget) {
+        const context = {
+            ...migrationContext,
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root,
+        };
+        const { pluginOptions, rspackConfigPath } = processOptions(target, context);
+        updateRspackConfig(tree, rspackConfigPath, pluginOptions);
+        if (target.outputs) {
+            (0, plugin_migration_utils_1.processTargetOutputs)(target, [], inferredTarget, {
+                projectName: projectDetails.projectName,
+                projectRoot: projectDetails.root,
+            });
+        }
+        return target;
+    };
+}
+function processOptions(target, context) {
+    const rspackConfig = target.options.rspackConfig;
+    delete target.options.rspackConfig;
+    const pluginOptions = {
+        default: extractPluginOptions(target.options, context),
+    };
+    if (target.configurations && Object.keys(target.configurations).length) {
+        for (const [configName, config] of Object.entries(target.configurations)) {
+            pluginOptions[configName] = extractPluginOptions(config, context, configName);
+        }
+    }
+    return { pluginOptions, rspackConfigPath: rspackConfig };
+}
+const pathOptions = new Set([
+    'index',
+    'main',
+    'outputPath',
+    'polyfills',
+    'postcssConfig',
+    'tsConfig',
+]);
+const assetsOptions = new Set(['assets', 'scripts', 'styles']);
+function extractPluginOptions(options, context, configName) {
+    const pluginOptions = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (pathOptions.has(key)) {
+            pluginOptions[key] = (0, plugin_migration_utils_1.toProjectRelativePath)(value, context.projectRoot);
+            delete options[key];
+        }
+        else if (assetsOptions.has(key)) {
+            pluginOptions[key] = value.map((asset) => {
+                if (typeof asset === 'string') {
+                    return (0, plugin_migration_utils_1.toProjectRelativePath)(asset, context.projectRoot);
+                }
+                asset.input = (0, plugin_migration_utils_1.toProjectRelativePath)(asset.input, context.projectRoot);
+                return asset;
+            });
+            delete options[key];
+        }
+        else if (key === 'fileReplacements') {
+            pluginOptions.fileReplacements = value.map((replacement) => ({
+                replace: (0, plugin_migration_utils_1.toProjectRelativePath)(replacement.replace, context.projectRoot),
+                with: (0, plugin_migration_utils_1.toProjectRelativePath)(replacement.with, context.projectRoot),
+            }));
+            delete options.fileReplacements;
+        }
+        else if (key === 'additionalEntryPoints') {
+            pluginOptions.additionalEntryPoints = value.map((entryPoint) => {
+                entryPoint.entryPath = (0, plugin_migration_utils_1.toProjectRelativePath)(entryPoint.entryPath, context.projectRoot);
+                return entryPoint;
+            });
+            delete options.additionalEntryPoints;
+        }
+        else if (key === 'memoryLimit') {
+            pluginOptions.memoryLimit = value;
+            const serveMemoryLimit = getMemoryLimitFromServeTarget(context, configName);
+            if (serveMemoryLimit) {
+                pluginOptions.memoryLimit = Math.max(serveMemoryLimit, value);
+                context.logger.addLog({
+                    executorName: '@nx/rspack:rspack',
+                    log: `The "memoryLimit" option was set in both the serve and build configurations. The migration set the higher value to the build configuration and removed the option from the serve configuration.`,
+                    project: context.projectName,
+                });
+            }
+            delete options.memoryLimit;
+        }
+        else if (key === 'standardRspackConfigFunction') {
+            delete options.standardRspackConfigFunction;
+        }
+        else {
+            pluginOptions[key] = value;
+            delete options[key];
+        }
+    }
+    return pluginOptions;
+}
+function updateRspackConfig(tree, rspackConfig, pluginOptions) {
+    let sourceFile;
+    let rspackConfigText;
+    const updateSources = () => {
+        rspackConfigText = tree.read(rspackConfig, 'utf-8');
+        sourceFile = tsquery_1.tsquery.ast(rspackConfigText);
+    };
+    updateSources();
+    setOptionsInRspackConfig(tree, rspackConfigText, sourceFile, rspackConfig, pluginOptions);
+    updateSources();
+    setOptionsInNxRspackPlugin(tree, rspackConfigText, sourceFile, rspackConfig);
+    updateSources();
+    setOptionsInLegacyNxPlugin(tree, rspackConfigText, sourceFile, rspackConfig);
+}
+function setOptionsInRspackConfig(tree, text, sourceFile, rspackConfig, pluginOptions) {
+    const { default: defaultOptions, ...configurationOptions } = pluginOptions;
+    const optionsSelector = 'VariableStatement:has(VariableDeclaration:has(Identifier[name=options]))';
+    const optionsVariable = (0, tsquery_1.tsquery)(sourceFile, optionsSelector)[0];
+    // This is assuming the `options` variable will be available since it's what the
+    // `convert-config-to-rspack-plugin` generates
+    let defaultOptionsObject;
+    const optionsObject = (0, tsquery_1.tsquery)(optionsVariable, 'ObjectLiteralExpression')[0];
+    if (optionsObject.properties.length === 0) {
+        defaultOptionsObject = ts.factory.createObjectLiteralExpression(Object.entries(defaultOptions).map(([key, value]) => (0, ast_1.toPropertyAssignment)(key, value)));
+    }
+    else {
+        // filter out the default options that are already in the options object
+        // the existing options override the options from the project.json file
+        const filteredDefaultOptions = Object.entries(defaultOptions).filter(([key]) => !optionsObject.properties.some((property) => ts.isPropertyAssignment(property) &&
+            ts.isIdentifier(property.name) &&
+            property.name.text === key));
+        defaultOptionsObject = ts.factory.createObjectLiteralExpression([
+            ...optionsObject.properties,
+            ...filteredDefaultOptions.map(([key, value]) => (0, ast_1.toPropertyAssignment)(key, value)),
+        ]);
+    }
+    /**
+     * const configValues = {
+     *  build: {
+     *   default: { ... },
+     *   configuration1: { ... },
+     *   configuration2: { ... },
+     * }
+     */
+    const configValuesVariable = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration('configValues', undefined, undefined, ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('build', ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment('default', defaultOptionsObject),
+                ...(configurationOptions
+                    ? Object.entries(configurationOptions).map(([key, value]) => ts.factory.createPropertyAssignment(key, ts.factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => (0, ast_1.toPropertyAssignment)(key, value)))))
+                    : []),
+            ])),
+        ], true)),
+    ], ts.NodeFlags.Const));
+    text = `${text.slice(0, optionsVariable.getStart())}
+    // These options were migrated by @nx/rspack:convert-to-inferred from
+    // the project.json file and merged with the options in this file
+    ${ts
+        .createPrinter()
+        .printNode(ts.EmitHint.Unspecified, configValuesVariable, sourceFile)}
+    
+    // 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],
+    };${text.slice(optionsVariable.getEnd())}`;
+    // These are comments written by the `convert-config-to-rspack-plugin` that are no longer needed
+    text = text
+        .replace(`// This file was migrated using @nx/rspack:convert-config-to-rspack-plugin from your './rspack.config.old.js'`, '')
+        .replace('// Please check that the options here are correct as they were moved from the old rspack.config.js to this file.', '');
+    tree.write(rspackConfig, text);
+}
+function setOptionsInNxRspackPlugin(tree, text, sourceFile, rspackConfig) {
+    const nxAppRspackPluginSelector = 'PropertyAssignment:has(Identifier[name=plugins]) NewExpression:has(Identifier[name=NxAppRspackPlugin])';
+    const nxAppRspackPlugin = (0, tsquery_1.tsquery)(sourceFile, nxAppRspackPluginSelector)[0];
+    // the NxAppRspackPlugin must exists, otherwise, the migration doesn't run and we wouldn't reach this point
+    const updatedNxAppRspackPlugin = ts.factory.updateNewExpression(nxAppRspackPlugin, nxAppRspackPlugin.expression, undefined, [ts.factory.createIdentifier('buildOptions')]);
+    text = `${text.slice(0, nxAppRspackPlugin.getStart())}${ts
+        .createPrinter()
+        .printNode(ts.EmitHint.Unspecified, updatedNxAppRspackPlugin, sourceFile)}${text.slice(nxAppRspackPlugin.getEnd())}`;
+    tree.write(rspackConfig, text);
+}
+function setOptionsInLegacyNxPlugin(tree, text, sourceFile, rspackConfig) {
+    const legacyNxPluginSelector = 'AwaitExpression CallExpression:has(Identifier[name=useLegacyNxPlugin])';
+    const legacyNxPlugin = (0, tsquery_1.tsquery)(sourceFile, legacyNxPluginSelector)[0];
+    // we're assuming the `useLegacyNxPlugin` function is being called since it's what the `convert-config-to-rspack-plugin` generates
+    // we've already "ensured" that the `convert-config-to-rspack-plugin` was run by checking for the `NxAppRspackPlugin` in the project validation
+    const updatedLegacyNxPlugin = ts.factory.updateCallExpression(legacyNxPlugin, legacyNxPlugin.expression, undefined, [legacyNxPlugin.arguments[0], ts.factory.createIdentifier('buildOptions')]);
+    text = `${text.slice(0, legacyNxPlugin.getStart())}${ts
+        .createPrinter()
+        .printNode(ts.EmitHint.Unspecified, updatedLegacyNxPlugin, sourceFile)}${text.slice(legacyNxPlugin.getEnd())}`;
+    tree.write(rspackConfig, text);
+}
+function getMemoryLimitFromServeTarget(context, configName) {
+    const { targets } = context.projectGraph.nodes[context.projectName].data;
+    const serveTarget = Object.values(targets).find((target) => target.executor === '@nx/rspack:dev-server' ||
+        target.executor === '@nrwl/web:dev-server');
+    if (!serveTarget) {
+        return undefined;
+    }
+    if (configName && serveTarget.configurations?.[configName]) {
+        return (serveTarget.configurations[configName].options?.memoryLimit ??
+            serveTarget.options?.memoryLimit);
+    }
+    return serveTarget.options?.memoryLimit;
+}

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

@@ -0,0 +1,3 @@
+export * from './build-post-target-transformer';
+export * from './serve-post-target-transformer';
+export * from './types';

package/src/generators/convert-to-inferred/utils/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build-post-target-transformer"), exports);
+tslib_1.__exportStar(require("./serve-post-target-transformer"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/src/generators/convert-to-inferred/utils/serve-post-target-transformer.d.ts

@@ -0,0 +1,6 @@
+import { type TargetConfiguration, type Tree } from '@nx/devkit';
+import type { MigrationContext } from './types';
+export declare function servePostTargetTransformerFactory(migrationContext: MigrationContext): (target: TargetConfiguration, tree: Tree, projectDetails: {
+    projectName: string;
+    root: string;
+}, inferredTarget: TargetConfiguration) => Promise<TargetConfiguration>;

package/src/generators/convert-to-inferred/utils/serve-post-target-transformer.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servePostTargetTransformerFactory = servePostTargetTransformerFactory;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const plugin_migration_utils_1 = require("@nx/devkit/src/generators/plugin-migrations/plugin-migration-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const path_1 = require("path");
+const ts = tslib_1.__importStar(require("typescript"));
+const serve_path_1 = require("../../../executors/dev-server/lib/serve-path");
+const ast_1 = require("./ast");
+function servePostTargetTransformerFactory(migrationContext) {
+    return async function servePostTargetTransformer(target, tree, projectDetails, inferredTarget) {
+        const context = {
+            ...migrationContext,
+            projectName: projectDetails.projectName,
+            projectRoot: projectDetails.root,
+        };
+        const { devServerOptions, rspackConfigPath } = await processOptions(tree, target, context);
+        updateRspackConfig(tree, rspackConfigPath, devServerOptions, context);
+        if (target.outputs) {
+            (0, plugin_migration_utils_1.processTargetOutputs)(target, [], inferredTarget, {
+                projectName: projectDetails.projectName,
+                projectRoot: projectDetails.root,
+            });
+        }
+        return target;
+    };
+}
+async function processOptions(tree, target, context) {
+    const executorContext = {
+        cwd: process.cwd(),
+        nxJsonConfiguration: (0, devkit_1.readJson)(tree, 'nx.json'),
+        projectGraph: context.projectGraph,
+        projectName: context.projectName,
+        projectsConfigurations: Object.entries(context.projectGraph.nodes).reduce((acc, [projectName, project]) => {
+            acc.projects[projectName] = project.data;
+            return acc;
+        }, { version: 1, projects: {} }),
+        root: context.workspaceRoot,
+    };
+    const buildTarget = (0, devkit_1.parseTargetString)(target.options.buildTarget, executorContext);
+    const buildOptions = (0, devkit_1.readTargetOptions)(buildTarget, executorContext);
+    // it must exist, we validated it in the project filter
+    const rspackConfigPath = buildOptions.rspackConfig;
+    const defaultOptions = extractDevServerOptions(target.options, context);
+    applyDefaults(defaultOptions, buildOptions);
+    const devServerOptions = {
+        default: defaultOptions,
+    };
+    if (target.configurations && Object.keys(target.configurations).length) {
+        for (const [configName, config] of Object.entries(target.configurations)) {
+            devServerOptions[configName] = extractDevServerOptions(config, context);
+        }
+    }
+    return { devServerOptions, rspackConfigPath: rspackConfigPath };
+}
+function extractDevServerOptions(options, context) {
+    const devServerOptions = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (key === 'ssl' || key === 'sslCert' || key === 'sslKey') {
+            if (key === 'ssl' || 'ssl' in options) {
+                if (options.ssl) {
+                    devServerOptions.server = { type: 'https' };
+                    if (options.sslCert && options.sslKey) {
+                        devServerOptions.server.options = {};
+                        devServerOptions.server.options.cert = (0, plugin_migration_utils_1.toProjectRelativePath)(options.sslCert, context.projectRoot);
+                        devServerOptions.server.options.key = (0, plugin_migration_utils_1.toProjectRelativePath)(options.sslKey, context.projectRoot);
+                    }
+                    else if (options.sslCert) {
+                        context.logger.addLog({
+                            executorName: '@nx/rspack:dev-server',
+                            log: 'The "sslCert" option was set but "sslKey" was missing and "ssl" was set to "true". This means that "sslCert" was ignored by the executor. It has been removed from the options.',
+                            project: context.projectName,
+                        });
+                    }
+                    else if (options.sslKey) {
+                        context.logger.addLog({
+                            executorName: '@nx/rspack:dev-server',
+                            log: 'The "sslKey" option was set but "sslCert" was missing and "ssl" was set to "true". This means that "sslKey" was ignored by the executor. It has been removed from the options.',
+                            project: context.projectName,
+                        });
+                    }
+                }
+                else if (options.sslCert || options.sslKey) {
+                    context.logger.addLog({
+                        executorName: '@nx/rspack:dev-server',
+                        log: 'The "sslCert" and/or "sslKey" were set with "ssl" set to "false". This means they were ignored by the executor. They have been removed from the options.',
+                        project: context.projectName,
+                    });
+                }
+                delete options.ssl;
+                delete options.sslCert;
+                delete options.sslKey;
+            }
+            else if (options.sslCert || options.sslKey) {
+                context.logger.addLog({
+                    executorName: '@nx/rspack:dev-server',
+                    log: 'The "sslCert" and/or "sslKey" were set but the "ssl" was not set. This means they were ignored by the executor. They have been removed from the options.',
+                    project: context.projectName,
+                });
+                delete options.sslCert;
+                delete options.sslKey;
+            }
+        }
+        else if (key === 'buildTarget') {
+            delete options.buildTarget;
+        }
+        else {
+            devServerOptions[key] = value;
+            delete options[key];
+        }
+    }
+    return devServerOptions;
+}
+function applyDefaults(options, buildOptions) {
+    if (options.port === undefined) {
+        options.port = 4200;
+    }
+    options.headers = { 'Access-Control-Allow-Origin': '*' };
+    const servePath = (0, serve_path_1.buildServePath)(buildOptions);
+    options.historyApiFallback = {
+        index: buildOptions.index && `${servePath}${(0, path_1.basename)(buildOptions.index)}`,
+        disableDotRule: true,
+        htmlAcceptHeaders: ['text/html', 'application/xhtml+xml'],
+    };
+}
+function getProxyConfig(root, proxyConfig) {
+    const proxyPath = (0, path_1.resolve)(root, proxyConfig);
+    return require(proxyPath);
+}
+function updateRspackConfig(tree, rspackConfigPath, devServerOptions, context) {
+    let sourceFile;
+    let rspackConfigText;
+    const updateSources = () => {
+        rspackConfigText = tree.read(rspackConfigPath, 'utf-8');
+        sourceFile = tsquery_1.tsquery.ast(rspackConfigText);
+    };
+    updateSources();
+    setOptionsInRspackConfig(tree, rspackConfigText, sourceFile, rspackConfigPath, devServerOptions);
+    updateSources();
+    setDevServerOptionsInRspackConfig(tree, rspackConfigText, sourceFile, rspackConfigPath, context);
+}
+function setOptionsInRspackConfig(tree, text, sourceFile, rspackConfigPath, devServerOptions) {
+    const { default: defaultOptions, ...configurationOptions } = devServerOptions;
+    const configValuesSelector = 'VariableDeclaration:has(Identifier[name=configValues]) ObjectLiteralExpression';
+    const configValuesObject = (0, tsquery_1.tsquery)(sourceFile, configValuesSelector)[0];
+    // configValues must exist at this point, we added it when processing the build target
+    /**
+     * const configValues = {
+     *   ...
+     *   serve: {
+     *     default: { ... },
+     *     configuration1: { ... },
+     *    ...
+     *  },
+     */
+    const updatedConfigValuesObject = ts.factory.updateObjectLiteralExpression(configValuesObject, [
+        ...configValuesObject.properties,
+        ts.factory.createPropertyAssignment('serve', ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('default', ts.factory.createObjectLiteralExpression(Object.entries(defaultOptions).map(([key, value]) => (0, ast_1.toPropertyAssignment)(key, value)))),
+            ...(configurationOptions
+                ? Object.entries(configurationOptions).map(([key, value]) => ts.factory.createPropertyAssignment(key, ts.factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => (0, ast_1.toPropertyAssignment)(key, value)))))
+                : []),
+        ])),
+    ]);
+    text = `${text.slice(0, configValuesObject.getStart())}${ts
+        .createPrinter()
+        .printNode(ts.EmitHint.Unspecified, updatedConfigValuesObject, sourceFile)}${text.slice(configValuesObject.getEnd())}`;
+    tree.write(rspackConfigPath, text);
+    sourceFile = tsquery_1.tsquery.ast(text);
+    const buildOptionsSelector = 'VariableStatement:has(VariableDeclaration:has(Identifier[name=buildOptions]))';
+    const buildOptionsStatement = (0, tsquery_1.tsquery)(sourceFile, buildOptionsSelector)[0];
+    text = `${text.slice(0, buildOptionsStatement.getEnd())}
+  const devServerOptions = {
+    ...configValues.serve.default,
+    ...configValues.serve[configuration],
+  };${text.slice(buildOptionsStatement.getEnd())}`;
+    tree.write(rspackConfigPath, text);
+}
+function setDevServerOptionsInRspackConfig(tree, text, sourceFile, rspackConfigPath, context) {
+    const rspackConfigDevServerSelector = 'ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=devServer])';
+    const rspackConfigDevServer = (0, tsquery_1.tsquery)(sourceFile, rspackConfigDevServerSelector)[0];
+    if (rspackConfigDevServer) {
+        context.logger.addLog({
+            executorName: '@nx/rspack:dev-server',
+            log: `The "devServer" option is already set in the rspack config. The migration doesn't support updating it. Please review it and make any necessary changes manually.`,
+            project: context.projectName,
+        });
+        text = `${text.slice(0, rspackConfigDevServer.getStart())}// This is the untouched "devServer" option from the original rspack config. Please review it and make any necessary changes manually.
+    ${text.slice(rspackConfigDevServer.getStart())}`;
+        tree.write(rspackConfigPath, text);
+        // If the devServer property already exists, we don't know how to merge the
+        // options, so we leave it as is.
+        return;
+    }
+    const rspackConfigSelector = 'ObjectLiteralExpression:has(PropertyAssignment:has(Identifier[name=plugins]))';
+    const rspackConfig = (0, tsquery_1.tsquery)(sourceFile, rspackConfigSelector)[0];
+    const updatedRspackConfig = ts.factory.updateObjectLiteralExpression(rspackConfig, [
+        ts.factory.createPropertyAssignment('devServer', ts.factory.createIdentifier('devServerOptions')),
+        ...rspackConfig.properties,
+    ]);
+    text = `${text.slice(0, rspackConfig.getStart())}${ts
+        .createPrinter()
+        .printNode(ts.EmitHint.Unspecified, updatedRspackConfig, sourceFile)}${text.slice(rspackConfig.getEnd())}`;
+    tree.write(rspackConfigPath, text);
+}

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

@@ -0,0 +1,11 @@
+import type { ProjectGraph } from '@nx/devkit';
+import type { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';
+export type MigrationContext = {
+    logger: AggregatedLog;
+    projectGraph: ProjectGraph;
+    workspaceRoot: string;
+};
+export type TransformerContext = MigrationContext & {
+    projectName: string;
+    projectRoot: string;
+};

package/src/generators/convert-webpack/lib/transform-cjs.js

@@ -119,14 +119,14 @@ function transformModuleFederationConfig(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `const { ModuleFederationConfig } = require('@nx/rspack/module-federation');
+    const newContents = `const { ModuleFederationConfig } = require('@nx/module-federation');
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }
 function transformWithModuleFederation(tree, configPath, scope) {
     const configContents = tree.read(configPath, 'utf-8');
     const ast = tsquery_1.tsquery.ast(configContents);
-    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `VariableDeclaration:has(Identifier[name=withModuleFederation]) > CallExpression:has(Identifier[name=require]) StringLiteral[value=${scope}/react/module-federation]`;
+    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `VariableDeclaration:has(Identifier[name=withModuleFederation]) > CallExpression:has(Identifier[name=require]) StringLiteral[value=${scope}/module-federation/webpack]`;
     const nodes = (0, tsquery_1.tsquery)(ast, HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT);
     if (nodes.length === 0) {
         return;
@@ -141,14 +141,14 @@ function transformWithModuleFederation(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `const { withModuleFederation } = require('@nx/rspack/module-federation');
+    const newContents = `const { withModuleFederation } = require('@nx/module-federation/rspack');
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }
 function transformWithModuleFederationSSR(tree, configPath, scope) {
     const configContents = tree.read(configPath, 'utf-8');
     const ast = tsquery_1.tsquery.ast(configContents);
-    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `VariableDeclaration:has(Identifier[name=withModuleFederationForSSR]) > CallExpression:has(Identifier[name=require]) StringLiteral[value=${scope}/react/module-federation]`;
+    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `VariableDeclaration:has(Identifier[name=withModuleFederationForSSR]) > CallExpression:has(Identifier[name=require]) StringLiteral[value=${scope}/module-federation/webpack]`;
     const nodes = (0, tsquery_1.tsquery)(ast, HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT);
     if (nodes.length === 0) {
         return;
@@ -163,7 +163,7 @@ function transformWithModuleFederationSSR(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `const { withModuleFederationForSSR } = require('@nx/rspack/module-federation');
+    const newContents = `const { withModuleFederationForSSR } = require('@nx/module-federation/rspack');
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }

package/src/generators/convert-webpack/lib/transform-esm.js

@@ -104,7 +104,7 @@ function transformWithReact(tree, configPath, scope) {
 function transformWithModuleFederation(tree, configPath, scope) {
     const configContents = tree.read(configPath, 'utf-8');
     const ast = tsquery_1.tsquery.ast(configContents);
-    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `ImportDeclaration:has(Identifier[name=withModuleFederation]) > StringLiteral[value=${scope}/react/module-federation]`;
+    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `ImportDeclaration:has(Identifier[name=withModuleFederation]) > StringLiteral[value=${scope}/module-federation/webpack]`;
     const nodes = (0, tsquery_1.tsquery)(ast, HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT);
     if (nodes.length === 0) {
         return;
@@ -119,7 +119,7 @@ function transformWithModuleFederation(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `import { withModuleFederation } from '@nx/rspack/module-federation';
+    const newContents = `import { withModuleFederation } from '@nx/module-federation/rspack';
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }
@@ -141,14 +141,14 @@ function transformModuleFederationConfig(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `import { ModuleFederationConfig } from '@nx/rspack/module-federation';
+    const newContents = `import { ModuleFederationConfig } from '@nx/module-federation';
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }
 function transformWithModuleFederationSSR(tree, configPath, scope) {
     const configContents = tree.read(configPath, 'utf-8');
     const ast = tsquery_1.tsquery.ast(configContents);
-    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `ImportDeclaration:has(Identifier[name=withModuleFederationForSSR]) > StringLiteral[value=${scope}/react/module-federation]`;
+    const HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT = `ImportDeclaration:has(Identifier[name=withModuleFederationForSSR]) > StringLiteral[value=${scope}/module-federation/webpack]`;
     const nodes = (0, tsquery_1.tsquery)(ast, HAS_WITH_MODULE_FEDERATION_FROM_NX_REACT);
     if (nodes.length === 0) {
         return;
@@ -163,7 +163,7 @@ function transformWithModuleFederationSSR(tree, configPath, scope) {
     if (configContents.charAt(endIndex) === ',') {
         endIndex++;
     }
-    const newContents = `import { withModuleFederationForSSR } from '@nx/rspack/module-federation';
+    const newContents = `import { withModuleFederationForSSR } from '@nx/module-federation/rspack';
   ${configContents.slice(0, startIndex)}${configContents.slice(endIndex)}`;
     tree.write(configPath, newContents);
 }

package/src/generators/init/init.js

@@ -5,11 +5,9 @@ exports.rspackInitGenerator = rspackInitGenerator;
 const devkit_1 = require("@nx/devkit");
 const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const js_1 = require("@nx/js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 const plugin_1 = require("../../../plugin");
 const versions_1 = require("../../utils/versions");
 async function rspackInitGenerator(tree, schema) {
-    (0, ts_solution_setup_1.assertNotUsingTsSolutionSetup)(tree, 'rspack', 'init');
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&

package/src/index.d.ts

@@ -4,3 +4,4 @@ export * from './utils/config';
 export * from './utils/with-nx';
 export * from './utils/with-react';
 export * from './utils/with-web';
+export * from './plugins/use-legacy-nx-plugin/use-legacy-nx-plugin';

package/src/index.js

@@ -7,3 +7,4 @@ tslib_1.__exportStar(require("./utils/config"), exports);
 tslib_1.__exportStar(require("./utils/with-nx"), exports);
 tslib_1.__exportStar(require("./utils/with-react"), exports);
 tslib_1.__exportStar(require("./utils/with-web"), exports);
+tslib_1.__exportStar(require("./plugins/use-legacy-nx-plugin/use-legacy-nx-plugin"), exports);

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.d.ts

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

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateWithMfImport;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const NX_RSPACK_MODULE_FEDERATION_IMPORT_SELECTOR = 'ImportDeclaration > StringLiteral[value=@nx/rspack/module-federation], VariableStatement CallExpression:has(Identifier[name=require]) > StringLiteral[value=@nx/rspack/module-federation]';
+const NEW_IMPORT_PATH = `'@nx/module-federation/rspack'`;
+async function migrateWithMfImport(tree) {
+    const projects = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rspack:module-federation-dev-server', (options, project, target) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+        projects.add(projectConfig.root);
+    });
+    for (const projectRoot of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectRoot, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes('@nx/rspack/module-federation')) {
+                return;
+            }
+            const ast = tsquery_1.tsquery.ast(contents);
+            const importNodes = (0, tsquery_1.tsquery)(ast, NX_RSPACK_MODULE_FEDERATION_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            const importPathNode = importNodes[0];
+            contents = `${contents.slice(0, importPathNode.getStart())}${NEW_IMPORT_PATH}${contents.slice(importPathNode.getEnd())}`;
+            tree.write(filePath, contents);
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/plugins/nx-app-rspack-plugin/nx-app-rspack-plugin.d.ts

@@ -0,0 +1,16 @@
+import type { Compiler } from '@rspack/core';
+import type { NxAppRspackPluginOptions } from '../utils/models';
+/**
+ * This plugin provides features to build Node and Web applications.
+ * - TS Support (including tsconfig paths
+ * - Assets handling
+ * - Stylesheets handling
+ * - index.html and package.json generation
+ *
+ * Web-only features, such as stylesheets and images, are only supported when `target` is `web` or `webworker`.
+ */
+export declare class NxAppRspackPlugin {
+    private readonly options;
+    constructor(options?: NxAppRspackPluginOptions);
+    apply(compiler: Compiler): void;
+}