add algorithm to extract graph roots

show only graph roots in chunks by default

Author: sokra

declarations/WebpackOptions.d.ts

@@ -1267,6 +1267,10 @@ export interface StatsOptions {
 	 * add the origins of chunks and chunk merging info
 	 */
 	chunkOrigins?: boolean;
+	/**
+	 * add root modules information to chunk information
+	 */
+	chunkRootModules?: boolean;
 	/**
 	 * add chunk information
 	 */

lib/ChunkGraph.js

@@ -15,6 +15,7 @@ const {
 	compareSelect,
 	compareIds
 } = require("./util/comparators");
+const findGraphRoots = require("./util/findGraphRoots");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
@@ -155,6 +156,8 @@ class ChunkGraph {
 		this._blockChunkGroups = new WeakMap();
 		/** @private @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
+
+		this._getGraphRoots = this._getGraphRoots.bind(this);
 	}
 
 	/**
@@ -185,6 +188,22 @@ class ChunkGraph {
 		return c;
 	}
 
+	/**
+	 * @param {SortableSet<Module>} set the sortable Set to get the roots of
+	 * @returns {Module[]} the graph roots
+	 */
+	_getGraphRoots(set) {
+		const { moduleGraph } = this;
+		return Array.from(
+			findGraphRoots(set, module => {
+				return moduleGraph
+					.getOutgoingConnections(module)
+					.map(connection => connection.module)
+					.filter(Boolean);
+			})
+		).sort(compareModulesByIdentifier);
+	}
+
 	/**
 	 * @param {Chunk} chunk the new chunk
 	 * @param {Module} module the module
@@ -534,6 +553,15 @@ class ChunkGraph {
 		return cgc.modules.getFromUnorderedCache(getModulesSizes);
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Module[]} root modules of the chunks (ordered by identifer)
+	 */
+	getChunkRootModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {ChunkSizeOptions} options options object

lib/ModuleGraph.js

@@ -300,7 +300,7 @@ class ModuleGraph {
 	 * @param {Module} module the module
 	 * @returns {ModuleGraphConnection[]} list of outgoing connections
 	 */
-	getOutgoingConnection(module) {
+	getOutgoingConnections(module) {
 		const connections = this._getModuleGraphModule(module).outgoingConnections;
 		return Array.from(connections);
 	}

lib/Stats.js

@@ -170,15 +170,22 @@ class Stats {
 			!forToString
 		);
 		const showChunks = optionOrLocalFallback(options.chunks, !forToString);
-		const showChunkModules = optionOrLocalFallback(options.chunkModules, true);
+		const showChunkModules = optionOrLocalFallback(
+			options.chunkModules,
+			!forToString
+		);
+		const showChunkRootModules = optionOrLocalFallback(
+			options.chunkRootModules,
+			forToString ? !showChunkModules : true
+		);
 		const showChunkOrigins = optionOrLocalFallback(
 			options.chunkOrigins,
 			!forToString
 		);
 		const showModules = optionOrLocalFallback(options.modules, true);
 		const showNestedModules = optionOrLocalFallback(
 			options.nestedModules,
-			true
+			!forToString
 		);
 		const showOrphanModules = optionOrLocalFallback(
 			options.orphanModules,
@@ -793,6 +800,25 @@ class Stats {
 						);
 					}
 				}
+				if (showChunkRootModules) {
+					const rootModules = chunkGraph.getChunkRootModules(chunk);
+					obj.rootModules = rootModules
+						.slice()
+						.sort(sortRealModules)
+						.filter(createModuleFilter("root-of-chunk"))
+						.map(m => fnModule(m));
+					obj.filteredRootModules = rootModules.length - obj.rootModules.length;
+					obj.nonRootModules =
+						chunkGraph.getNumberOfChunkModules(chunk) - rootModules.length;
+					if (sortModules) {
+						obj.rootModules.sort(
+							concatComparators(
+								sortByField(sortModules),
+								keepOriginalOrder(obj.rootModules)
+							)
+						);
+					}
+				}
 				if (showChunkOrigins) {
 					const originsKeySet = new Set();
 					obj.origins = Array.from(chunk.groupsIterable, g => g.origins)
@@ -1134,21 +1160,6 @@ class Stats {
 			processChunkGroups(outputChunkGroups, "Chunk Group");
 		}
 
-		const modulesByIdentifier = {};
-		if (obj.modules) {
-			for (const module of obj.modules) {
-				modulesByIdentifier[`$${module.identifier}`] = module;
-			}
-		} else if (obj.chunks) {
-			for (const chunk of obj.chunks) {
-				if (chunk.modules) {
-					for (const module of chunk.modules) {
-						modulesByIdentifier[`$${module.identifier}`] = module;
-					}
-				}
-			}
-		}
-
 		const processSizes = sizes => {
 			const keys = Object.keys(sizes);
 			if (keys.length > 1) {
@@ -1341,11 +1352,16 @@ class Stats {
 				newline();
 			}
 			if (module.modules) {
-				processModulesList(module, prefix + "| ");
+				processModulesList(module, prefix + "| ", "nested module");
 			}
 		};
 
-		const processModulesList = (obj, prefix) => {
+		const processModulesList = (
+			obj,
+			prefix,
+			itemType = "module",
+			dependentItemType = "dependent module"
+		) => {
 			if (obj.modules) {
 				let maxModuleId = 0;
 				for (const module of obj.modules) {
@@ -1397,7 +1413,19 @@ class Stats {
 					if (obj.modules.length > 0) colors.normal(" + ");
 					colors.normal(obj.filteredModules);
 					if (obj.modules.length > 0) colors.normal(" hidden");
-					colors.normal(obj.filteredModules !== 1 ? " modules" : " module");
+					colors.normal(` ${itemType}${obj.filteredModules !== 1 ? "s" : ""}`);
+					newline();
+				}
+				if (obj.dependentModules > 0) {
+					const additional = obj.modules.length > 0 || obj.filteredModules > 0;
+					colors.normal(prefix);
+					colors.normal("   ");
+					if (additional) colors.normal(" + ");
+					colors.normal(obj.dependentModules);
+					if (additional) colors.normal(" hidden");
+					colors.normal(
+						` ${dependentItemType}${obj.dependentModules !== 1 ? "s" : ""}`
+					);
 					newline();
 				}
 			}
@@ -1473,9 +1501,8 @@ class Stats {
 							colors.normal("[");
 							colors.normal(origin.moduleId);
 							colors.normal("] ");
-							const module = modulesByIdentifier[`$${origin.module}`];
-							if (module) {
-								colors.bold(module.name);
+							if (origin.moduleName) {
+								colors.bold(origin.moduleName);
 								colors.normal(" ");
 							}
 						}
@@ -1485,7 +1512,21 @@ class Stats {
 						newline();
 					}
 				}
-				processModulesList(chunk, " ");
+				const hasRootModules =
+					chunk.rootModules ||
+					chunk.filteredRootModules ||
+					chunk.nonRootModules;
+				processModulesList(
+					{
+						modules: chunk.rootModules,
+						filteredModules: chunk.filteredRootModules,
+						dependentModules: chunk.nonRootModules
+					},
+					" ",
+					"root module",
+					"dependent module"
+				);
+				processModulesList(chunk, hasRootModules ? " | " : " ", "chunk module");
 			}
 		}
 
@@ -1552,6 +1593,7 @@ class Stats {
 					modules: false,
 					chunks: true,
 					chunkModules: true,
+					chunkRootModules: false,
 					chunkOrigins: true,
 					depth: true,
 					env: true,
@@ -1572,6 +1614,7 @@ class Stats {
 					chunkGroups: true,
 					chunks: true,
 					chunkModules: false,
+					chunkRootModules: false,
 					chunkOrigins: true,
 					depth: true,
 					usedExports: true,