@nx/rspack 20.1.0 → 20.2.0-beta.0

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

@@ -4,7 +4,6 @@ exports.applyWebConfig = applyWebConfig;
 const core_1 = require("@rspack/core");
 const instantiate_script_plugins_1 = require("./instantiate-script-plugins");
 const path_1 = require("path");
-const webpack_subresource_integrity_1 = require("webpack-subresource-integrity");
 const hash_format_1 = require("./hash-format");
 const normalize_entry_1 = require("./normalize-entry");
 const stylesheet_loaders_1 = require("./loaders/stylesheet-loaders");
@@ -35,15 +34,15 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
     if (options.index && options.generateIndexHtml) {
         plugins.push(new core_1.HtmlRspackPlugin({
             template: options.index,
-            sri: options.subresourceIntegrity ? 'sha256' : undefined,
+            sri: 'sha256',
             ...(options.baseHref ? { base: { href: options.baseHref } } : {}),
+            ...(config.output?.scriptType === 'module'
+                ? { scriptLoading: 'module' }
+                : {}),
         }));
     }
-    if (options.subresourceIntegrity) {
-        plugins.push(new webpack_subresource_integrity_1.SubresourceIntegrityPlugin());
-    }
     const minimizer = [];
-    if (stylesOptimization) {
+    if (isProd && stylesOptimization) {
         minimizer.push(new core_1.LightningCssMinimizerRspackPlugin({
             test: /\.(?:css|scss|sass|less|styl)$/,
         }));
@@ -272,12 +271,10 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
     }
     config.output = {
         ...(config.output ?? {}),
-        assetModuleFilename: '[name].[contenthash:20][ext]',
-        crossOriginLoading: options.subresourceIntegrity
-            ? 'anonymous'
-            : false,
+        assetModuleFilename: '[name].[contenthash:16][ext]',
+        crossOriginLoading: 'anonymous',
     };
-    // In case users customize their webpack config with unsupported entry.
+    // In case users customize their rspack config with unsupported entry.
     if (typeof config.entry === 'function')
         throw new Error('Entry function is not supported. Use an object.');
     if (typeof config.entry === 'string')
@@ -292,40 +289,42 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
             config.entry[entryName] = entryData.import;
         }
     });
