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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "21.2.0-beta.2",
+  "version": "21.2.0-beta.4",
   "private": false,
   "description": "The Nx Plugin for Webpack contains executors and generators that support building applications using Webpack.",
   "repository": {
@@ -66,8 +66,8 @@
     "webpack-dev-server": "^5.2.1",
     "webpack-node-externals": "^3.0.0",
     "webpack-subresource-integrity": "^5.1.0",
-    "@nx/devkit": "21.2.0-beta.2",
-    "@nx/js": "21.2.0-beta.2"
+    "@nx/devkit": "21.2.0-beta.4",
+    "@nx/js": "21.2.0-beta.4"
   },
   "publishConfig": {
     "access": "public"

package/src/plugins/nx-webpack-plugin/lib/apply-base-config.js

@@ -21,8 +21,10 @@ const IGNORED_WEBPACK_WARNINGS = [
     /could not find any license/i,
 ];
 const extensionAlias = {
-    '.js': ['.ts', '.js'],
+    '.js': ['.ts', '.tsx', '.js', '.jsx'],
     '.mjs': ['.mts', '.mjs'],
+    '.cjs': ['.cts', '.cjs'],
+    '.jsx': ['.tsx', '.jsx'],
 };
 const extensions = ['.ts', '.tsx', '.mjs', '.js', '.jsx'];
 const mainFields = ['module', 'main'];

package/src/plugins/nx-webpack-plugin/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import type { ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
+export declare function createAllowlistFromExports(packageName: string, exports: Record<string, any> | string | undefined): (string | RegExp)[];
 /**
  * Check if the library is buildable.
  * @param node from the project graph
@@ -22,4 +23,4 @@ export declare function getAllTransitiveDeps(graph: ProjectGraph, targetName: st
  * @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/nx-webpack-plugin/lib/utils.js

@@ -1,8 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAllowlistFromExports = createAllowlistFromExports;
 exports.isBuildableLibrary = isBuildableLibrary;
 exports.getAllTransitiveDeps = getAllTransitiveDeps;
 exports.getNonBuildableLibs = getNonBuildableLibs;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+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;
+}
 function isSourceFile(path) {
     return ['.ts', '.tsx', '.mts', '.cts'].some((ext) => path.endsWith(ext));
 }
@@ -109,11 +166,32 @@ function getNonBuildableLibs(graph, projectName) {
             return false;
         return !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 = getAllTransitiveDeps(graph, dep.target);