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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/rspack",
   "description": "The Nx Plugin for Rspack contains executors and generators that support building applications using Rspack.",
-  "version": "20.2.0-beta.1",
+  "version": "20.2.0-beta.2",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -24,9 +24,9 @@
   "generators": "./generators.json",
   "executors": "./executors.json",
   "dependencies": {
-    "@nx/js": "20.2.0-beta.1",
-    "@nx/devkit": "20.2.0-beta.1",
-    "@nx/web": "20.2.0-beta.1",
+    "@nx/js": "20.2.0-beta.2",
+    "@nx/devkit": "20.2.0-beta.2",
+    "@nx/web": "20.2.0-beta.2",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "@rspack/core": "^1.0.4",
     "@rspack/dev-server": "^1.0.4",

package/src/executors/rspack/lib/config.d.ts

@@ -0,0 +1,6 @@
+import { ExecutorContext } from '@nx/devkit';
+import { type Configuration } from '@rspack/core';
+import { type NormalizedRspackExecutorSchema } from '../schema';
+export declare function getRspackConfigs(options: NormalizedRspackExecutorSchema & {
+    devServer?: any;
+}, context: ExecutorContext): Promise<Configuration | Configuration[]>;

package/src/executors/rspack/lib/config.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRspackConfigs = getRspackConfigs;
+const config_1 = require("../../../utils/config");
+const resolve_user_defined_rspack_config_1 = require("../../../utils/resolve-user-defined-rspack-config");
+const with_nx_1 = require("../../../utils/with-nx");
+const with_web_1 = require("../../../utils/with-web");
+async function getRspackConfigs(options, context) {
+    let userDefinedConfig = (0, resolve_user_defined_rspack_config_1.resolveUserDefinedRspackConfig)(options.rspackConfig, options.tsConfig);
+    if (typeof userDefinedConfig.then === 'function') {
+        userDefinedConfig = await userDefinedConfig;
+    }
+    const config = (options.target === 'web'
+        ? (0, config_1.composePluginsSync)((0, with_nx_1.withNx)(options), (0, with_web_1.withWeb)(options))
+        : (0, with_nx_1.withNx)(options))({}, { options, context });
+    if ((typeof userDefinedConfig === 'function' &&
+        (0, config_1.isNxRspackComposablePlugin)(userDefinedConfig)) ||
+        !options.standardRspackConfigFunction) {
+        // Old behavior, call the Nx-specific rspack config function that user exports
+        return await userDefinedConfig(config, {
+            options,
+            context,
+            configuration: context.configurationName,
+        });
+    }
+    else if (userDefinedConfig) {
+        if (typeof userDefinedConfig === 'function') {
+            // assume it's an async standard rspack config function which operates similar to webpack
+            // https://webpack.js.org/configuration/configuration-types/#exporting-a-promise
+            return await userDefinedConfig(process.env.NODE_ENV, {});
+        }
+        // New behavior, we want the rspack config to export object
+        return userDefinedConfig;
+    }
+    else {
+        // Fallback case, if we cannot find a rspack config path
+        return config;
+    }
+}

package/src/executors/rspack/rspack.impl.js

@@ -1,32 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = runExecutor;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
 const js_1 = require("@nx/js");
 const fs_1 = require("fs");
-const path = tslib_1.__importStar(require("path"));
 const create_compiler_1 = require("../../utils/create-compiler");
 const mode_utils_1 = require("../../utils/mode-utils");
 const normalize_options_1 = require("./lib/normalize-options");
+const path_1 = require("path");
 async function* runExecutor(options, context) {
     process.env.NODE_ENV ??= options.mode ?? 'production';
     options.target ??= 'web';
+    const metadata = context.projectsConfigurations.projects[context.projectName];
+    const sourceRoot = metadata.sourceRoot;
+    const normalizedOptions = (0, normalize_options_1.normalizeOptions)(options, context.root, metadata.root, sourceRoot);
     if ((0, mode_utils_1.isMode)(process.env.NODE_ENV)) {
-        options.mode = process.env.NODE_ENV;
+        normalizedOptions.mode = process.env.NODE_ENV;
     }
-    if (options.typeCheck) {
-        await executeTypeCheck(options, context);
+    if (normalizedOptions.typeCheck) {
+        await executeTypeCheck(normalizedOptions, context);
     }
     // Mimic --clean from webpack.
-    (0, fs_1.rmSync)(path.join(context.root, options.outputPath), {
+    (0, fs_1.rmSync)((0, path_1.join)(context.root, normalizedOptions.outputPath), {
         force: true,
         recursive: true,
     });
-    const metadata = context.projectsConfigurations.projects[context.projectName];
-    const sourceRoot = metadata.sourceRoot;
-    const normalizedOptions = (0, normalize_options_1.normalizeOptions)(options, context.root, metadata.root, sourceRoot);
     const compiler = await (0, create_compiler_1.createCompiler)(normalizedOptions, context);
     const iterable = (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
         if (options.watch) {
@@ -49,7 +48,7 @@ async function* runExecutor(options, context) {
                 }
                 next({
                     success: !stats.hasErrors(),
-                    outfile: path.resolve(context.root, normalizedOptions.outputPath, 'main.js'),
+                    outfile: (0, path_1.resolve)(context.root, normalizedOptions.outputPath, 'main.js'),
                 });
             });
             registerCleanupCallback(() => {
@@ -79,7 +78,7 @@ async function* runExecutor(options, context) {
                     }
                     next({
                         success: !stats.hasErrors(),
-                        outfile: path.resolve(context.root, normalizedOptions.outputPath, 'main.js'),
+                        outfile: (0, path_1.resolve)(context.root, normalizedOptions.outputPath, 'main.js'),
                     });
                     done();
                 });
@@ -103,7 +102,7 @@ function registerCleanupCallback(callback) {
 async function executeTypeCheck(options, context) {
     const projectConfiguration = context.projectGraph.nodes[context.projectName].data;
     const result = await (0, js_1.runTypeCheck)({
-        workspaceRoot: path.resolve(projectConfiguration.root),
+        workspaceRoot: (0, path_1.resolve)(projectConfiguration.root),
         tsConfigPath: options.tsConfig,
         mode: 'noEmit',
     });

package/src/executors/rspack/schema.d.ts

@@ -1,28 +1,49 @@
-import type { Mode } from '@rspack/core';
+import type { DevTool, Mode } from '@rspack/core';
 
 export interface RspackExecutorSchema {
-  target?: 'web' | 'node';
-  main?: string;
-  index?: string;
-  tsConfig?: string;
-  typeCheck?: boolean;
-  skipTypeChecking?: boolean;
-  outputPath?: string;
-  outputFileName?: string;
-  index?: string;
-  indexHtml?: string;
-  mode?: Mode;
-  watch?: boolean;
+  additionalEntryPoints?: AdditionalEntryPoint[];
+  assets?: Array<AssetGlobPattern | string>;
   baseHref?: string;
+  buildLibsFromSource?: boolean;
   deployUrl?: string;
-
-  rspackConfig: string;
-  optimization?: boolean | OptimizationOptions;
-  sourceMap?: boolean | string;
-  assets?: any[];
+  extractCss?: boolean;
   extractLicenses?: boolean;
+  externalDependencies?: 'all' | 'none' | string[];
   fileReplacements?: FileReplacement[];
+  generateIndexHtml?: boolean;
   generatePackageJson?: boolean;
+  index?: string;
+  indexHtml?: string;
+  main?: string;
+  memoryLimit?: number;
+  mode?: Mode;
+  namedChunks?: boolean;
+  optimization?: boolean | OptimizationOptions;
+  outputFileName?: string;
+  outputHashing?: any;
+  outputPath?: string;
+  poll?: number;
+  polyfills?: string;
+  postcssConfig?: string;
+  progress?: boolean;
+  publicPath?: string;
+  rebaseRootRelative?: boolean;
+  rspackConfig: string;
+  runtimeChunk?: boolean;
+  scripts?: Array<ExtraEntryPointClass | string>;
+  skipTypeChecking?: boolean;
+  sourceMap?: boolean | DevTool;
+  standardRspackConfigFunction?: boolean;
+  statsJson?: boolean;
+  stylePreprocessorOptions?: any;
+  styles?: Array<ExtraEntryPointClass | string>;
+  target?: 'web' | 'node';
+  transformers?: TransformerEntry[];
+  tsConfig?: string;
+  typeCheck?: boolean;
+  verbose?: boolean;
+  vendorChunk?: boolean;
+  watch?: boolean;
 }
 
 export interface AssetGlobPattern {

package/src/executors/rspack/schema.json

@@ -129,6 +129,144 @@
     "generatePackageJson": {
       "type": "boolean",
       "description": "Generates a `package.json` and pruned lock file with the project's `node_module` dependencies populated for installing in a container. If a `package.json` exists in the project's directory, it will be reused with dependencies populated."
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "entryName": {
+            "type": "string",
+            "description": "Name of the additional entry file."
+          },
+          "entryPath": {
+            "type": "string",
+            "description": "Path to the additional entry file.",
+            "x-completion-type": "file",
+            "x-completion-glob": "**/*@(.js|.ts)"
+          }
+        }
+      }
+    },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source instead of building them separately. If set to `false`, the `tsConfig` option must also be set to remap paths.",
+      "default": true
+    },
+    "extractCss": {
+      "type": "boolean",
+      "description": "Extract CSS into a `.css` file."
+    },
+    "externalDependencies": {
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["none", "all"]
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ],
+      "description": "Dependencies to keep external to the bundle. (`all` (default), `none`, or an array of module names)"
+    },
+    "generateIndexHtml": {
+      "type": "boolean",
+      "description": "Generates `index.html` file to the output path. This can be turned off if using a webpack plugin to generate HTML such as `html-webpack-plugin`."
+    },
+    "memoryLimit": {
+      "type": "number",
+      "description": "Memory limit for type checking service process in `MB`."
+    },
+    "namedChunks": {
+      "type": "boolean",
+      "description": "Names the produced bundles according to their entry file."
+    },
+    "outputHashing": {
+      "type": "string",
+      "description": "Define the output filename cache-busting hashing mode.",
+      "enum": ["none", "all", "media", "bundles"]
+    },
+    "poll": {
+      "type": "number",
+      "description": "Enable and define the file watching poll time period."
+    },
+    "polyfills": {
+      "type": "string",
+      "description": "Polyfills to load before application",
+      "x-completion-type": "file",
+      "x-completion-glob": "**/*@(.js|.ts|.tsx)"
+    },
+    "postcssConfig": {
+      "type": "string",
+      "description": "Set a path to PostCSS config that applies to the app and all libs. Defaults to `undefined`, which auto-detects postcss.config.js files in each `app`/`lib` directory."
+    },
+    "progress": {
+      "type": "boolean",
+      "description": "Log progress to the console while building."
+    },
+    "publicPath": {
+      "type": "string",
+      "description": "Set a public path for assets resources with absolute paths."
+    },
+    "rebaseRootRelative": {
+      "type": "boolean",
+      "description": "Whether to rebase absolute path for assets in postcss cli resources."
+    },
+    "runtimeChunk": {
+      "type": "boolean",
+      "description": "Use a separate bundle containing the runtime."
+    },
+    "scripts": {
+      "type": "array",
+      "description": "External Scripts which will be included before the main application entry.",
+      "items": {
+        "$ref": "#/definitions/extraEntryPoint"
+      }
+    },
+    "standardRspackConfigFunction": {
+      "type": "boolean",
+      "description": "Set to true if the rspack config exports a standard rspack function, not an Nx-specific one. See: https://rspack.dev/config/",
+      "default": false
+    },
+    "statsJson": {
+      "type": "boolean",
+      "description": "Generates a 'stats.json' file which can be analyzed using tools such as: 'webpack-bundle-analyzer' See: https://rspack.dev/guide/optimization/analysis"
+    },
+    "stylePreprocessorOptions": {
+      "description": "Options to pass to style preprocessors.",
+      "type": "object",
+      "properties": {
+        "includePaths": {
+          "description": "Paths to include. Paths will be resolved to project root.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "styles": {
+      "type": "array",
+      "description": "External Styles which will be included with the application",
+      "items": {
+        "$ref": "#/definitions/extraEntryPoint"
+      }
+    },
+    "transformers": {
+      "type": "array",
+      "description": "List of TypeScript Compiler Transfomers Plugins.",
+      "aliases": ["tsPlugins"],
+      "items": {
+        "$ref": "#/definitions/transformerPattern"
+      }
+    },
+    "vendorChunk": {
+      "type": "boolean",
+      "description": "Use a separate bundle containing only vendor libraries."
     }
   },
   "required": ["rspackConfig"],
@@ -170,6 +308,59 @@
           "type": "string"
         }
       ]
+    },
+    "extraEntryPoint": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "input": {
+              "type": "string",
+              "description": "The file to include.",
+              "x-completion-type": "file",
+              "x-completion-glob": "**/*@(.css|.scss|.less|.sass|.styl|.stylus)"
+            },
+            "bundleName": {
+              "type": "string",
+              "description": "The bundle name for this extra entry point."
+            },
+            "inject": {
+              "type": "boolean",
+              "description": "If the bundle will be referenced in the HTML file.",
+              "default": true
+            }
+          },
+          "additionalProperties": false,
+          "required": ["input"]
+        },
+        {
+          "type": "string",
+          "description": "The file to include.",
+          "x-completion-type": "file",
+          "x-completion-glob": "**/*@(.css|.scss|.less|.sass|.styl|.stylus)"
+        }
+      ]
+    },
+    "transformerPattern": {
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "options": {
+              "type": "object",
+              "additionalProperties": true
+            }
+          },
+          "additionalProperties": false,
+          "required": ["name"]
+        }
+      ]
     }
   }
 }

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 ??

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

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/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,52 +1,11 @@
 "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 });
-    }
-    else {
-        config = userDefinedConfig;
-        config.devServer ??= options.devServer;
-    }
+    const config = await (0, config_1.getRspackConfigs)(options, context);
     validateConfig(config);
     return (0, core_1.rspack)(config);
 }
@@ -54,10 +13,12 @@ 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/module-federation/with-module-federation/with-module-federation-ssr.js

@@ -13,6 +13,9 @@ async function withModuleFederationForSSR(options, configOverride) {
     return (config, { context }) => {
         config.target = 'async-node';
         config.output.uniqueName = options.name;
+        config.output.library = {
+            type: 'commonjs-module',
+        };
         config.optimization = {
             ...(config.optimization ?? {}),
             runtimeChunk: false,
@@ -28,6 +31,10 @@ async function withModuleFederationForSSR(options, configOverride) {
                 ...sharedDependencies,
             },
             isServer: true,
+            library: {
+                type: 'commonjs-module',
+            },
+            remoteType: 'script',
             /**
              * Apply user-defined config overrides
              */