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

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

package/src/plugins/nx-app-rspack-plugin/nx-app-rspack-plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxAppRspackPlugin = void 0;
+const normalize_options_1 = require("../utils/plugins/normalize-options");
+const apply_base_config_1 = require("../utils/apply-base-config");
+const apply_web_config_1 = require("../utils/apply-web-config");
+/**
+ * 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`.
+ */
+class NxAppRspackPlugin {
+    constructor(options = {}) {
+        // If we're building inferred targets, skip normalizing the build options
+        if (!global.NX_GRAPH_CREATION) {
+            this.options = (0, normalize_options_1.normalizeOptions)(options);
+        }
+    }
+    apply(compiler) {
+        // Default's to web
+        const target = this.options.target ?? compiler.options.target;
+        this.options.outputPath ??= compiler.options.output?.path;
+        if (typeof target === 'string') {
+            this.options.target = target;
+        }
+        (0, apply_base_config_1.applyBaseConfig)(this.options, compiler.options, {
+            useNormalizedEntry: true,
+        });
+        if (compiler.options.target) {
+            this.options.target = compiler.options.target;
+        }
+        if (this.options.target === 'web' || this.options.target === 'webworker') {
+            (0, apply_web_config_1.applyWebConfig)(this.options, compiler.options, {
+                useNormalizedEntry: true,
+            });
+        }
+    }
+}
+exports.NxAppRspackPlugin = NxAppRspackPlugin;

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

@@ -0,0 +1,8 @@
+import type { Compiler } from '@rspack/core';
+export declare class NxReactRspackPlugin {
+    private options;
+    constructor(options?: {
+        svgr?: boolean;
+    });
+    apply(compiler: Compiler): void;
+}

package/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxReactRspackPlugin = void 0;
+const apply_react_config_1 = require("../utils/apply-react-config");
+class NxReactRspackPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        (0, apply_react_config_1.applyReactConfig)(this.options, compiler.options);
+    }
+}
+exports.NxReactRspackPlugin = NxReactRspackPlugin;

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.d.ts

