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

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

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

@@ -0,0 +1,84 @@
+#### Replace the `svgr` Option with the `withSvgr` Composable in Rspack Configs
+
+Updates rspack configs that use React to use a new `withSvgr` composable function instead of passing an `svgr` option to `withReact` or `NxReactRspackPlugin`. The option was removed; SVG handling is now consolidated into the images asset rule by default. The migration inlines a `withSvgr` helper into each affected config so existing SVGR-as-React-component behavior is preserved.
+
+#### Sample Code Changes
+
+Replace the `svgr` option on `withReact` with a `withSvgr(...)` call composed alongside it.
+
+##### Before
+
+```js title="apps/myapp/rspack.config.js" {5}
+const { composePlugins, withNx, withReact } = require('@nx/rspack');
+
+module.exports = composePlugins(
+  withNx(),
+  withReact({ svgr: { svgo: false, titleProp: true, ref: true } })
+);
+```
+
+##### After
+
+```js title="apps/myapp/rspack.config.js"
+const { composePlugins, withNx, withReact } = require('@nx/rspack');
+
+// 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) {
+    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/ },
+      {
+        test: /\.svg$/i,
+        issuer: /\.[jt]sx?$/,
+        resourceQuery: { not: [/url/] },
+        use: [{ loader: '@svgr/webpack', options }],
+      }
+    );
+    return config;
+  };
+}
+
+module.exports = composePlugins(
+  withNx(),
+  withReact(),
+  withSvgr({ svgo: false, titleProp: true, ref: true })
+);
+```
+
+For the `NxReactRspackPlugin` style, the `svgr` option is removed from the plugin call and the entire `module.exports` is wrapped with a `withSvgr(...)` call that registers the loader rules directly on the compiler.
+
+##### Before
+
+```js title="apps/myapp/rspack.config.js" {5}
+const { NxReactRspackPlugin } = require('@nx/rspack');
+
+module.exports = {
+  plugins: [new NxReactRspackPlugin({ svgr: true, main: './src/main.tsx' })],
+};
+```
+
+##### After
+
+```js title="apps/myapp/rspack.config.js"
+const { NxReactRspackPlugin } = require('@nx/rspack');
+
+// SVGR support function (migrated from svgr option in withReact/NxReactRspackPlugin)
+function withSvgr(svgrOptions = {}) {
+  /* same helper as above, compiler.options.module.rules variant */
+}
+
+module.exports = withSvgr()({
+  plugins: [new NxReactRspackPlugin({ main: './src/main.tsx' })],
+});
+```

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

@@ -1,13 +1,7 @@
 import type { Compiler } from '@rspack/core';
 export declare class NxReactRspackPlugin {
     private options;
-    constructor(options?: {
-        /**
-         * @deprecated SVGR support is deprecated and will be removed in Nx 23.
-         * TODO(v23): Remove SVGR support
-         */
-        svgr?: boolean;
-    });
+    constructor(options?: Record<string, any>);
     apply(compiler: Compiler): void;
 }
 //# sourceMappingURL=nx-react-rspack-plugin.d.ts.map

package/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nx-react-rspack-plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG7C,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,OAAO;gBAAP,OAAO,GAAE;QACf;;;WAGG;QACH,IAAI,CAAC,EAAE,OAAO,CAAC;KACX;IAGR,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAGzB"}
+{"version":3,"file":"nx-react-rspack-plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAG7C,qBAAa,mBAAmB;IAClB,OAAO,CAAC,OAAO;gBAAP,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;IAErD,KAAK,CAAC,QAAQ,EAAE,QAAQ;CAGzB"}

package/src/plugins/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../packages/rspack/src/plugins/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAGlB,aAAa,EAMd,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAqBD,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAIF,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,mBAAmB,CAgC5D,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../packages/rspack/src/plugins/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAGlB,aAAa,EAKd,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAID,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAIF,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,mBAAmB,CAiC5D,CAAC"}