-    config.optimization = {
-        ...(config.optimization ?? {}),
-        minimizer: [...(config.optimization?.minimizer ?? []), ...minimizer],
-        emitOnErrors: false,
-        moduleIds: 'deterministic',
-        runtimeChunk: options.runtimeChunk ? { name: 'runtime' } : false,
-        splitChunks: {
-            defaultSizeTypes: config.optimization?.splitChunks !== false
-                ? config.optimization?.splitChunks?.defaultSizeTypes
-                : ['...'],
-            maxAsyncRequests: Infinity,
-            cacheGroups: {
-                default: !!options.commonChunk && {
-                    chunks: 'async',
-                    minChunks: 2,
-                    priority: 10,
-                },
-                common: !!options.commonChunk && {
-                    name: 'common',
-                    chunks: 'async',
-                    minChunks: 2,
-                    enforce: true,
-                    priority: 5,
-                },
-                vendors: false,
-                vendor: !!options.vendorChunk && {
-                    name: 'vendor',
-                    chunks: (chunk) => chunk.name === 'main',
-                    enforce: true,
-                    test: /[\\/]node_modules[\\/]/,
+    config.optimization = !isProd
+        ? undefined
+        : {
+            ...(config.optimization ?? {}),
+            minimizer: [...(config.optimization?.minimizer ?? []), ...minimizer],
+            emitOnErrors: false,
+            moduleIds: 'deterministic',
+            runtimeChunk: options.runtimeChunk ? { name: 'runtime' } : false,
+            splitChunks: {
+                defaultSizeTypes: config.optimization?.splitChunks !== false
+                    ? config.optimization?.splitChunks?.defaultSizeTypes
+                    : ['...'],
+                maxAsyncRequests: Infinity,
+                cacheGroups: {
+                    default: !!options.commonChunk && {
+                        chunks: 'async',
+                        minChunks: 2,
+                        priority: 10,
+                    },
+                    common: !!options.commonChunk && {
+                        name: 'common',
+                        chunks: 'async',
+                        minChunks: 2,
+                        enforce: true,
+                        priority: 5,
+                    },
+                    vendors: false,
+                    vendor: !!options.vendorChunk && {
+                        name: 'vendor',
+                        chunks: (chunk) => chunk.name === 'main',
+                        enforce: true,
+                        test: /[\\/]node_modules[\\/]/,
+                    },
                 },
             },
-        },
-    };
+        };
     config.resolve.mainFields = ['browser', 'module', 'main'];
     config.module = {
         ...(config.module ?? {}),
@@ -364,7 +363,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
 }
 function getClientEnvironment(mode) {
     // Grab NODE_ENV and NX_PUBLIC_* environment variables and prepare them to be
-    // injected into the application via DefinePlugin in webpack configuration.
+    // injected into the application via DefinePlugin in rspack configuration.
     const nxPublicKeyRegex = /^NX_PUBLIC_/i;
     const raw = Object.keys(process.env)
         .filter((key) => nxPublicKeyRegex.test(key))
@@ -372,7 +371,7 @@ function getClientEnvironment(mode) {
         env[key] = process.env[key];
         return env;
     }, {});
-    // Stringify all values so we can feed into webpack DefinePlugin
+    // Stringify all values so we can feed into rspack DefinePlugin
     const stringified = {
         'process.env': Object.keys(raw).reduce((env, key) => {
             env[key] = JSON.stringify(raw[key]);

package/src/plugins/utils/get-terser-ecma-version.d.ts

@@ -0,0 +1 @@
+export declare function getTerserEcmaVersion(projectRoot: string): 2020 | 5;

package/src/plugins/utils/get-terser-ecma-version.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTerserEcmaVersion = getTerserEcmaVersion;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const browserslist = require("browserslist");
+const VALID_BROWSERSLIST_FILES = ['.browserslistrc', 'browserslist'];
+const ES5_BROWSERS = [
+    'ie 10',
+    'ie 11',
+    'safari 11',
+    'safari 11.1',
+    'safari 12',
+    'safari 12.1',
+    'safari 13',
+    'ios_saf 13.0',
+    'ios_saf 13.3',
+];
+function getTerserEcmaVersion(projectRoot) {
+    let pathToBrowserslistFile = '';
+    for (const browserslistFile of VALID_BROWSERSLIST_FILES) {
+        const fullPathToFile = path.join(projectRoot, browserslistFile);
+        if (fs.existsSync(fullPathToFile)) {
+            pathToBrowserslistFile = fullPathToFile;
+            break;
+        }
+    }
+    if (!pathToBrowserslistFile) {
+        return 2020;
+    }
+    const env = browserslist.loadConfig({ path: pathToBrowserslistFile });
+    const browsers = browserslist(env);
+    return browsers.some((b) => ES5_BROWSERS.includes(b)) ? 5 : 2020;
+}

package/src/plugins/utils/hash-format.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOutputHashFormat = getOutputHashFormat;
-function getOutputHashFormat(option, length = 20) {
+const devkit_1 = require("@nx/devkit");
+const MAX_HASH_LENGTH = 16;
+function getOutputHashFormat(option, length = MAX_HASH_LENGTH) {
+    if (length > MAX_HASH_LENGTH) {
+        devkit_1.logger.warn(`Hash format length cannot be longer than ${MAX_HASH_LENGTH}. Using default of ${MAX_HASH_LENGTH}.`);
+        length = MAX_HASH_LENGTH;
+    }
     const hashFormats = {
         none: { chunk: '', extract: '', file: '', script: '' },
         media: { chunk: '', extract: '', file: `.[hash:${length}]`, script: '' },

package/src/plugins/utils/loaders/stylesheet-loaders.js

@@ -82,7 +82,7 @@ function getCommonLoadersForGlobalStyle(options, includePaths) {
 }
 function postcssOptionsCreator(options, { includePaths, forCssModules = false, }) {
     const hashFormat = (0, hash_format_1.getOutputHashFormat)(options.outputHashing);
-    // PostCSS options depend on the webpack loader, but we need to set the `config` path as a string due to this check:
+    // PostCSS options depend on the rspack loader, but we need to set the `config` path as a string due to this check:
     // https://github.com/webpack-contrib/postcss-loader/blob/0d342b1/src/utils.js#L36
     const postcssOptions = (loader) => ({
         map: options.sourceMap &&

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

@@ -1,6 +1,11 @@
 import type { Mode } from '@rspack/core';
 import type { ProjectGraph } from '@nx/devkit';
 import type { AssetGlob } from '@nx/js/src/utils/assets/assets';
+export interface SvgrOptions {
+    svgo?: boolean;
+    titleProp?: boolean;
+    ref?: boolean;
+}
 export interface AssetGlobPattern {
     glob: string;
     input: string;
@@ -120,11 +125,11 @@ export interface NxAppRspackPluginOptions {
      */
     outputHashing?: any;
     /**
-     * Override `output.path` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     * Override `output.path` in rspack configuration. This setting is not recommended and exists for backwards compatibility.
      */
     outputPath?: string;
     /**
-     * Override `watchOptions.poll` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     * Override `watchOptions.poll` in rspack configuration. This setting is not recommended and exists for backwards compatibility.
      */
     poll?: number;
     /**
@@ -140,7 +145,7 @@ export interface NxAppRspackPluginOptions {
      */
     progress?: boolean;
     /**
-     * Add an additional chunk for the Webpack runtime. Defaults to `true` when `target === 'web'`.
+     * Add an additional chunk for the rspack runtime. Defaults to `true` when `target === 'web'`.
      */
     runtimeChunk?: boolean;
     /**
@@ -184,11 +189,7 @@ export interface NxAppRspackPluginOptions {
      */
     styles?: Array<ExtraEntryPointClass | string>;
     /**
-     * Enables the use of subresource integrity validation.
-     */
-    subresourceIntegrity?: boolean;
-    /**
-     * Override the `target` option in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     * Override the `target` option in rspack configuration. This setting is not recommended and exists for backwards compatibility.
      */
     target?: string | string[];
     /**

package/src/plugins/utils/plugins/generate-package-json-plugin.d.ts

@@ -0,0 +1,15 @@
+import { type Compiler, type RspackPluginInstance } from '@rspack/core';
+import { type ProjectGraph } from '@nx/devkit';
+export declare class GeneratePackageJsonPlugin implements RspackPluginInstance {
+    private readonly options;
+    constructor(options: {
+        skipPackageManager?: boolean;
+        tsConfig: string;
+        outputFileName: string;
+        root: string;
+        projectName: string;
+        targetName: string;
+        projectGraph: ProjectGraph;
+    });
+    apply(compiler: Compiler): void;
+}

package/src/plugins/utils/plugins/generate-package-json-plugin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratePackageJsonPlugin = void 0;
+const core_1 = require("@rspack/core");
+const js_1 = require("@nx/js");
+const devkit_1 = require("@nx/devkit");
+const pluginName = 'GeneratePackageJsonPlugin';
+class GeneratePackageJsonPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: pluginName,
+                stage: compiler.rspack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+            }, () => {
+                const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(this.options.root, this.options.projectName, this.options.projectGraph);
+                const importHelpers = !!(0, js_1.readTsConfig)(this.options.tsConfig).options
+                    .importHelpers;
+                const shouldAddHelperDependency = importHelpers &&
+                    helperDependencies.every((dep) => dep.target !== js_1.HelperDependency.tsc);
+                if (shouldAddHelperDependency) {
+                    helperDependencies.push({
+                        type: 'static',
+                        source: this.options.projectName,
+                        target: js_1.HelperDependency.tsc,
+                    });
+                }
+                const packageJson = (0, js_1.createPackageJson)(this.options.projectName, this.options.projectGraph, {
+                    target: this.options.targetName,
+                    root: this.options.root,
+                    isProduction: true,
+                    helperDependencies: helperDependencies.map((dep) => dep.target),
+                    skipPackageManager: this.options.skipPackageManager,
+                });
+                packageJson.main = packageJson.main ?? this.options.outputFileName;
+                compilation.emitAsset('package.json', new core_1.sources.RawSource((0, devkit_1.serializeJson)(packageJson)));
+                const packageManager = (0, devkit_1.detectPackageManager)(this.options.root);
+                compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new core_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.options.projectGraph, packageManager)));
+            });
+        });
+    }
+}
+exports.GeneratePackageJsonPlugin = GeneratePackageJsonPlugin;

package/src/plugins/utils/plugins/normalize-options.d.ts

@@ -0,0 +1,4 @@
+import { AssetGlobPattern, FileReplacement, NxAppRspackPluginOptions, NormalizedNxAppRspackPluginOptions } from '../models';
+export declare function normalizeOptions(options: NxAppRspackPluginOptions): NormalizedNxAppRspackPluginOptions;
+export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string, projectRoot: string, resolveRelativePathsToProjectRoot?: boolean): AssetGlobPattern[];
+export declare function normalizeFileReplacements(root: string, fileReplacements: FileReplacement[]): FileReplacement[];

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

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+exports.normalizeAssets = normalizeAssets;
+exports.normalizeFileReplacements = normalizeFileReplacements;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+function normalizeOptions(options) {
+    const combinedPluginAndMaybeExecutorOptions = {};
+    const isProd = process.env.NODE_ENV === 'production';
+    // Since this is invoked by the executor, the graph has already been created and cached.
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const taskDetailsFromBuildTarget = process.env.NX_BUILD_TARGET
+        ? (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph)
+        : undefined;
+    const projectName = taskDetailsFromBuildTarget
+        ? taskDetailsFromBuildTarget.project
+        : process.env.NX_TASK_TARGET_PROJECT;
+    const targetName = taskDetailsFromBuildTarget
+        ? taskDetailsFromBuildTarget.target
+        : process.env.NX_TASK_TARGET_TARGET;
+    const configurationName = taskDetailsFromBuildTarget
+        ? taskDetailsFromBuildTarget.configuration
+        : process.env.NX_TASK_TARGET_CONFIGURATION;
+    const projectNode = projectGraph.nodes[projectName];
+    const targetConfig = projectNode.data.targets[targetName];
+    normalizeRelativePaths(projectNode.data.root, options);
+    // Merge options from `@nx/rspack:rspack` into plugin options.
+    // Options from `@nx/rspack:rspack` take precedence.
+    const originalTargetOptions = targetConfig.options;
+    if (configurationName) {
+        Object.assign(originalTargetOptions, targetConfig.configurations?.[configurationName]);
+    }
+    // This could be called from dev-server which means we need to read `buildTarget` to get actual build options.
+    // Otherwise, the options are passed from the `@nx/rspack:rspack` executor.
+    if (originalTargetOptions.buildTarget) {
+        const buildTargetOptions = targetConfig.options;
+        if (configurationName) {
+            Object.assign(buildTargetOptions, targetConfig.configurations?.[configurationName]);
+        }
+        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
+        // executor options take precedence (especially for overriding with CLI args)
+        buildTargetOptions);
+    }
+    else {
+        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
+        // executor options take precedence (especially for overriding with CLI args)
+        originalTargetOptions);
+    }
+    const sourceRoot = projectNode.data.sourceRoot ?? projectNode.data.root;
+    if (!combinedPluginAndMaybeExecutorOptions.main) {
+        throw new Error(`Missing "main" option for the entry file. Set this option in your Nx rspack plugin.`);
+    }
+    return {
+        ...combinedPluginAndMaybeExecutorOptions,
+        assets: combinedPluginAndMaybeExecutorOptions.assets
+            ? normalizeAssets(combinedPluginAndMaybeExecutorOptions.assets, devkit_1.workspaceRoot, sourceRoot, projectNode.data.root)
+            : [],
+        baseHref: combinedPluginAndMaybeExecutorOptions.baseHref ?? '/',
+        buildLibsFromSource: combinedPluginAndMaybeExecutorOptions.buildLibsFromSource ?? true,
+        commonChunk: combinedPluginAndMaybeExecutorOptions.commonChunk ?? true,
+        configurationName,
+        deleteOutputPath: combinedPluginAndMaybeExecutorOptions.deleteOutputPath ?? true,
+        extractCss: combinedPluginAndMaybeExecutorOptions.extractCss ?? true,
+        fileReplacements: normalizeFileReplacements(devkit_1.workspaceRoot, combinedPluginAndMaybeExecutorOptions.fileReplacements),
+        generateIndexHtml: combinedPluginAndMaybeExecutorOptions.generateIndexHtml ?? true,
+        main: combinedPluginAndMaybeExecutorOptions.main,
+        namedChunks: combinedPluginAndMaybeExecutorOptions.namedChunks ?? !isProd,
+        optimization: combinedPluginAndMaybeExecutorOptions.optimization ?? isProd,
+        outputFileName: combinedPluginAndMaybeExecutorOptions.outputFileName ?? 'main.js',
+        outputHashing: combinedPluginAndMaybeExecutorOptions.outputHashing ??
+            (isProd ? 'all' : 'none'),
+        outputPath: combinedPluginAndMaybeExecutorOptions.outputPath,
+        projectGraph,
+        projectName,
+        projectRoot: projectNode.data.root,
+        root: devkit_1.workspaceRoot,
+        runtimeChunk: combinedPluginAndMaybeExecutorOptions.runtimeChunk ?? true,
+        scripts: combinedPluginAndMaybeExecutorOptions.scripts ?? [],
+        sourceMap: combinedPluginAndMaybeExecutorOptions.sourceMap ?? !isProd,
+        sourceRoot,
+        styles: combinedPluginAndMaybeExecutorOptions.styles ?? [],
+        target: combinedPluginAndMaybeExecutorOptions.target,
+        targetName,
+        vendorChunk: combinedPluginAndMaybeExecutorOptions.vendorChunk ?? !isProd,
+    };
+}
+function normalizeAssets(assets, root, sourceRoot, projectRoot, resolveRelativePathsToProjectRoot = true) {
+    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);
+            let resolvedAssetPath = (0, path_1.resolve)(root, assetPath);
+            if (resolveRelativePathsToProjectRoot && asset.input.startsWith('.')) {
+                const resolvedProjectRoot = (0, path_1.resolve)(root, projectRoot);
+                resolvedAssetPath = (0, path_1.resolve)(resolvedProjectRoot, assetPath);
+            }
+            return {
+                ...asset,
+                input: resolvedAssetPath,
+                // Now we remove starting slash to make rspack place it from the output root.
+                output: asset.output.replace(/^\//, ''),
+            };
+        }
+    });
+}
+function normalizeFileReplacements(root, fileReplacements) {
+    return fileReplacements
+        ? fileReplacements.map((fileReplacement) => ({
+            replace: (0, path_1.resolve)(root, fileReplacement.replace),
+            with: (0, path_1.resolve)(root, fileReplacement.with),
+        }))
+        : [];
+}
+function normalizeRelativePaths(projectRoot, options) {
+    for (const [fieldName, fieldValue] of Object.entries(options)) {
+        if (isRelativePath(fieldValue)) {
+            options[fieldName] = (0, path_1.join)(projectRoot, fieldValue);
+        }
+        else if (fieldName === 'additionalEntryPoints') {
+            for (let i = 0; i < fieldValue.length; i++) {
+                const v = fieldValue[i];
+                if (isRelativePath(v)) {
+                    fieldValue[i] = {
+                        entryName: (0, path_1.parse)(v).name,
+                        entryPath: (0, path_1.join)(projectRoot, v),
+                    };
+                }
+                else if (isRelativePath(v.entryPath)) {
+                    v.entryPath = (0, path_1.join)(projectRoot, v.entryPath);
+                }
+            }
+        }
+        else if (Array.isArray(fieldValue)) {
+            for (let i = 0; i < fieldValue.length; i++) {
+                if (isRelativePath(fieldValue[i])) {
+                    fieldValue[i] = (0, path_1.join)(projectRoot, fieldValue[i]);
+                }
+            }
+        }
+    }
+}
+function isRelativePath(val) {
+    return (typeof val === 'string' &&
+        (val.startsWith('./') ||
+            // Windows
+            val.startsWith('.\\')));
+}

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

@@ -0,0 +1,10 @@
+import { Compiler, type Configuration, type RspackOptionsNormalized } from '@rspack/core';
+import { NormalizedNxAppRspackPluginOptions } from '../models';
+export declare class NxTsconfigPathsRspackPlugin {
+    private options;
+    private tmpTsConfigPath;
+    constructor(options: NormalizedNxAppRspackPluginOptions);
+    apply(compiler: Compiler): void;
+    cleanupTmpTsConfigFile(): void;
+    handleBuildLibsFromSource(config: Partial<RspackOptionsNormalized | Configuration>, options: any): void;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxTsconfigPathsRspackPlugin = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const devkit_1 = require("@nx/devkit");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const rspack_nx_build_coordination_plugin_1 = require("./rspack-nx-build-coordination-plugin");
+const fs_1 = require("fs");
+class NxTsconfigPathsRspackPlugin {
+    constructor(options) {
+        this.options = options;
+        if (!this.options.tsConfig)
+            throw new Error(`Missing "tsConfig" option. Set this option in your Nx rspack plugin.`);
+    }
+    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);
+        const pathToTsconfig = !path.isAbsolute(this.options.tsConfig)
+            ? path.join(devkit_1.workspaceRoot, this.options.tsConfig)
+            : this.options.tsConfig;
+        const extensions = new Set([
+            ...['.ts', '.tsx', '.mjs', '.js', '.jsx'],
+            ...(compiler.options?.resolve?.extensions ?? []),
+        ]);
+        compiler.options.resolve = {
+            ...compiler.options.resolve,
+            extensions: [...extensions],
+            tsConfig: { configFile: pathToTsconfig },
+        };
+    }
+    cleanupTmpTsConfigFile() {
+        if (this.tmpTsConfigPath) {
+            try {
+                if (this.tmpTsConfigPath) {
+                    (0, fs_1.unlinkSync)(this.tmpTsConfigPath);
+                }
+            }
+            catch (e) { }
+        }
+    }
+    handleBuildLibsFromSource(config, options) {
+        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);
+            this.tmpTsConfigPath = options.tsConfig;
+            if (options.targetName === 'serve') {
+                const buildableDependencies = dependencies
+                    .filter((dependency) => dependency.node.type === 'lib')
+                    .map((dependency) => dependency.node.name)
+                    .join(',');
+                const buildCommand = `nx run-many --target=build --projects=${buildableDependencies}`;
+                if (buildableDependencies && buildableDependencies.length > 0) {
+                    config.plugins.push(new rspack_nx_build_coordination_plugin_1.RspackNxBuildCoordinationPlugin(buildCommand));
+                }
+            }
+        }
+    }
+}
+exports.NxTsconfigPathsRspackPlugin = NxTsconfigPathsRspackPlugin;

package/src/plugins/utils/plugins/rspack-nx-build-coordination-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Compiler } from '@rspack/core';
+export declare class RspackNxBuildCoordinationPlugin {
+    private readonly buildCmd;
+    private currentlyRunning;
+    private buildCmdProcess;
+    constructor(buildCmd: string, skipInitialBuild?: boolean);
+    apply(compiler: Compiler): void;
+    startWatchingBuildableLibs(): Promise<void>;
+    buildChangedProjects(): Promise<void>;
+    private createFileWatcher;
+}