@nx/rspack 0.0.0-pr-28218-5048fd1

package/src/utils/normalize-assets.d.ts

@@ -0,0 +1 @@
+export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string): any[];

package/src/utils/normalize-assets.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAssets = normalizeAssets;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+function normalizeAssets(assets, root, sourceRoot) {
+    return assets.map((asset) => {
+        if (typeof asset === 'string') {
+            const assetPath = (0, devkit_1.normalizePath)(asset);
+            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
+            const resolvedSourceRoot = (0, path_1.resolve)(root, sourceRoot);
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new Error(`The ${resolvedAssetPath} asset path must start with the project source root: ${sourceRoot}`);
+            }
+            const isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
+            const input = isDirectory
+                ? resolvedAssetPath
+                : (0, path_1.dirname)(resolvedAssetPath);
+            const output = (0, path_1.relative)(resolvedSourceRoot, (0, path_1.resolve)(root, input));
+            const glob = isDirectory ? '**/*' : (0, path_1.basename)(resolvedAssetPath);
+            return {
+                input,
+                output,
+                glob,
+            };
+        }
+        else {
+            if (asset.output.startsWith('..')) {
+                throw new Error('An asset cannot be written to a location outside of the output path.');
+            }
+            const assetPath = (0, devkit_1.normalizePath)(asset.input);
+            const resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
+            return {
+                ...asset,
+                input: resolvedAssetPath,
+                // Now we remove starting slash to make Webpack place it from the output root.
+                output: asset.output.replace(/^\//, ''),
+            };
+        }
+    });
+}

package/src/utils/read-rspack-options.d.ts

@@ -0,0 +1,10 @@
+import { Configuration } from '@rspack/core';
+/**
+ * Reads the Rspack options from a give Rspack configuration. The configuration can be:
+ * 1. A standard config object
+ * 2. A standard function that returns a config object
+ * 3. A Nx-specific composable function that takes Nx context, rspack config, and returns the config object.
+ *
+ * @param rspackConfig
+ */
+export declare function readRspackOptions(rspackConfig: unknown): Promise<Configuration>;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRspackOptions = readRspackOptions;
+const devkit_1 = require("@nx/devkit");
+const config_1 = require("./config");
+/**
+ * Reads the Rspack options from a give Rspack configuration. The configuration can be:
+ * 1. A standard config object
+ * 2. A standard function that returns a config object
+ * 3. A Nx-specific composable function that takes Nx context, rspack config, and returns the config object.
+ *
+ * @param rspackConfig
+ */
+async function readRspackOptions(rspackConfig) {
+    let config;
+    if ((0, config_1.isNxRspackComposablePlugin)(rspackConfig)) {
+        config = await rspackConfig({}, {
+            // These values are only used during build-time, so passing stubs here just to read out
+            // the returned config object.
+            options: {
+                root: devkit_1.workspaceRoot,
+                projectRoot: '',
+                sourceRoot: '',
+            },
+            context: { root: devkit_1.workspaceRoot, cwd: undefined, isVerbose: false },
+        });
+    }
+    else if (typeof rspackConfig === 'function') {
+        config = await rspackConfig({
+            production: true, // we want the production build options
+        }, {});
+    }
+    else {
+        config = rspackConfig;
+    }
+    return config;
+}

package/src/utils/resolve-user-defined-rspack-config.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveUserDefinedRspackConfig(path: string, tsConfig: string, 
+/** Skip require cache and return latest content */
+reload?: boolean): any;

