@nx/rspack 23.0.0-beta.2 → 23.0.0-beta.20

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.servePostTargetTransformerFactory = servePostTargetTransformerFactory;
 const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
 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"));
@@ -19,7 +19,7 @@ function servePostTargetTransformerFactory(migrationContext) {
         const { devServerOptions, rspackConfigPath } = await processOptions(tree, target, context);
         updateRspackConfig(tree, rspackConfigPath, devServerOptions, context);
         if (target.outputs) {
-            (0, plugin_migration_utils_1.processTargetOutputs)(target, [], inferredTarget, {
+            (0, internal_1.processTargetOutputs)(target, [], inferredTarget, {
                 projectName: projectDetails.projectName,
                 projectRoot: projectDetails.root,
             });
@@ -64,8 +64,8 @@ function extractDevServerOptions(options, context) {
                     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);
+                        devServerOptions.server.options.cert = (0, internal_1.toProjectRelativePath)(options.sslCert, context.projectRoot);
+                        devServerOptions.server.options.key = (0, internal_1.toProjectRelativePath)(options.sslKey, context.projectRoot);
                     }
                     else if (options.sslCert) {
                         context.logger.addLog({

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

@@ -1,5 +1,5 @@
 import type { ProjectGraph } from '@nx/devkit';
-import type { AggregatedLog } from '@nx/devkit/src/generators/plugin-migrations/aggregate-log-util';
+import type { AggregatedLog } from '@nx/devkit/internal';
 export type MigrationContext = {
     logger: AggregatedLog;
     projectGraph: ProjectGraph;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rspack/src/generators/convert-to-inferred/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gEAAgE,CAAC;AAEpG,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rspack/src/generators/convert-to-inferred/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,GAAG;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/src/generators/convert-webpack/convert-webpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-webpack.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/generators/convert-webpack/convert-webpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AASlC,yBAA+B,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,mDAwJzD"}
+{"version":3,"file":"convert-webpack.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/generators/convert-webpack/convert-webpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAWlC,yBAA+B,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,mDAiKzD"}

package/src/generators/convert-webpack/convert-webpack.js

@@ -6,7 +6,9 @@ const versions_1 = require("../../utils/versions");
 const transform_esm_1 = require("./lib/transform-esm");
 const transform_cjs_1 = require("./lib/transform-cjs");
 const transform_plugin_config_1 = require("./lib/transform-plugin-config");
+const assert_supported_rspack_version_1 = require("../../utils/assert-supported-rspack-version");
 async function default_1(tree, options) {
+    (0, assert_supported_rspack_version_1.assertSupportedRspackVersion)(tree);
     const projects = (0, devkit_1.getProjects)(tree);
     if (!projects.has(options.project)) {
         throw new Error(`Could not find project '${options.project}'. Ensure you have specified the project you'd like to convert correctly.`);
@@ -113,7 +115,12 @@ async function default_1(tree, options) {
     const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
         '@rspack/core': versions_1.rspackCoreVersion,
         '@rspack/dev-server': versions_1.rspackDevServerVersion,
-    });
+        // @rspack/plugin-react-refresh is required at runtime by
+        // apply-react-config when building a React project. Since it is an
+        // optional peer dependency of @nx/rspack, the convert generator must
+        // install it explicitly.
+        '@rspack/plugin-react-refresh': versions_1.rspackPluginReactRefreshVersion,
+    }, undefined, true);
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/generators/init/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,iBAAiB,EAGjB,IAAI,EACL,MAAM,YAAY,CAAC;AAapB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,mBAAmB,8BAyG5B;AAED,eAAe,mBAAmB,CAAC;AAEnC,eAAO,MAAM,mBAAmB,sFAA0C,CAAC"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/generators/init/init.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,iBAAiB,EAGjB,IAAI,EACL,MAAM,YAAY,CAAC;AAWpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,mBAAmB,8BAiH5B;AAED,eAAe,mBAAmB,CAAC;AAEnC,eAAO,MAAM,mBAAmB,sFAA0C,CAAC"}

package/src/generators/init/init.js

@@ -2,19 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rspackInitSchematic = void 0;
 exports.rspackInitGenerator = rspackInitGenerator;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
 const js_1 = require("@nx/js");
 const plugin_1 = require("../../../plugin");
 const versions_1 = require("../../utils/versions");
+const version_utils_1 = require("../../utils/version-utils");
+const assert_supported_rspack_version_1 = require("../../utils/assert-supported-rspack-version");
 async function rspackInitGenerator(tree, schema) {
+    (0, assert_supported_rspack_version_1.assertSupportedRspackVersion)(tree);
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
         nxJson.useInferencePlugins !== false;
     schema.addPlugin ??= addPluginDefault;
     if (schema.addPlugin) {
-        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rspack/plugin', plugin_1.createNodesV2, {
+        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rspack/plugin', plugin_1.createNodesV2, {
             buildTargetName: [
                 'build',
                 'rspack:build',
@@ -59,12 +62,15 @@ async function rspackInitGenerator(tree, schema) {
         skipFormat: true,
     });
     tasks.push(jsInitTask);
+    const rspackVersions = (0, version_utils_1.getRspackVersionsForInstalledMajor)(tree);
+    const keepExistingVersions = schema.keepExistingVersions ?? true;
     const devDependencies = {
-        '@rspack/core': versions_1.rspackCoreVersion,
-        '@rspack/cli': versions_1.rspackCoreVersion,
+        '@rspack/core': rspackVersions.rspackCoreVersion,
+        '@rspack/cli': rspackVersions.rspackCoreVersion,
+        '@rspack/dev-server': rspackVersions.rspackDevServerVersion,
         ...(!schema.framework || schema.framework === 'react'
             ? {
-                '@rspack/plugin-react-refresh': versions_1.rspackPluginReactRefreshVersion,
+                '@rspack/plugin-react-refresh': rspackVersions.rspackPluginReactRefreshVersion,
                 'react-refresh': versions_1.reactRefreshVersion,
             }
             : {}),
@@ -82,9 +88,10 @@ async function rspackInitGenerator(tree, schema) {
         devDependencies['sass-embedded'] = versions_1.sassEmbeddedVersion;
     }
     if (schema.framework !== 'none' || schema.devServer) {
-        devDependencies['@rspack/dev-server'] = versions_1.rspackDevServerVersion;
+        devDependencies['@rspack/dev-server'] =
+            rspackVersions.rspackDevServerVersion;
     }
-    const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
+    const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, keepExistingVersions);
     tasks.push(installTask);
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }

package/src/generators/init/schema.json

@@ -24,7 +24,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     }
   },
   "required": []

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

@@ -1 +1 @@
-{"version":3,"file":"migrate-with-mf-import-to-new-package.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,YAAY,CAAC;AASpB,wBAA8B,mBAAmB,CAAC,IAAI,EAAE,IAAI,iBAqD3D"}
+{"version":3,"file":"migrate-with-mf-import-to-new-package.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,YAAY,CAAC;AAQpB,wBAA8B,mBAAmB,CAAC,IAAI,EAAE,IAAI,iBAqD3D"}

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = migrateWithMfImport;
+const internal_1 = require("@nx/devkit/internal");
 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 versions_1 = require("../../utils/versions");
 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) => {
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rspack:module-federation-dev-server', (options, project, target) => {
         const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
         projects.add(projectConfig.root);
     });

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensure-nx-module-federation-package.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-20-3-0/ensure-nx-module-federation-package.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AAIpB,wBAA8B,eAAe,CAAC,IAAI,EAAE,IAAI,iBAqBvD"}
+{"version":3,"file":"ensure-nx-module-federation-package.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-20-3-0/ensure-nx-module-federation-package.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,IAAI,EAGV,MAAM,YAAY,CAAC;AAGpB,wBAA8B,eAAe,CAAC,IAAI,EAAE,IAAI,iBAqBvD"}

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = ensureMfPackage;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
 const versions_1 = require("../../utils/versions");
 async function ensureMfPackage(tree) {
     const projects = new Set();
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rspack:module-federation-dev-server', (options, project, target) => {
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rspack:module-federation-dev-server', (options, project, target) => {
         const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
         projects.add(projectConfig.root);
     });

package/src/migrations/update-22-0-0/remove-deprecated-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove-deprecated-options.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-22-0-0/remove-deprecated-options.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,YAAY,CAAC;AAGpB,wBAA8B,uBAAuB,CAAC,IAAI,EAAE,IAAI,iBAwH/D"}
+{"version":3,"file":"remove-deprecated-options.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-22-0-0/remove-deprecated-options.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,YAAY,CAAC;AAEpB,wBAA8B,uBAAuB,CAAC,IAAI,EAAE,IAAI,iBAwH/D"}

package/src/migrations/update-22-0-0/remove-deprecated-options.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = removeDeprecatedOptions;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
 async function removeDeprecatedOptions(tree) {
     const projects = new Set();
     // Find all projects using @nx/rspack:rspack or @nx/rspack:dev-server executors
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rspack:rspack', (options, project) => {
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rspack:rspack', (options, project) => {
         projects.add(project);
     });