package/src/plugins/plugin.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createDependencies = void 0;
+const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
 const js_1 = require("@nx/js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_2 = require("@nx/js/internal");
 const fs_1 = require("fs");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
@@ -12,20 +12,6 @@ const package_manager_1 = require("nx/src/utils/package-manager");
 const path_1 = require("path");
 const read_rspack_options_1 = require("../utils/read-rspack-options");
 const resolve_user_defined_rspack_config_1 = require("../utils/resolve-user-defined-rspack-config");
-const util_1 = require("@nx/js/src/plugins/typescript/util");
-function readTargetsCache(cachePath) {
-    try {
-        return process.env.NX_CACHE_PROJECT_GRAPH !== 'false'
-            ? (0, devkit_1.readJsonFile)(cachePath)
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-function writeTargetsToCache(cachePath, results) {
-    (0, devkit_1.writeJsonFile)(cachePath, results);
-}
 const createDependencies = () => {
     return [];
 };
@@ -36,18 +22,20 @@ exports.createNodesV2 = [
     async (configFilePaths, options, context) => {
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `rspack-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
-        const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
-        const pmc = (0, package_manager_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const targetsCache = new internal_1.PluginCache(cachePath);
+        const isTsSolutionSetup = (0, internal_2.isUsingTsSolutionSetup)();
+        const packageManager = (0, devkit_1.detectPackageManager)(context.workspaceRoot);
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+        const lockFileName = (0, js_1.getLockFileName)(packageManager);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache, isTsSolutionSetup, pmc), configFilePaths, options, context);
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache, isTsSolutionSetup, pmc, lockFileName), configFilePaths, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            targetsCache.writeToDisk();
         }
     },
 ];
-async function createNodesInternal(configFilePath, options, context, targetsCache, isTsSolutionSetup, pmc) {
+async function createNodesInternal(configFilePath, options, context, targetsCache, isTsSolutionSetup, pmc, lockFileName) {
     const projectRoot = (0, path_1.dirname)(configFilePath);
     // Do not create a project if package.json and project.json isn't there.
     const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
@@ -60,7 +48,7 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
         packageJson = (0, devkit_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, projectRoot, 'package.json'));
     }
     const normalizedOptions = normalizeOptions(options);
-    const lockFileHash = (0, file_hasher_1.hashFile)((0, path_1.join)(context.workspaceRoot, (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)))) ?? '';
+    const lockFileHash = (0, file_hasher_1.hashFile)((0, path_1.join)(context.workspaceRoot, lockFileName)) ?? '';
     const nodeHash = (0, file_hasher_1.hashArray)([
         (0, file_hasher_1.hashFile)((0, path_1.join)(context.workspaceRoot, configFilePath)),
         lockFileHash,
@@ -70,8 +58,10 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
     // We do not want to alter how the hash is calculated, so appending the config file path to the hash
     // to prevent vite/vitest files overwriting the target cache created by the other
     const hash = `${nodeHash}_${configFilePath}`;
-    targetsCache[hash] ??= await createRspackTargets(configFilePath, projectRoot, normalizedOptions, context, isTsSolutionSetup, pmc);
-    const { targets, metadata } = targetsCache[hash];
+    if (!targetsCache.has(hash)) {
+        targetsCache.set(hash, await createRspackTargets(configFilePath, projectRoot, normalizedOptions, context, isTsSolutionSetup, pmc));
+    }
+    const { targets, metadata } = targetsCache.get(hash);
     return {
         projects: {
             [projectRoot]: {
@@ -83,7 +73,7 @@ async function createNodesInternal(configFilePath, options, context, targetsCach
     };
 }
 async function createRspackTargets(configFilePath, projectRoot, options, context, isTsSolutionSetup, pmc) {
-    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, internal_1.getNamedInputs)(projectRoot, context);
     const rspackConfig = await (0, resolve_user_defined_rspack_config_1.resolveUserDefinedRspackConfig)((0, path_1.join)(context.workspaceRoot, configFilePath), (0, js_1.getRootTsConfigPath)(), true);
     const rspackOptions = await (0, read_rspack_options_1.readRspackOptions)(rspackConfig);
     const outputs = [];
@@ -175,7 +165,7 @@ async function createRspackTargets(configFilePath, projectRoot, options, context
             '@nx/js:typescript-sync',
         ];
     }
-    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
+    (0, internal_2.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
     return { targets, metadata: {} };
 }
 function normalizeOptions(options) {

package/src/plugins/utils/apply-base-config.js

@@ -12,7 +12,7 @@ const hash_format_1 = require("./hash-format");
 const nx_tsconfig_paths_rspack_plugin_1 = require("./plugins/nx-tsconfig-paths-rspack-plugin");
 const get_terser_ecma_version_1 = require("./get-terser-ecma-version");
 const nodeExternals = require("webpack-node-externals");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 const get_non_buildable_libs_1 = require("./get-non-buildable-libs");
 const IGNORED_RSPACK_WARNINGS = [
     /The comment file/i,
@@ -201,7 +201,7 @@ function applyNxIndependentConfig(options, config) {
 function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
     const tsConfig = options.tsConfig ?? (0, js_1.getRootTsConfigPath)();
     const plugins = [];
-    const isUsingTsSolution = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+    const isUsingTsSolution = (0, internal_1.isUsingTsSolutionSetup)();
     const executorContext = {
         projectName: options.projectName,
         targetName: options.targetName,

package/src/plugins/utils/apply-react-config.d.ts

@@ -1,6 +1,3 @@
 import { Configuration, RspackOptionsNormalized } from '@rspack/core';
-import { SvgrOptions } from './models';
-export declare function applyReactConfig(options: {
-    svgr?: boolean | SvgrOptions;
-}, config?: Partial<RspackOptionsNormalized | Configuration>): void;
+export declare function applyReactConfig(options?: Record<string, any>, config?: Partial<RspackOptionsNormalized | Configuration>): void;
 //# sourceMappingURL=apply-react-config.d.ts.map

package/src/plugins/utils/apply-react-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-react-config.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/plugins/utils/apply-react-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEtE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,GAAG,WAAW,CAAA;CAAE,EACzC,MAAM,GAAE,OAAO,CAAC,uBAAuB,GAAG,aAAa,CAAM,GAC5D,IAAI,CA4CN"}
+{"version":3,"file":"apply-react-config.d.ts","sourceRoot":"","sources":["../../../../../../packages/rspack/src/plugins/utils/apply-react-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEtE,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACjC,MAAM,GAAE,OAAO,CAAC,uBAAuB,GAAG,aAAa,CAAM,GAC5D,IAAI,CAUN"}