package/src/utils/resolve-user-defined-rspack-config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUserDefinedRspackConfig = resolveUserDefinedRspackConfig;
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const internal_1 = require("@nx/js/src/internal");
+function resolveUserDefinedRspackConfig(path, tsConfig, 
+/** Skip require cache and return latest content */
+reload = false) {
+    if (reload) {
+        // Clear cache if the path is in the cache
+        if (require.cache[path]) {
+            // Clear all entries because config may import other modules
+            (0, config_utils_1.clearRequireCache)();
+        }
+    }
+    // Don't transpile non-TS files. This prevents workspaces libs from being registered via tsconfig-paths.
+    // There's an issue here with Nx workspace where loading plugins from source (via tsconfig-paths) can lead to errors.
+    if (!/\.(ts|mts|cts)$/.test(path)) {
+        return require(path);
+    }
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const maybeCustomRspackConfig = require(path);
+    cleanupTranspiler();
+    // If the user provides a configuration in TS file
+    // then there are 3 cases for exporing an object. The first one is:
+    // `module.exports = { ... }`. And the second one is:
+    // `export default { ... }`. The ESM format is compiled into:
+    // `{ default: { ... } }`
+    // There is also a case of
+    // `{ default: { default: { ... } }`
+    const customRspackConfig = 'default' in maybeCustomRspackConfig
+        ? 'default' in maybeCustomRspackConfig.default
+            ? maybeCustomRspackConfig.default.default
+            : maybeCustomRspackConfig.default
+        : maybeCustomRspackConfig;
+    return customRspackConfig;
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,21 @@
+export declare const rspackCoreVersion = "1.0.5";
+export declare const rspackDevServerVersion = "1.0.5";
+export declare const rspackPluginMinifyVersion = "^0.7.5";
+export declare const rspackPluginReactRefreshVersion = "^1.0.0";
+export declare const lessLoaderVersion = "~11.1.3";
+export declare const reactVersion = "~18.2.0";
+export declare const reactRefreshVersion = "~0.14.0";
+export declare const reactDomVersion = "~18.2.0";
+export declare const typesReactVersion = "~18.0.28";
+export declare const typesReactDomVersion = "~18.0.10";
+export declare const nestjsCommonVersion = "~9.0.0";
+export declare const nestjsCoreVersion = "~9.0.0";
+export declare const nestjsPlatformExpressVersion = "~9.0.0";
+export declare const nestjsMicroservicesVersion = "~9.0.0";
+export declare const lessVersion = "4.1.3";
+export declare const sassVersion = "^1.42.1";
+export declare const stylusVersion = "^0.55.0";
+export declare const eslintPluginImportVersion = "2.27.5";
+export declare const eslintPluginJsxA11yVersion = "6.7.1";
+export declare const eslintPluginReactVersion = "7.32.2";
+export declare const eslintPluginReactHooksVersion = "4.6.0";

package/src/utils/versions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslintPluginReactHooksVersion = exports.eslintPluginReactVersion = exports.eslintPluginJsxA11yVersion = exports.eslintPluginImportVersion = exports.stylusVersion = exports.sassVersion = exports.lessVersion = exports.nestjsMicroservicesVersion = exports.nestjsPlatformExpressVersion = exports.nestjsCoreVersion = exports.nestjsCommonVersion = exports.typesReactDomVersion = exports.typesReactVersion = exports.reactDomVersion = exports.reactRefreshVersion = exports.reactVersion = exports.lessLoaderVersion = exports.rspackPluginReactRefreshVersion = exports.rspackPluginMinifyVersion = exports.rspackDevServerVersion = exports.rspackCoreVersion = void 0;
+exports.rspackCoreVersion = '1.0.5';
+exports.rspackDevServerVersion = '1.0.5';
+exports.rspackPluginMinifyVersion = '^0.7.5';
+exports.rspackPluginReactRefreshVersion = '^1.0.0';
+exports.lessLoaderVersion = '~11.1.3';
+exports.reactVersion = '~18.2.0';
+exports.reactRefreshVersion = '~0.14.0';
+exports.reactDomVersion = '~18.2.0';
+exports.typesReactVersion = '~18.0.28';
+exports.typesReactDomVersion = '~18.0.10';
+exports.nestjsCommonVersion = '~9.0.0';
+exports.nestjsCoreVersion = '~9.0.0';
+exports.nestjsPlatformExpressVersion = '~9.0.0';
+exports.nestjsMicroservicesVersion = '~9.0.0';
+exports.lessVersion = '4.1.3';
+exports.sassVersion = '^1.42.1';
+exports.stylusVersion = '^0.55.0';
+exports.eslintPluginImportVersion = '2.27.5';
+exports.eslintPluginJsxA11yVersion = '6.7.1';
+exports.eslintPluginReactVersion = '7.32.2';
+exports.eslintPluginReactHooksVersion = '4.6.0';

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

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

package/src/utils/with-nx.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNx = withNx;
+const tslib_1 = require("tslib");
+const core_1 = require("@rspack/core");
+const fs_1 = require("fs");
+const license_webpack_plugin_1 = require("license-webpack-plugin");
+const path = tslib_1.__importStar(require("path"));
+const path_1 = require("path");
+const generate_package_json_plugin_1 = require("../plugins/generate-package-json-plugin");
+const get_copy_patterns_1 = require("./get-copy-patterns");
+const normalize_assets_1 = require("./normalize-assets");
+function withNx(_opts = {}) {
+    return function makeConfig(config, { options, context }) {
+        const isProd = process.env.NODE_ENV === 'production' || options.mode === 'production';
+        const project = context.projectGraph.nodes[context.projectName];
+        const sourceRoot = path.join(context.root, project.data.sourceRoot);
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const tsconfigPaths = require('tsconfig-paths');
+        const { paths } = tsconfigPaths.loadConfig(options.tsConfig);
+        const alias = Object.keys(paths).reduce((acc, k) => {
+            acc[k] = path.join(context.root, paths[k][0]);
+            return acc;
+        }, {});
+        const plugins = config.plugins ?? [];
+        if (options.extractLicenses) {
+            /**
+             * Needed to prevent an issue with Rspack and Workspaces where the
+             * workspace's root package.json file is added to the dependency tree
+             */
+            let rootPackageJsonName;
+            const pathToRootPackageJson = (0, path_1.join)(context.root, 'package.json');
+            if ((0, fs_1.existsSync)(pathToRootPackageJson)) {
+                try {
+                    const rootPackageJson = JSON.parse((0, fs_1.readFileSync)(pathToRootPackageJson, 'utf-8'));
+                    rootPackageJsonName = rootPackageJson.name;
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            plugins.push(new license_webpack_plugin_1.LicenseWebpackPlugin({
+                stats: {
+                    warnings: false,
+                    errors: false,
+                },
+                outputFilename: `3rdpartylicenses.txt`,
+                /**
+                 * Needed to prevent an issue with Rspack and Workspaces where the
+                 * workspace's root package.json file is added to the dependency tree
+                 */
+                excludedPackageTest: (packageName) => {
+                    if (!rootPackageJsonName) {
+                        return false;
+                    }
+                    return packageName === rootPackageJsonName;
+                },
+            }));
+        }
+        if (options.generatePackageJson) {
+            const mainOutputFile = options.main.split('/').pop().split('.')[0] + '.js';
+            plugins.push(new generate_package_json_plugin_1.GeneratePackageJsonPlugin({
+                tsConfig: options.tsConfig,
+                outputFileName: options.outputFileName ?? mainOutputFile,
+            }, context));
+        }
+        plugins.push(new core_1.rspack.CopyRspackPlugin({
+            patterns: (0, get_copy_patterns_1.getCopyPatterns)((0, normalize_assets_1.normalizeAssets)(options.assets, context.root, sourceRoot)),
+        }));
+        plugins.push(new core_1.rspack.ProgressPlugin());
+        options.fileReplacements.forEach((item) => {
+            alias[item.replace] = item.with;
+        });
+        const externals = {};
+        let externalsType;
+        if (options.target === 'node') {
+            const projectDeps = context.projectGraph.dependencies[context.projectName];
+            for (const dep of Object.values(projectDeps)) {
+                const externalNode = context.projectGraph.externalNodes[dep.target];
+                if (externalNode) {
+                    externals[externalNode.data.packageName] =
+                        externalNode.data.packageName;
+                }
+            }
+            externalsType = 'commonjs';
+        }
+        const updated = {
+            ...config,
+            target: options.target,
+            mode: options.mode,
+            entry: {},
+            context: (0, path_1.join)(context.root, context.projectGraph.nodes[context.projectName].data.root),
+            devtool: options.sourceMap === 'hidden'
+                ? 'hidden-source-map'
+                : options.sourceMap
+                    ? 'source-map'
+                    : false,
+            output: {
+                path: path.join(context.root, options.outputPath),
+                publicPath: '/',
+                filename: isProd && options.target !== 'node'
+                    ? '[name].[contenthash:8].js'
+                    : '[name].js',
+                chunkFilename: isProd && options.target !== 'node'
+                    ? '[name].[contenthash:8].js'
+                    : '[name].js',
+                cssFilename: isProd && options.target !== 'node'
+                    ? '[name].[contenthash:8].css'
+                    : '[name].css',
+                cssChunkFilename: isProd && options.target !== 'node'
+                    ? '[name].[contenthash:8].css'
+                    : '[name].css',
+                assetModuleFilename: isProd && options.target !== 'node'
+                    ? '[name].[contenthash:8][ext]'
+                    : '[name][ext]',
+            },
+            devServer: {
+                ...(config.devServer ?? {}),
+                port: config.devServer?.port ?? 4200,
+                hot: config.devServer?.hot ?? true,
+            },
+            module: {
+                rules: [
+                    {
+                        test: /\.js$/,
+                        loader: 'builtin:swc-loader',
+                        exclude: /node_modules/,
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'ecmascript',
+                                },
+                                externalHelpers: true,
+                            },
+                        },
+                        type: 'javascript/auto',
+                    },
+                    {
+                        test: /\.ts$/,
+                        loader: 'builtin:swc-loader',
+                        exclude: /node_modules/,
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    decorators: true,
+                                },
+                                transform: {
+                                    legacyDecorator: true,
+                                    decoratorMetadata: true,
+                                },
+                                externalHelpers: true,
+                            },
+                        },
+                        type: 'javascript/auto',
+                    },
+                ],
+            },
+            plugins: plugins,
+            resolve: {
+                // There are some issues resolving workspace libs in a monorepo.
+                // It looks to be an issue with rspack itself, but will check back after Nx 16 release
+                // once I can reproduce a small example repo with rspack only.
+                alias,
+                // We need to define the extensions that rspack can resolve
+                extensions: ['...', '.ts', '.tsx', '.jsx'],
+                // tsConfigPath: path.join(context.root, options.tsConfig),
+            },
+            infrastructureLogging: {
+                debug: false,
+            },
+            externals,
+            externalsType,
+            stats: {
+                colors: true,
+                preset: 'normal',
+            },
+        };
+        const mainEntry = options.main
+            ? options.outputFileName
+                ? path.parse(options.outputFileName).name
+                : 'main'
+            : 'main';
+        updated.entry[mainEntry] = path.resolve(context.root, options.main);
+        return updated;
+    };
+}

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

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

