@nx/rspack 20.1.0-beta.0 → 20.1.0-beta.2

package/src/utils/config.js

@@ -3,20 +3,67 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxRspackComposablePlugin = void 0;
 exports.isNxRspackComposablePlugin = isNxRspackComposablePlugin;
 exports.composePlugins = composePlugins;
+exports.composePluginsSync = composePluginsSync;
+const devkit_1 = require("@nx/devkit");
+const configuration_1 = require("nx/src/config/configuration");
 exports.nxRspackComposablePlugin = 'nxRspackComposablePlugin';
 function isNxRspackComposablePlugin(a) {
     return a?.[exports.nxRspackComposablePlugin] === true;
 }
 function composePlugins(...plugins) {
-    return Object.defineProperty(async function combined(config, ctx) {
+    return Object.assign(async function combined(config, ctx) {
+        // Rspack may be calling us as a standard config function.
+        // Build up Nx context from environment variables.
+        // This is to enable `@nx/webpack/plugin` to work with existing projects.
+        if (ctx['env']) {
+            ensureNxRspackExecutionContext(ctx);
+            // Build this from scratch since what webpack passes us is the env, not config,
+            // and `withNX()` creates a new config object anyway.
+            config = {};
+        }
         for (const plugin of plugins) {
             const fn = await plugin;
             config = await fn(config, ctx);
         }
         return config;
-    }, exports.nxRspackComposablePlugin, {
-        value: true,
-        enumerable: false,
-        writable: false,
+    }, {
+        [exports.nxRspackComposablePlugin]: true,
     });
 }
+function composePluginsSync(...plugins) {
+    return Object.assign(function combined(config, ctx) {
+        for (const plugin of plugins) {
+            config = plugin(config, ctx);
+        }
+        return config;
+    }, {
+        [exports.nxRspackComposablePlugin]: true,
+    });
+}
+function ensureNxRspackExecutionContext(ctx) {
+    const projectName = process.env.NX_TASK_TARGET_PROJECT;
+    const targetName = process.env.NX_TASK_TARGET_TARGET;
+    const configurationName = process.env.NX_TASK_TARGET_CONFIGURATION;
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectNode = projectGraph.nodes[projectName];
+    ctx.options ??= {
+        root: devkit_1.workspaceRoot,
+        projectRoot: projectNode.data.root,
+        sourceRoot: projectNode.data.sourceRoot ?? projectNode.data.root,
+        // These aren't actually needed since NxRspackPlugin and withNx both support them being undefined.
+        assets: undefined,
+        outputFileName: undefined,
+        rspackConfig: undefined,
+    };
+    ctx.context ??= {
+        projectName,
+        targetName,
+        configurationName,
+        projectsConfigurations: (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+        nxJsonConfiguration: (0, configuration_1.readNxJson)(devkit_1.workspaceRoot),
+        cwd: process.cwd(),
+        root: devkit_1.workspaceRoot,
+        isVerbose: process.env['NX_VERBOSE_LOGGING'] === 'true',
+        projectGraph,
+    };
+}

package/src/utils/generator-utils.js

@@ -133,6 +133,7 @@ function addOrChangeBuildTarget(tree, options, target) {
         outputPath: (0, devkit_1.joinPathFragments)('dist', 
         // If standalone project then use the project's name in dist.
         project.root === '.' ? project.name : project.root),
+        index: (0, devkit_1.joinPathFragments)(project.root, 'src/index.html'),
         main: determineMain(tree, options),
         tsConfig: determineTsConfig(tree, options),
         rspackConfig: (0, devkit_1.joinPathFragments)(project.root, 'rspack.config.js'),

package/src/utils/model.d.ts

@@ -1,6 +1,16 @@
-import { ExecutorContext } from '@nx/devkit';
-import { RspackExecutorSchema } from '../executors/rspack/schema';
-export interface SharedConfigContext {
-    options: RspackExecutorSchema;
-    context: ExecutorContext;
+export interface ExtraEntryPointClass {
+    bundleName?: string;
+    inject?: boolean;
+    input: string;
+    lazy?: boolean;
+}
+export type ExtraEntryPoint = ExtraEntryPointClass | string;
+export type NormalizedEntryPoint = Required<ExtraEntryPointClass>;
+export interface EmittedFile {
+    id?: string;
+    name?: string;
+    file: string;
+    extension: string;
+    initial: boolean;
+    asset?: boolean;
 }

package/src/utils/module-federation/with-module-federation/with-module-federation-ssr.d.ts

@@ -1,3 +1,3 @@
-import { SharedConfigContext } from '../../model';
 import { ModuleFederationConfig, NxModuleFederationConfigOverride } from '../models';
-export declare function withModuleFederationForSSR(options: ModuleFederationConfig, configOverride?: NxModuleFederationConfigOverride): Promise<(config: any, { context }: SharedConfigContext) => any>;
+import { NxRspackExecutionContext } from '../../config';
+export declare function withModuleFederationForSSR(options: ModuleFederationConfig, configOverride?: NxModuleFederationConfigOverride): Promise<(config: any, { context }: NxRspackExecutionContext) => any>;

package/src/utils/module-federation/with-module-federation/with-module-federation.d.ts

@@ -1,8 +1,8 @@
 import type { Configuration } from '@rspack/core';
-import { SharedConfigContext } from '../../model';
 import { ModuleFederationConfig, NxModuleFederationConfigOverride } from '../models';
+import { NxRspackExecutionContext } from '../../config';
 /**
  * @param {ModuleFederationConfig} options
  * @param {NxModuleFederationConfigOverride} configOverride
  */
-export declare function withModuleFederation(options: ModuleFederationConfig, configOverride?: NxModuleFederationConfigOverride): Promise<(config: Configuration, { context }: SharedConfigContext) => Configuration>;
+export declare function withModuleFederation(options: ModuleFederationConfig, configOverride?: NxModuleFederationConfigOverride): Promise<(config: Configuration, { context }: NxRspackExecutionContext) => Configuration>;

package/src/utils/read-rspack-options.js

@@ -22,6 +22,12 @@ async function readRspackOptions(rspackConfig) {
                 root: devkit_1.workspaceRoot,
                 projectRoot: '',
                 sourceRoot: '',
+                outputFileName: '',
+                assets: [],
+                main: '',
+                tsConfig: '',
+                outputPath: '',
+                rspackConfig: '',
             },
             context: {
                 root: devkit_1.workspaceRoot,

package/src/utils/with-nx.d.ts

@@ -1,3 +1,3 @@
 import { Configuration } from '@rspack/core';
-import { SharedConfigContext } from './model';
-export declare function withNx(_opts?: {}): (config: Configuration, { options, context }: SharedConfigContext) => Configuration;
+import { NxRspackExecutionContext } from './config';
+export declare function withNx(_opts?: {}): (config: Configuration, { options, context }: NxRspackExecutionContext) => Configuration;

package/src/utils/with-react.d.ts

@@ -1,3 +1,3 @@
 import { Configuration } from '@rspack/core';
-import { SharedConfigContext } from './model';
-export declare function withReact(opts?: {}): (config: Configuration, { options, context }: SharedConfigContext) => Configuration;
+import { NxRspackExecutionContext } from './config';
+export declare function withReact(opts?: {}): (config: Configuration, { options, context }: NxRspackExecutionContext) => Configuration;

package/src/utils/with-web.d.ts

@@ -1,9 +1,20 @@
 import { Configuration } from '@rspack/core';
-import { SharedConfigContext } from './model';
+import { ExtraEntryPointClass } from './model';
+import { NxRspackExecutionContext } from './config';
 export interface WithWebOptions {
+    baseHref?: string;
+    deployUrl?: string;
+    extractCss?: boolean;
+    generateIndexHtml?: boolean;
+    index?: string;
+    postcssConfig?: string;
+    scripts?: Array<ExtraEntryPointClass | string>;
+    styles?: Array<ExtraEntryPointClass | string>;
+    subresourceIntegrity?: boolean;
     stylePreprocessorOptions?: {
         includePaths?: string[];
     };
     cssModules?: boolean;
+    ssr?: boolean;
 }
-export declare function withWeb(opts?: WithWebOptions): (config: Configuration, { options, context }: SharedConfigContext) => Configuration;
+export declare function withWeb(pluginOptions?: WithWebOptions): (config: Configuration, { options, context }: NxRspackExecutionContext) => Configuration;

package/src/utils/with-web.js

@@ -1,110 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withWeb = withWeb;
-const tslib_1 = require("tslib");
-const core_1 = require("@rspack/core");
-const path = tslib_1.__importStar(require("path"));
-function withWeb(opts = {}) {
+const apply_web_config_1 = require("../plugins/utils/apply-web-config");
+const processed = new Set();
+function withWeb(pluginOptions = {}) {
     return function makeConfig(config, { options, context }) {
-        const isProd = process.env.NODE_ENV === 'production' || options.mode === 'production';
-        const projectRoot = path.join(context.root, context.projectGraph.nodes[context.projectName].data.root);
-        const includePaths = [];
-        if (opts?.stylePreprocessorOptions?.includePaths?.length > 0) {
-            opts.stylePreprocessorOptions.includePaths.forEach((includePath) => includePaths.push(path.resolve(context.root, includePath)));
+        if (processed.has(config)) {
+            return config;
         }
-        let lessPathOptions = {};
-        if (includePaths.length > 0) {
-            lessPathOptions = {
-                paths: includePaths,
-            };
-        }
-        return {
-            ...config,
-            target: config.target ?? 'web',
-            experiments: {
-                css: true,
-            },
-            module: {
-                ...config.module,
-                rules: [
-                    ...(config.module.rules || []),
-                    {
-                        test: /\.css$/,
-                        type: opts?.cssModules ? 'css/module' : undefined,
-                    },
-                    {
-                        test: /\.css$/,
-                        type: 'css',
-                        use: [
-                            {
-                                loader: require.resolve('postcss-loader'),
-                            },
-                        ],
-                    },
-                    {
-                        test: /\.scss$|\.sass$/,
-                        type: opts?.cssModules ? 'css/module' : undefined,
-                        use: [
-                            {
-                                loader: require.resolve('sass-loader'),
-                                options: {
-                                    sourceMap: !!options.sourceMap,
-                                    sassOptions: {
-                                        fiber: false,
-                                        // bootstrap-sass requires a minimum precision of 8
-                                        precision: 8,
-                                        includePaths,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        test: /.less$/,
-                        type: opts?.cssModules ? 'css/module' : undefined,
-                        use: [
-                            {
-                                loader: require.resolve('less-loader'),
-                                options: {
-                                    sourceMap: !!options.sourceMap,
-                                    lessOptions: {
-                                        javascriptEnabled: true,
-                                        ...lessPathOptions,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        test: /\.styl$/,
-                        use: [
-                            {
-                                loader: require.resolve('stylus-loader'),
-                                options: {
-                                    sourceMap: !!options.sourceMap,
-                                    stylusOptions: {
-                                        include: includePaths,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ].filter((a) => !!a),
-            },
-            plugins: [
-                ...config.plugins,
-                new core_1.rspack.HtmlRspackPlugin({
-                    template: options.indexHtml
-                        ? path.join(context.root, options.indexHtml)
-                        : path.join(projectRoot, 'src/index.html'),
-                    ...(options.baseHref ? { base: { href: options.baseHref } } : {}),
-                }),
-                new core_1.rspack.EnvironmentPlugin({
-                    NODE_ENV: isProd ? 'production' : 'development',
-                }),
-                new core_1.rspack.DefinePlugin(getClientEnvironment(isProd ? 'production' : undefined).stringified),
-            ],
-        };
+        (0, apply_web_config_1.applyWebConfig)({
+            ...options,
+            ...pluginOptions,
+            root: context.root,
+            projectName: context.projectName,
+            targetName: context.targetName,
+            configurationName: context.configurationName,
+            projectGraph: context.projectGraph,
+        }, config);
+        processed.add(config);
+        return config;
     };
 }
 function getClientEnvironment(mode) {