@nx/webpack 21.1.2 → 21.1.3

package/README.md

@@ -1,7 +1,7 @@
 <p style="text-align: center;">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
-    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+    <img alt="Nx - Smart Repos · Fast Builds" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
   </picture>
 </p>
 
@@ -20,9 +20,9 @@
 
 <hr>
 
-# Nx: Smart Monorepos · Fast CI
+# Nx: Smart Repos · Fast Builds
 
-Nx is a build system, optimized for monorepos, with plugins for popular frameworks and tools and advanced CI capabilities including caching and distribution.
+An AI-first build platform that connects everything from your editor to CI. Helping you deliver fast, without breaking things.
 
 This package is a [Webpack plugin for Nx](https://nx.dev/nx-api/webpack).
 
@@ -64,5 +64,5 @@ npx nx@latest init
 - [Blog Posts About Nx](https://nx.dev/blog)
 
 <p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "21.1.2",
+  "version": "21.1.3",
   "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.1.2",
-    "@nx/js": "21.1.2"
+    "@nx/devkit": "21.1.3",
+    "@nx/js": "21.1.3"
   },
   "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'];
@@ -281,27 +283,11 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
         const modulesDir = `${options.root}/node_modules`;
         const graph = options.projectGraph;
         const projectName = options.projectName;
-        const deps = graph?.dependencies?.[projectName] ?? [];
         // Collect non-buildable TS project references so that they are bundled
         // in the final output. This is needed for projects that are not buildable
-        // but are referenced by buildable projects. This is needed for the new TS
-        // solution setup.
+        // but are referenced by buildable projects.
         const nonBuildableWorkspaceLibs = isUsingTsSolution
-            ? deps
-                .filter((dep) => {
-                const node = graph.nodes?.[dep.target];
-                if (!node || node.type !== 'lib')
-                    return false;
-                const hasBuildTarget = 'build' in (node.data?.targets ?? {});
-                if (hasBuildTarget) {
-                    return false;
-                }
-                // If there is no build target we check the package exports to see if they reference
-                // source files
-                return !(0, utils_1.isBuildableLibrary)(node);
-            })
-                .map((dep) => graph.nodes?.[dep.target]?.data?.metadata?.js?.packageName)
-                .filter((name) => !!name)
+            ? (0, utils_1.getNonBuildableLibs)(graph, projectName)
             : [];
         externals.push(nodeExternals({ modulesDir, allowlist: nonBuildableWorkspaceLibs }));
     }

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

@@ -1,7 +1,25 @@
-import { type ProjectGraphProjectNode } from '@nx/devkit';
+import type { ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
 /**
  * Check if the library is buildable.
  * @param node from the project graph
  * @returns boolean
  */
 export declare function isBuildableLibrary(node: ProjectGraphProjectNode): boolean;
+/**
+ * Get all transitive dependencies of a target that are non-buildable libraries.
+ * This function traverses the project graph to find all dependencies of a given target,
+ * @param graph Graph of the project
+ * @param targetName The project name to get dependencies for
+ * @param visited Set to keep track of visited nodes to prevent infinite loops in circular dependencies
+ * @returns string[] - List of all transitive dependencies that are non-buildable libraries
+ */
+export declare function getAllTransitiveDeps(graph: ProjectGraph, targetName: string, visited?: Set<string>): string[];
+/**
+ * Get all non-buildable libraries in the project graph for a given project.
+ * This function retrieves all direct and transitive dependencies of a project,
+ * filtering out only those that are libraries and not buildable.
+ * @param graph Project graph
+ * @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[];

package/src/plugins/nx-webpack-plugin/lib/utils.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBuildableLibrary = isBuildableLibrary;
+exports.getAllTransitiveDeps = getAllTransitiveDeps;
+exports.getNonBuildableLibs = getNonBuildableLibs;
 function isSourceFile(path) {
     return ['.ts', '.tsx', '.mts', '.cts'].some((ext) => path.endsWith(ext));
 }
@@ -46,3 +48,76 @@ function isBuildableLibrary(node) {
         packageMain !== '' &&
         !isSourceFile(packageMain));
 }
+/**
+ * Get all transitive dependencies of a target that are non-buildable libraries.
+ * This function traverses the project graph to find all dependencies of a given target,
+ * @param graph Graph of the project
+ * @param targetName The project name to get dependencies for
+ * @param visited Set to keep track of visited nodes to prevent infinite loops in circular dependencies
+ * @returns string[] - List of all transitive dependencies that are non-buildable libraries
+ */
+function getAllTransitiveDeps(graph, targetName, visited = new Set()) {
+    if (visited.has(targetName)) {
+        return [];
+    }
+    visited.add(targetName);
+    const node = graph.nodes?.[targetName];
+    if (!node) {
+        return [];
+    }
+    // Get direct dependencies of this target
+    const directDeps = graph.dependencies?.[targetName] || [];
+    const transitiveDeps = [];
+    for (const dep of directDeps) {
+        const depNode = graph.nodes?.[dep.target];
+        // Only consider library dependencies
+        if (!depNode || depNode.type !== 'lib') {
+            continue;
+        }
+        // Check if this dependency is non-buildable
+        const hasBuildTarget = 'build' in (depNode.data?.targets ?? {});
+        const isBuildable = hasBuildTarget || isBuildableLibrary(depNode);
+        if (!isBuildable) {
+            const packageName = depNode.data?.metadata?.js?.packageName;
+            if (packageName) {
+                transitiveDeps.push(packageName);
+            }
+            const nestedDeps = getAllTransitiveDeps(graph, dep.target, visited);
+            transitiveDeps.push(...nestedDeps);
+        }
+    }
+    return transitiveDeps;
+}
+/**
+ * Get all non-buildable libraries in the project graph for a given project.
+ * This function retrieves all direct and transitive dependencies of a project,
+ * filtering out only those that are libraries and not buildable.
+ * @param graph Project graph
+ * @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.
+ */
+function getNonBuildableLibs(graph, projectName) {
+    const deps = graph?.dependencies?.[projectName] ?? [];
+    const allNonBuildable = new Set();
+    // First, find all direct non-buildable deps and add them App -> library
+    const directNonBuildable = deps.filter((dep) => {
+        const node = graph.nodes?.[dep.target];
+        if (!node || node.type !== 'lib')
+            return false;
+        const hasBuildTarget = 'build' in (node.data?.targets ?? {});
+        if (hasBuildTarget)
+            return false;
+        return !isBuildableLibrary(node);
+    });
+    // Add direct non-buildable dependencies
+    for (const dep of directNonBuildable) {
+        const packageName = graph.nodes?.[dep.target]?.data?.metadata?.js?.packageName;
+        if (packageName) {
+            allNonBuildable.add(packageName);
+        }
+        // Get all transitive non-buildable dependencies App -> library1 -> library2
+        const transitiveDeps = getAllTransitiveDeps(graph, dep.target);
+        transitiveDeps.forEach((pkg) => allNonBuildable.add(pkg));
+    }
+    return Array.from(allNonBuildable);
+}