package/src/utils/with-react.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withReact = withReact;
+const with_web_1 = require("./with-web");
+function withReact(opts = {}) {
+    return function makeConfig(config, { options, context }) {
+        const isDev = process.env.NODE_ENV === 'development' || options.mode === 'development';
+        config = (0, with_web_1.withWeb)({ ...opts, cssModules: true })(config, {
+            options,
+            context,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const ReactRefreshPlugin = require('@rspack/plugin-react-refresh');
+        const react = {
+            runtime: 'automatic',
+            development: isDev,
+            refresh: isDev,
+        };
+        return {
+            ...config,
+            plugins: [
+                ...(config.plugins || []),
+                isDev && new ReactRefreshPlugin(),
+            ].filter(Boolean),
+            module: {
+                ...config.module,
+                rules: [
+                    ...(config.module.rules || []),
+                    {
+                        test: /\.jsx$/,
+                        loader: 'builtin:swc-loader',
+                        exclude: /node_modules/,
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'ecmascript',
+                                    jsx: true,
+                                },
+                                transform: {
+                                    react,
+                                },
+                                externalHelpers: true,
+                            },
+                        },
+                        type: 'javascript/auto',
+                    },
+                    {
+                        test: /\.tsx$/,
+                        loader: 'builtin:swc-loader',
+                        exclude: /node_modules/,
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                },
+                                transform: {
+                                    react,
+                                },
+                                externalHelpers: true,
+                            },
+                        },
+                        type: 'javascript/auto',
+                    },
+                ],
+            },
+        };
+    };
+}

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

@@ -0,0 +1,9 @@
+import { Configuration } from '@rspack/core';
+import { SharedConfigContext } from './model';
+export interface WithWebOptions {
+    stylePreprocessorOptions?: {
+        includePaths?: string[];
+    };
+    cssModules?: boolean;
+}
+export declare function withWeb(opts?: WithWebOptions): (config: Configuration, { options, context }: SharedConfigContext) => Configuration;

package/src/utils/with-web.js

@@ -0,0 +1,106 @@
+"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 = {}) {
+    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)));
+        }
+        let lessPathOptions = {};
+        if (includePaths.length > 0) {
+            lessPathOptions = {
+                paths: includePaths,
+            };
+        }
+        return {
+            ...config,
+            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'),
+                }),
+                new core_1.rspack.DefinePlugin({
+                    'process.env.NODE_ENV': isProd ? "'production'" : "'development'",
+                }),
+            ],
+        };
+    };
+}