@nx/rspack 21.2.0-beta.2 → 21.2.0-beta.4

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": "21.2.0-beta.2",
+  "version": "21.2.0-beta.4",
   "type": "commonjs",
   "repository": {
     "type": "git",
@@ -24,10 +24,10 @@
   "generators": "./generators.json",
   "executors": "./executors.json",
   "dependencies": {
-    "@nx/js": "21.2.0-beta.2",
-    "@nx/devkit": "21.2.0-beta.2",
-    "@nx/web": "21.2.0-beta.2",
-    "@nx/module-federation": "21.2.0-beta.2",
+    "@nx/js": "21.2.0-beta.4",
+    "@nx/devkit": "21.2.0-beta.4",
+    "@nx/web": "21.2.0-beta.4",
+    "@nx/module-federation": "21.2.0-beta.4",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "@rspack/core": "^1.3.8",
     "@rspack/dev-server": "^1.1.1",

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

@@ -18,7 +18,7 @@ async function* runExecutor(options, context) {
     if ((0, mode_utils_1.isMode)(process.env.NODE_ENV)) {
         normalizedOptions.mode = process.env.NODE_ENV;
     }
-    if (normalizedOptions.typeCheck) {
+    if (!normalizedOptions.skipTypeChecking) {
         await executeTypeCheck(normalizedOptions, context);
     }
     // Mimic --clean from webpack.

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

@@ -19,6 +19,12 @@ const IGNORED_RSPACK_WARNINGS = [
     /could not find any license/i,
 ];
 const extensions = ['...', '.ts', '.tsx', '.mjs', '.js', '.jsx'];
+const extensionAlias = {
+    '.js': ['.ts', '.tsx', '.js', '.jsx'],
+    '.mjs': ['.mts', '.mjs'],
+    '.cjs': ['.cts', '.cjs'],
+    '.jsx': ['.tsx', '.jsx'],
+};
 const mainFields = ['module', 'main'];
 function applyBaseConfig(options, config = {}, { useNormalizedEntry, } = {}) {
     // Defaults that was applied from executor schema previously.
@@ -306,6 +312,10 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
     config.resolve = {
         ...config.resolve,
         extensions: [...(config?.resolve?.extensions ?? []), ...extensions],
+        extensionAlias: {
+            ...(config.resolve?.extensionAlias ?? {}),
+            ...extensionAlias,
+        },
         alias: {
             ...(config.resolve?.alias ?? {}),
             ...(options.fileReplacements?.reduce((aliases, replacement) => ({

package/src/plugins/utils/get-non-buildable-libs.d.ts

@@ -1,4 +1,5 @@
 import { type ProjectGraph } from '@nx/devkit';
+export declare function createAllowlistFromExports(packageName: string, exports: Record<string, any> | string | undefined): (string | RegExp)[];
 /**
  * Get all non-buildable libraries in the project graph for a given project.
  * This function retrieves all direct and transitive dependencies of a project,
@@ -7,4 +8,4 @@ import { type ProjectGraph } from '@nx/devkit';
  * @param projectName The project name to get dependencies for
  * @returns A list of all non-buildable libraries that the project depends on, including transitive dependencies.
  */
-export declare function getNonBuildableLibs(graph: ProjectGraph, projectName: string): string[];
+export declare function getNonBuildableLibs(graph: ProjectGraph, projectName: string): (string | RegExp)[];

package/src/plugins/utils/get-non-buildable-libs.js

@@ -1,8 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllowlistFromExports = createAllowlistFromExports;
 exports.getNonBuildableLibs = getNonBuildableLibs;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
 const get_transitive_deps_1 = require("./get-transitive-deps");
 const is_lib_buildable_1 = require("./is-lib-buildable");
+function escapePackageName(packageName) {
+    return packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function escapeRegexAndConvertWildcard(pattern) {
+    return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*');
+}
+function resolveConditionalExport(target) {
+    if (typeof target === 'string') {
+        return target;
+    }
+    if (typeof target === 'object' && target !== null) {
+        // Priority order for conditions
+        const conditions = ['development', 'import', 'require', 'default'];
+        for (const condition of conditions) {
+            if (target[condition] && typeof target[condition] === 'string') {
+                return target[condition];
+            }
+        }
+    }
+    return null;
+}
+function createAllowlistFromExports(packageName, exports) {
+    if (!exports) {
+        return [packageName];
+    }
+    const allowlist = [];
+    allowlist.push(packageName);
+    if (typeof exports === 'string') {
+        return allowlist;
+    }
+    if (typeof exports === 'object') {
+        for (const [exportPath, target] of Object.entries(exports)) {
+            if (typeof exportPath !== 'string')
+                continue;
+            const resolvedTarget = resolveConditionalExport(target);
+            if (!resolvedTarget)
+                continue;
+            if (exportPath === '.') {
+                continue;
+            }
+            else if (exportPath.startsWith('./')) {
+                const subpath = exportPath.slice(2);
+                if (subpath.includes('*')) {
+                    const regexPattern = escapeRegexAndConvertWildcard(subpath);
+                    allowlist.push(new RegExp(`^${escapePackageName(packageName)}/${regexPattern}$`));
+                }
+                else {
+                    allowlist.push(`${packageName}/${subpath}`);
+                }
+            }
+        }
+    }
+    return allowlist;
+}
 /**
  * Get all non-buildable libraries in the project graph for a given project.
  * This function retrieves all direct and transitive dependencies of a project,
@@ -24,11 +81,32 @@ function getNonBuildableLibs(graph, projectName) {
             return false;
         return !(0, is_lib_buildable_1.isBuildableLibrary)(node);
     });
-    // Add direct non-buildable dependencies
+    // Add direct non-buildable dependencies with expanded export patterns
     for (const dep of directNonBuildable) {
-        const packageName = graph.nodes?.[dep.target]?.data?.metadata?.js?.packageName;
+        const node = graph.nodes?.[dep.target];
+        const packageName = node?.data?.metadata?.js?.packageName;
         if (packageName) {
-            allNonBuildable.add(packageName);
+            // Get exports from project metadata first (most reliable)
+            const packageExports = node?.data?.metadata?.js?.packageExports;
+            if (packageExports) {
+                // Use metadata exports if available
+                const allowlistPatterns = createAllowlistFromExports(packageName, packageExports);
+                allowlistPatterns.forEach((pattern) => allNonBuildable.add(pattern));
+            }
+            else {
+                // Fallback: try to read package.json directly
+                try {
+                    const projectRoot = node.data.root;
+                    const packageJsonPath = (0, path_1.join)(projectRoot, 'package.json');
+                    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+                    const allowlistPatterns = createAllowlistFromExports(packageName, packageJson.exports);
+                    allowlistPatterns.forEach((pattern) => allNonBuildable.add(pattern));
+                }
+                catch (error) {
+                    // Final fallback: just add base package name
+                    allNonBuildable.add(packageName);
+                }
+            }
         }
         // Get all transitive non-buildable dependencies App -> library1 -> library2
         const transitiveDeps = (0, get_transitive_deps_1.getAllTransitiveDeps)(graph, dep.target);

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

@@ -52,6 +52,34 @@ function normalizeOptions(options) {
     if (!combinedPluginAndMaybeExecutorOptions.main) {
         throw new Error(`Missing "main" option for the entry file. Set this option in your Nx rspack plugin.`);
     }
+    // Normalize typeCheck and skipTypeChecking options
+    let normalizedTypeCheck;
+    let normalizedSkipTypeChecking;
+    if (combinedPluginAndMaybeExecutorOptions.typeCheck !== undefined &&
+        combinedPluginAndMaybeExecutorOptions.skipTypeChecking !== undefined) {
+        // Both options are provided - use typeCheck as the source of truth
+        normalizedTypeCheck = combinedPluginAndMaybeExecutorOptions.typeCheck;
+        normalizedSkipTypeChecking =
+            !combinedPluginAndMaybeExecutorOptions.typeCheck;
+    }
+    else if (combinedPluginAndMaybeExecutorOptions.typeCheck !== undefined) {
+        // Only typeCheck is provided
+        normalizedTypeCheck = combinedPluginAndMaybeExecutorOptions.typeCheck;
+        normalizedSkipTypeChecking =
+            !combinedPluginAndMaybeExecutorOptions.typeCheck;
+    }
+    else if (combinedPluginAndMaybeExecutorOptions.skipTypeChecking !== undefined) {
+        // Only skipTypeChecking is provided
+        normalizedSkipTypeChecking =
+            combinedPluginAndMaybeExecutorOptions.skipTypeChecking;
+        normalizedTypeCheck =
+            !combinedPluginAndMaybeExecutorOptions.skipTypeChecking;
+    }
+    else {
+        // Neither option is provided - use defaults
+        normalizedTypeCheck = true;
+        normalizedSkipTypeChecking = false;
+    }
     return {
         ...combinedPluginAndMaybeExecutorOptions,
         assets: combinedPluginAndMaybeExecutorOptions.assets
@@ -81,12 +109,14 @@ function normalizeOptions(options) {
         sassImplementation: combinedPluginAndMaybeExecutorOptions.sassImplementation ??
             'sass-embedded',
         scripts: combinedPluginAndMaybeExecutorOptions.scripts ?? [],
+        skipTypeChecking: normalizedSkipTypeChecking,
         sourceMap: combinedPluginAndMaybeExecutorOptions.sourceMap ?? !isProd,
         sourceRoot,
         styles: combinedPluginAndMaybeExecutorOptions.styles ?? [],
         subresourceIntegrity: combinedPluginAndMaybeExecutorOptions.subresourceIntegrity ?? false,
         target: combinedPluginAndMaybeExecutorOptions.target ?? 'web',
         targetName,
+        typeCheck: normalizedTypeCheck,
         vendorChunk: combinedPluginAndMaybeExecutorOptions.vendorChunk ?? !isProd,
     };
 }

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

@@ -16,9 +16,8 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
 async function readRspackOptions(rspackConfig) {
     const configs = [];
     const resolveConfig = async (config) => {
-        let resolvedConfig;
         if ((0, config_1.isNxRspackComposablePlugin)(config)) {
-            resolvedConfig = await config({}, {
+            return await config({}, {
                 // These values are only used during build-time, so passing stubs here just to read out
                 // the returned config object.
                 options: {