@@ -0,0 +1,31 @@
+import type { NxRspackExecutionContext } from '../../utils/config';
+import type { NxAppRspackPluginOptions } from '../utils/models';
+import type { Compiler, Configuration } from '@rspack/core';
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the rspack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+ withNx(),
+ (config) => {
+ return config;
+ }
+ );
+
+ Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+ Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+ The context options are created and passed to the legacy plugin function.
+
+ module.exports = async () => ({
+ plugins: [
+ ...otherPlugins,
+ await nxUseLegacyPlugin(require({path}), options),
+ ],
+ });
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Rspack configuration
+ */
+export declare function useLegacyNxPlugin(fn: (config: Configuration, ctx: NxRspackExecutionContext) => Promise<Configuration>, executorOptions: NxAppRspackPluginOptions): Promise<{
+    apply(compiler: Compiler): void;
+}>;

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLegacyNxPlugin = useLegacyNxPlugin;
+const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../utils/plugins/normalize-options");
+const configuration_1 = require("nx/src/config/configuration");
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the rspack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+ withNx(),
+ (config) => {
+ return config;
+ }
+ );
+
+ Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+ Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+ The context options are created and passed to the legacy plugin function.
+
+ module.exports = async () => ({
+ plugins: [
+ ...otherPlugins,
+ await nxUseLegacyPlugin(require({path}), options),
+ ],
+ });
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Rspack configuration
+ */
+async function useLegacyNxPlugin(fn, executorOptions) {
+    if (global.NX_GRAPH_CREATION) {
+        return;
+    }
+    const options = (0, normalize_options_1.normalizeOptions)(executorOptions);
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectName = process.env.NX_TASK_TARGET_PROJECT;
+    const project = projectGraph.nodes[projectName];
+    const targetName = process.env.NX_TASK_TARGET_TARGET;
+    const context = {
+        cwd: process.cwd(),
+        isVerbose: process.env.NX_VERBOSE_LOGGING === 'true',
+        root: devkit_1.workspaceRoot,
+        projectGraph,
+        projectsConfigurations: (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+        nxJsonConfiguration: (0, configuration_1.readNxJson)(devkit_1.workspaceRoot),
+        target: project.data.targets[targetName],
+        targetName: targetName,
+        projectName: projectName,
+    };
+    const configuration = process.env.NX_TASK_TARGET_CONFIGURATION;
+    const ctx = {
+        context,
+        options: options,
+        configuration,
+    };
+    return {
+        apply(compiler) {
+            compiler.hooks.beforeCompile.tapPromise('NxLegacyAsyncPlugin', () => {
+                return new Promise((resolve) => {
+                    fn(compiler.options, ctx).then((updated) => {
+                        // Merge options back shallowly since it's a fully functional configuration.
+                        // Most likely, the user modified the config in place, but this guarantees that updates are applied if users did something like:
+                        // `return { ...config, plugins: [...config.plugins, new MyPlugin()] }`
+                        Object.assign(compiler.options, updated);
+                        resolve();
+                    });
+                });
+            });
+        },
+    };
+}

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

@@ -59,11 +59,7 @@ function applyNxIndependentConfig(options, config) {
     // So to mitigate this we enable in memory caching when target is Node and in watch mode.
     config.cache = options.target === 'node' && options.watch ? true : undefined;
     config.devtool =
-        options.sourceMap === 'hidden'
-            ? 'hidden-source-map'
-            : options.sourceMap
-                ? 'source-map'
-                : false;
+        options.sourceMap === true ? 'source-map' : options.sourceMap;
     config.output = {
         ...(config.output ?? {}),
         libraryTarget: config.output?.libraryTarget ??
@@ -83,6 +79,7 @@ function applyNxIndependentConfig(options, config) {
         hashFunction: config.output?.hashFunction ?? 'xxhash64',
         // Disabled for performance
         pathinfo: config.output?.pathinfo ?? false,
+        clean: options.deleteOutputPath,
     };
     config.watch = options.watch;
     config.watchOptions = {

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

@@ -1,5 +1,5 @@
-import { type Configuration } from '@rspack/core';
+import { type Configuration, RspackOptionsNormalized } from '@rspack/core';
 import { NormalizedNxAppRspackPluginOptions } from './models';
-export declare function applyWebConfig(options: NormalizedNxAppRspackPluginOptions, config?: Configuration, { useNormalizedEntry, }?: {
+export declare function applyWebConfig(options: NormalizedNxAppRspackPluginOptions, config?: Partial<RspackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;

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

@@ -70,13 +70,6 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
             const resolvedPath = style.input.startsWith('.')
                 ? style.input
                 : (0, path_1.resolve)(options.root, style.input);
-            // Add style entry points.
-            if (entries[style.bundleName]) {
-                entries[style.bundleName].import.push(resolvedPath);
-            }
-            else {
-                entries[style.bundleName] = { import: [resolvedPath] };
-            }
             // Add global css paths.
             globalStylePaths.push(resolvedPath);
         });
@@ -290,7 +283,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
         }
     });
     config.optimization = !isProd
-        ? undefined
+        ? {}
         : {
             ...(config.optimization ?? {}),
             minimizer: [...(config.optimization?.minimizer ?? []), ...minimizer],

package/src/plugins/utils/models.d.ts

@@ -1,4 +1,4 @@
-import type { Mode } from '@rspack/core';
+import type { DevTool, Mode } from '@rspack/core';
 import type { ProjectGraph } from '@nx/devkit';
 import type { AssetGlob } from '@nx/js/src/utils/assets/assets';
 export interface SvgrOptions {
@@ -171,7 +171,7 @@ export interface NxAppRspackPluginOptions {
     /**
      * Generate source maps.
      */
-    sourceMap?: boolean | string;
+    sourceMap?: boolean | DevTool;
     /**
      * When `true`, `process.env.NODE_ENV` will be excluded from the bundle. Useful for building a web application to run in a Node environment.
      */

package/src/plugins/utils/plugins/normalize-options.js

@@ -81,7 +81,7 @@ function normalizeOptions(options) {
         sourceMap: combinedPluginAndMaybeExecutorOptions.sourceMap ?? !isProd,
         sourceRoot,
         styles: combinedPluginAndMaybeExecutorOptions.styles ?? [],
-        target: combinedPluginAndMaybeExecutorOptions.target,
+        target: combinedPluginAndMaybeExecutorOptions.target ?? 'web',
         targetName,
         vendorChunk: combinedPluginAndMaybeExecutorOptions.vendorChunk ?? !isProd,
     };

package/src/plugins/utils/plugins/nx-tsconfig-paths-rspack-plugin.js

@@ -16,7 +16,7 @@ class NxTsconfigPathsRspackPlugin {
     apply(compiler) {
         // TODO(Colum): Investigate the best way to handle this, currently it is not working and affecting HMR
         // // If we are not building libs from source, we need to remap paths so tsconfig may be updated.
-        // this.handleBuildLibsFromSource(compiler.options, this.options);
+        this.handleBuildLibsFromSource(compiler.options, this.options);
         const pathToTsconfig = !path.isAbsolute(this.options.tsConfig)
             ? path.join(devkit_1.workspaceRoot, this.options.tsConfig)
             : this.options.tsConfig;
@@ -44,7 +44,8 @@ class NxTsconfigPathsRspackPlugin {
         if (!options.buildLibsFromSource && options.targetName) {
             const remappedTarget = options.targetName === 'serve' ? 'build' : options.targetName;
             const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(undefined, options.projectGraph, options.root, options.projectName, remappedTarget, options.configurationName);
-            options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies);
+            options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies, true // There is an issue with Rspack that requires the baseUrl to be set in the generated tsconfig
+            );
             this.tmpTsConfigPath = options.tsConfig;
             if (options.targetName === 'serve') {
                 const buildableDependencies = dependencies

package/src/utils/create-compiler.d.ts

@@ -1,7 +1,7 @@
 import { ExecutorContext } from '@nx/devkit';
 import { Compiler, MultiCompiler } from '@rspack/core';
-import { RspackExecutorSchema } from '../executors/rspack/schema';
-export declare function createCompiler(options: RspackExecutorSchema & {
+import { NormalizedRspackExecutorSchema } from '../executors/rspack/schema';
+export declare function createCompiler(options: NormalizedRspackExecutorSchema & {
     devServer?: any;
 }, context: ExecutorContext): Promise<Compiler | MultiCompiler>;
 export declare function isMultiCompiler(compiler: Compiler | MultiCompiler): compiler is MultiCompiler;

package/src/utils/create-compiler.js

@@ -1,63 +1,26 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompiler = createCompiler;
 exports.isMultiCompiler = isMultiCompiler;
 const core_1 = require("@rspack/core");
-const resolve_user_defined_rspack_config_1 = require("./resolve-user-defined-rspack-config");
+const config_1 = require("../executors/rspack/lib/config");
 async function createCompiler(options, context) {
-    const pathToConfig = options.rspackConfig;
-    let userDefinedConfig = {};
-    if (options.tsConfig) {
-        userDefinedConfig = (0, resolve_user_defined_rspack_config_1.resolveUserDefinedRspackConfig)(pathToConfig, options.tsConfig);
-    }
-    else {
-        userDefinedConfig = await Promise.resolve(`${pathToConfig}`).then(s => __importStar(require(s))).then((x) => x.default || x);
-    }
-    if (typeof userDefinedConfig.then === 'function') {
-        userDefinedConfig = await userDefinedConfig;
-    }
-    let config = {};
-    if (typeof userDefinedConfig === 'function') {
-        config = await userDefinedConfig({ devServer: options.devServer }, { options, context });
+    const config = await (0, config_1.getRspackConfigs)(options, context);
+    if (!options.standardRspackConfigFunction) {
+        validateConfig(config);
     }
-    else {
-        config = userDefinedConfig;
-        config.devServer ??= options.devServer;
-    }
-    validateConfig(config);
     return (0, core_1.rspack)(config);
 }
 function isMultiCompiler(compiler) {
     return 'compilers' in compiler;
 }
 function validateConfig(config) {
-    if (!config.entry) {
-        throw new Error('Entry is required. Please set the `main` option in the executor or the `entry` property in the rspack config.');
-    }
-    if (!config.output) {
-        throw new Error('Output is required. Please set the `outputPath` option in the executor or the `output` property in the rspack config.');
-    }
+    [config].flat().forEach((config) => {
+        if (!config.entry) {
+            throw new Error('Entry is required. Please set the `main` option in the executor or the `entry` property in the rspack config.');
+        }
+        if (!config.output) {
+            throw new Error('Output is required. Please set the `outputPath` option in the executor or the `output` property in the rspack config.');
+        }
+    });
 }

package/src/utils/generator-utils.d.ts

@@ -1,6 +1,6 @@
 import { TargetConfiguration, Tree } from '@nx/devkit';
-import { ConfigurationSchema } from '../generators/configuration/schema';
-import { Framework } from '../generators/init/schema';
+import { type ConfigurationSchema } from '../generators/configuration/schema';
+import { type Framework } from '../generators/init/schema';
 export type Target = 'build' | 'serve';
 export type TargetFlags = Partial<Record<Target, boolean>>;
 export type UserProvidedTargetName = Partial<Record<Target, string>>;