-    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/rspack:dev-server', (options, project) => {
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rspack:dev-server', (options, project) => {
         projects.add(project);
     });
     // Update project configurations to remove deprecated options

package/src/migrations/update-23-0-0/add-svgr-to-rspack-config.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function addSvgrToRspackConfig(tree: Tree): Promise<void>;
+//# sourceMappingURL=add-svgr-to-rspack-config.d.ts.map

package/src/migrations/update-23-0-0/add-svgr-to-rspack-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-svgr-to-rspack-config.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/migrations/update-23-0-0/add-svgr-to-rspack-config.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,YAAY,CAAC;AA8FpB,wBAA8B,qBAAqB,CAAC,IAAI,EAAE,IAAI,iBA+Y7D"}

package/src/migrations/update-23-0-0/add-svgr-to-rspack-config.js

@@ -0,0 +1,413 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addSvgrToRspackConfig;
+const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = tslib_1.__importStar(require("typescript"));
+const withSvgrFunctionForWithReact = `
+
+// SVGR support function (migrated from svgr option in withReact/NxReactRspackPlugin)
+function withSvgr(svgrOptions = {}) {
+  const defaultOptions = {
+    svgo: false,
+    titleProp: true,
+    ref: true,
+  };
+
+  const options = { ...defaultOptions, ...svgrOptions };
+
+  return function configure(config) {
+    // Remove existing SVG loader if present
+    const svgLoaderIdx = config.module.rules.findIndex(
+      (rule) =>
+        typeof rule === 'object' &&
+        typeof rule.test !== 'undefined' &&
+        rule.test.toString().includes('svg')
+    );
+
+    if (svgLoaderIdx !== -1) {
+      config.module.rules.splice(svgLoaderIdx, 1);
+    }
+
+    config.module.rules.push(
+      {
+        test: /\\.svg$/i,
+        type: 'asset',
+        resourceQuery: /url/, // *.svg?url
+      },
+      {
+        test: /\\.svg$/i,
+        issuer: /\\.[jt]sx?$/,
+        resourceQuery: { not: [/url/] },
+        use: [{ loader: '@svgr/webpack', options }],
+      }
+    );
+
+    return config;
+  };
+}
+`;
+const withSvgrFunctionForNxReactRspackPlugin = `
+
+// SVGR support function (migrated from svgr option in withReact/NxReactRspackPlugin)
+function withSvgr(svgrOptions = {}) {
+  const defaultOptions = {
+    svgo: false,
+    titleProp: true,
+    ref: true,
+  };
+
+  const options = { ...defaultOptions, ...svgrOptions };
+
+  return (config) => {
+    config.plugins.push({
+      apply: (compiler) => {
+        // Remove ALL existing SVG loaders
+        compiler.options.module.rules = compiler.options.module.rules.filter(
+          (rule) =>
+            !(
+              rule &&
+              typeof rule === 'object' &&
+              rule.test &&
+              rule.test.toString().includes('svg')
+            )
+        );
+
+        compiler.options.module.rules.push(
+          {
+            test: /\\.svg$/i,
+            type: 'asset',
+            resourceQuery: /url/,
+          },
+          {
+            test: /\\.svg$/i,
+            issuer: /\\.[jt]sx?$/,
+            resourceQuery: { not: [/url/] },
+            use: [{ loader: '@svgr/webpack', options }],
+          }
+        );
+      },
+    });
+    return config;
+  };
+}
+`;
+async function addSvgrToRspackConfig(tree) {
+    const projects = new Map();
+    // Find all React rspack projects using either withReact OR NxReactRspackPlugin
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/rspack:rspack', (options, project, target) => {
+        if (!options.rspackConfig)
+            return;
+        const rspackConfigPath = options.rspackConfig;
+        if (!tree.exists(rspackConfigPath))
+            return;
+        const content = tree.read(rspackConfigPath, 'utf-8');
+        const sourceFile = (0, tsquery_1.ast)(content);
+        // Check if this is a withReact setup
+        if (content.includes('withReact')) {
+            const withReactCalls = (0, tsquery_1.query)(sourceFile, 'CallExpression[expression.name=withReact]');
+            if (withReactCalls.length > 0) {
+                const callExpr = withReactCalls[0];
+                if (callExpr.arguments.length === 0)
+                    return;
+                const arg = callExpr.arguments[0];
+                if (!ts.isObjectLiteralExpression(arg))
+                    return;
+                const svgrProp = arg.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+                    ts.isIdentifier(prop.name) &&
+                    prop.name.text === 'svgr');
+                if (svgrProp) {
+                    let svgrValue;
+                    if (ts.isObjectLiteralExpression(svgrProp.initializer)) {
+                        svgrValue = {};
+                        for (const prop of svgrProp.initializer.properties) {
+                            if (!ts.isPropertyAssignment(prop))
+                                continue;
+                            if (!ts.isIdentifier(prop.name))
+                                continue;
+                            const key = prop.name.text;
+                            if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                svgrValue[key] = true;
+                            }
+                            else if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                                svgrValue[key] = false;
+                            }
+                        }
+                    }
+                    else {
+                        svgrValue =
+                            svgrProp.initializer.kind === ts.SyntaxKind.TrueKeyword;
+                    }
+                    projects.set(rspackConfigPath, {
+                        svgrOptions: svgrValue,
+                        isWithReact: true,
+                    });
+                }
+            }
+        }
+        // Otherwise check if this is NxReactRspackPlugin setup
+        else if (content.includes('NxReactRspackPlugin')) {
+            const pluginCalls = (0, tsquery_1.query)(sourceFile, 'NewExpression[expression.name=NxReactRspackPlugin]');
+            if (pluginCalls.length > 0) {
+                const newExpr = pluginCalls[0];
+                if (!newExpr.arguments || newExpr.arguments.length === 0)
+                    return;
+                const arg = newExpr.arguments[0];
+                if (!ts.isObjectLiteralExpression(arg))
+                    return;
+                const svgrProp = arg.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+                    ts.isIdentifier(prop.name) &&
+                    prop.name.text === 'svgr');
+                if (svgrProp) {
+                    let svgrValue;
+                    if (ts.isObjectLiteralExpression(svgrProp.initializer)) {
+                        svgrValue = {};
+                        for (const prop of svgrProp.initializer.properties) {
+                            if (!ts.isPropertyAssignment(prop))
+                                continue;
+                            if (!ts.isIdentifier(prop.name))
+                                continue;
+                            const key = prop.name.text;
+                            if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                svgrValue[key] = true;
+                            }
+                            else if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                                svgrValue[key] = false;
+                            }
+                        }
+                    }
+                    else if (svgrProp.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                        svgrValue = true;
+                    }
+                    else if (svgrProp.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                        svgrValue = false;
+                    }
+                    // Add to projects if svgr is explicitly set
+                    if (svgrValue !== undefined) {
+                        projects.set(rspackConfigPath, {
+                            svgrOptions: svgrValue,
+                            isWithReact: false,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    if (projects.size === 0)
+        return;
+    // Update rspack configs to add withSvgr function inline
+    for (const [rspackConfigPath, config] of projects.entries()) {
+        let content = tree.read(rspackConfigPath, 'utf-8');
+        const sourceFile = (0, tsquery_1.ast)(content);
+        const changes = [];
+        // Build the svgr options for this specific config
+        let svgrOptionsStr = '';
+        if (config.svgrOptions) {
+            const importStatements = (0, tsquery_1.query)(sourceFile, 'ImportDeclaration');
+            const requireStatements = (0, tsquery_1.query)(sourceFile, 'VariableStatement:has(CallExpression[expression.name=require])');
+            const allImportRequires = [
+                ...importStatements,
+                ...requireStatements,
+            ].sort((a, b) => a.getEnd() - b.getEnd());
+            const lastImportOrRequire = allImportRequires[allImportRequires.length - 1];
+            if (config.svgrOptions === true || config.svgrOptions === undefined) {
+                svgrOptionsStr = '';
+            }
+            else if (typeof config.svgrOptions === 'object') {
+                const options = Object.entries(config.svgrOptions)
+                    .map(([key, value]) => `  ${key}: ${value}`)
+                    .join(',\n');
+                svgrOptionsStr = `{\n${options}\n}`;
+            }
+            if (lastImportOrRequire) {
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: lastImportOrRequire.getEnd(),
+                    text: config.isWithReact
+                        ? withSvgrFunctionForWithReact
+                        : withSvgrFunctionForNxReactRspackPlugin,
+                });
+            }
+            else {
+                changes.push({
+                    type: devkit_1.ChangeType.Insert,
+                    index: 0,
+                    text: (config.isWithReact
+                        ? withSvgrFunctionForWithReact
+                        : withSvgrFunctionForNxReactRspackPlugin) + '\n',
+                });
+            }
+        }
+        // Remove svgr option based on the style (withReact OR NxReactRspackPlugin)
+        if (config.isWithReact) {
+            const withReactCalls = (0, tsquery_1.query)(sourceFile, 'CallExpression[expression.name=withReact]');
+            if (withReactCalls.length > 0) {
+                const callExpr = withReactCalls[0];
+                if (callExpr.arguments.length > 0) {
+                    const arg = callExpr.arguments[0];
+                    if (ts.isObjectLiteralExpression(arg)) {
+                        const svgrProp = arg.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+                            ts.isIdentifier(prop.name) &&
+                            prop.name.text === 'svgr');
+                        if (svgrProp) {
+                            const hasOnlySvgrProperty = arg.properties.length === 1;
+                            if (hasOnlySvgrProperty) {
+                                changes.push({
+                                    type: devkit_1.ChangeType.Delete,
+                                    start: arg.getStart(),
+                                    length: arg.getEnd() - arg.getStart(),
+                                });
+                            }
+                            else {
+                                const propIndex = arg.properties.indexOf(svgrProp);
+                                const isLastProp = propIndex === arg.properties.length - 1;
+                                const isFirstProp = propIndex === 0;
+                                let removeStart = svgrProp.getFullStart();
+                                let removeEnd = svgrProp.getEnd();
+                                if (!isLastProp) {
+                                    const nextProp = arg.properties[propIndex + 1];
+                                    removeEnd = nextProp.getFullStart();
+                                }
+                                else if (!isFirstProp) {
+                                    const prevProp = arg.properties[propIndex - 1];
+                                    const textBetween = content.substring(prevProp.getEnd(), svgrProp.getFullStart());
+                                    const commaIndex = textBetween.indexOf(',');
+                                    if (commaIndex !== -1) {
+                                        removeStart = prevProp.getEnd() + commaIndex;
+                                    }
+                                }
+                                changes.push({
+                                    type: devkit_1.ChangeType.Delete,
+                                    start: removeStart,
+                                    length: removeEnd - removeStart,
+                                });
+                            }
+                            if (config.svgrOptions) {
+                                const composePluginsCalls = (0, tsquery_1.query)(sourceFile, 'CallExpression[expression.name=composePlugins]');
+                                if (composePluginsCalls.length > 0) {
+                                    const composeCall = composePluginsCalls[0];
+                                    let svgrCallStr = '';
+                                    if (config.svgrOptions === true ||
+                                        config.svgrOptions === undefined) {
+                                        svgrCallStr = 'withSvgr()';
+                                    }
+                                    else if (typeof config.svgrOptions === 'object') {
+                                        svgrCallStr = `withSvgr(${svgrOptionsStr})`;
+                                    }
+                                    const withReactIdx = composeCall.arguments.findIndex((arg) => arg.getText().includes('withReact'));
+                                    // Insert withSvgr as the last argument before the closing paren
+                                    const argToInsertAfter = composeCall.arguments[withReactIdx];
+                                    if (argToInsertAfter) {
+                                        changes.push({
+                                            type: devkit_1.ChangeType.Insert,
+                                            index: argToInsertAfter.getEnd(),
+                                            text: `, ${svgrCallStr}`,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // Remove svgr option from first NxReactRspackPlugin call
+            const pluginCalls = (0, tsquery_1.query)(sourceFile, 'NewExpression[expression.name=NxReactRspackPlugin]');
+            if (pluginCalls.length > 0) {
+                const newExpr = pluginCalls[0];
+                if (newExpr.arguments && newExpr.arguments.length > 0) {
+                    const arg = newExpr.arguments[0];
+                    if (ts.isObjectLiteralExpression(arg)) {
+                        const svgrProp = arg.properties.find((prop) => ts.isPropertyAssignment(prop) &&
+                            ts.isIdentifier(prop.name) &&
+                            prop.name.text === 'svgr');
+                        if (svgrProp) {
+                            const hasOnlySvgrProperty = arg.properties.length === 1;
+                            if (hasOnlySvgrProperty) {
+                                changes.push({
+                                    type: devkit_1.ChangeType.Delete,
+                                    start: arg.getStart(),
+                                    length: arg.getEnd() - arg.getStart(),
+                                });
+                            }
+                            else {
+                                const propIndex = arg.properties.indexOf(svgrProp);
+                                const isLastProp = propIndex === arg.properties.length - 1;
+                                const isFirstProp = propIndex === 0;
+                                let removeStart = svgrProp.getFullStart();
+                                let removeEnd = svgrProp.getEnd();
+                                if (!isLastProp) {
+                                    const nextProp = arg.properties[propIndex + 1];
+                                    removeEnd = nextProp.getFullStart();
+                                }
+                                else if (!isFirstProp) {
+                                    const prevProp = arg.properties[propIndex - 1];
+                                    const textBetween = content.substring(prevProp.getEnd(), svgrProp.getFullStart());
+                                    const commaIndex = textBetween.indexOf(',');
+                                    if (commaIndex !== -1) {
+                                        removeStart = prevProp.getEnd() + commaIndex;
+                                    }
+                                }
+                                changes.push({
+                                    type: devkit_1.ChangeType.Delete,
+                                    start: removeStart,
+                                    length: removeEnd - removeStart,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // For NxReactRspackPlugin style, wrap the entire module.exports or export default with withSvgr
+            if (config.svgrOptions) {
+                const allAssignments = (0, tsquery_1.query)(sourceFile, 'BinaryExpression');
+                const moduleExportsAssignment = allAssignments.find((node) => {
+                    const binaryExpr = node;
+                    const left = binaryExpr.left;
+                    return (ts.isPropertyAccessExpression(left) &&
+                        ts.isIdentifier(left.expression) &&
+                        left.expression.text === 'module' &&
+                        ts.isIdentifier(left.name) &&
+                        left.name.text === 'exports');
+                });
+                const exportDefaultStatements = (0, tsquery_1.query)(sourceFile, 'ExportAssignment');
+                const exportDefaultStatement = exportDefaultStatements[0];
+                let exportValue;
+                if (moduleExportsAssignment) {
+                    exportValue = moduleExportsAssignment.right;
+                }
+                else if (exportDefaultStatement) {
+                    exportValue = exportDefaultStatement.expression;
+                }
+                if (exportValue) {
+                    let svgrCallStr = '';
+                    if (config.svgrOptions === true || config.svgrOptions === undefined) {
+                        svgrCallStr = 'withSvgr()';
+                    }
+                    else if (typeof config.svgrOptions === 'object') {
+                        const options = Object.entries(config.svgrOptions)
+                            .map(([key, value]) => `  ${key}: ${value}`)
+                            .join(',\n');
+                        svgrCallStr = `withSvgr({\n${options}\n})`;
+                    }
+                    changes.push({
+                        type: devkit_1.ChangeType.Insert,
+                        index: exportValue.getStart(),
+                        text: `${svgrCallStr}(`,
+                    });
+                    changes.push({
+                        type: devkit_1.ChangeType.Insert,
+                        index: exportValue.getEnd(),
+                        text: ')',
+                    });
+                }
+            }
+        }
+        content = (0, devkit_1.applyChangesToString)(content, changes);
+        tree.write(rspackConfigPath, content);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}