webpack 5.76.1 → 5.88.0

package/lib/optimize/InnerGraphPlugin.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
 const InnerGraph = require("./InnerGraph");
 
@@ -12,6 +16,7 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").ClassExpression} ClassExpressionNode */
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
@@ -21,6 +26,8 @@ const InnerGraph = require("./InnerGraph");
 
 const { topLevelSymbolTag } = InnerGraph;
 
+const PLUGIN_NAME = "InnerGraphPlugin";
+
 class InnerGraphPlugin {
 	/**
 	 * Apply the plugin
@@ -29,7 +36,7 @@ class InnerGraphPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"InnerGraphPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
 
@@ -40,7 +47,7 @@ class InnerGraphPlugin {
 
 				/**
 				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
+				 * @param {JavascriptParserOptions} parserOptions options
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
@@ -61,11 +68,11 @@ class InnerGraphPlugin {
 						});
 					};
 
-					parser.hooks.program.tap("InnerGraphPlugin", () => {
+					parser.hooks.program.tap(PLUGIN_NAME, () => {
 						InnerGraph.enable(parser.state);
 					});
 
-					parser.hooks.finish.tap("InnerGraphPlugin", () => {
+					parser.hooks.finish.tap(PLUGIN_NAME, () => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						logger.time("infer dependency usage");
@@ -97,7 +104,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
+					parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
@@ -110,11 +117,14 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
+					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
+							if (
+								statement.type === "ClassDeclaration" &&
+								parser.isPure(statement, statement.range[0])
+							) {
 								const name = statement.id ? statement.id.name : "*default*";
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								classWithTopLevelSymbol.set(statement, fn);
@@ -125,8 +135,9 @@ class InnerGraphPlugin {
 								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
 								const decl = statement.declaration;
 								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
+									(decl.type === "ClassExpression" ||
+										decl.type === "ClassDeclaration") &&
+									parser.isPure(decl, decl.range[0])
 								) {
 									classWithTopLevelSymbol.set(decl, fn);
 								} else if (parser.isPure(decl, statement.range[0])) {
@@ -143,33 +154,33 @@ class InnerGraphPlugin {
 						}
 					});
 
-					parser.hooks.preDeclarator.tap(
-						"InnerGraphPlugin",
-						(decl, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (
+							parser.scope.topLevelScope === true &&
+							decl.init &&
+							decl.id.type === "Identifier"
+						) {
+							const name = decl.id.name;
 							if (
-								parser.scope.topLevelScope === true &&
-								decl.init &&
-								decl.id.type === "Identifier"
+								decl.init.type === "ClassExpression" &&
+								parser.isPure(decl.init, decl.id.range[1])
 							) {
-								const name = decl.id.name;
-								if (decl.init.type === "ClassExpression") {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									classWithTopLevelSymbol.set(decl.init, fn);
-								} else if (parser.isPure(decl.init, decl.id.range[1])) {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									declWithTopLevelSymbol.set(decl, fn);
-									if (
-										!decl.init.type.endsWith("FunctionExpression") &&
-										decl.init.type !== "Literal"
-									) {
-										pureDeclarators.add(decl);
-									}
-									return true;
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								classWithTopLevelSymbol.set(decl.init, fn);
+							} else if (parser.isPure(decl.init, decl.id.range[1])) {
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								declWithTopLevelSymbol.set(decl, fn);
+								if (
+									!decl.init.type.endsWith("FunctionExpression") &&
+									decl.init.type !== "Literal"
+								) {
+									pureDeclarators.add(decl);
 								}
+								return true;
 							}
 						}
-					);
+					});
 
 					// During real walking we set the TopLevelSymbol state to the assigned
 					// TopLevelSymbol by using the fill datastructures.
@@ -187,7 +198,7 @@ class InnerGraphPlugin {
 
 					// The following hooks are called during walking:
 
-					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
+					parser.hooks.statement.tap(PLUGIN_NAME, statement => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
 							InnerGraph.setTopLevelSymbol(parser.state, undefined);
@@ -219,7 +230,7 @@ class InnerGraphPlugin {
 					});
 
 					parser.hooks.classExtendsExpression.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(expr, statement) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -239,7 +250,7 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.classBodyElement.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(element, classDefinition) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -252,7 +263,7 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.classBodyValue.tap(
-						"InnerGraphPlugin",
+						PLUGIN_NAME,
 						(expression, element, classDefinition) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
@@ -292,7 +303,7 @@ class InnerGraphPlugin {
 						}
 					);
 
-					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
+					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, statement) => {
 						if (!InnerGraph.isEnabled(parser.state)) return;
 						const fn = declWithTopLevelSymbol.get(decl);
 
@@ -330,7 +341,7 @@ class InnerGraphPlugin {
 
 					parser.hooks.expression
 						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", () => {
+						.tap(PLUGIN_NAME, () => {
 							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
 								parser.currentTagData
 							);
@@ -343,21 +354,19 @@ class InnerGraphPlugin {
 								currentTopLevelSymbol || true
 							);
 						});
-					parser.hooks.assign
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", expr => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (expr.operator === "=") return true;
-						});
+					parser.hooks.assign.for(topLevelSymbolTag).tap(PLUGIN_NAME, expr => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (expr.operator === "=") return true;
+					});
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("InnerGraphPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("InnerGraphPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 
-				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
+				compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 					logger.timeAggregateEnd("infer dependency usage");
 				});
 			}

package/lib/optimize/LimitChunkCountPlugin.js

@@ -36,6 +36,12 @@ const validate = createSchemaValidation(
  * @property {number} bSize
  */
 
+/**
+ * @template K, V
+ * @param {Map<K, Set<V>>} map map
+ * @param {K} key key
+ * @param {V} value value
+ */
 const addToSetMap = (map, key, value) => {
 	const set = map.get(key);
 	if (set === undefined) {
@@ -68,7 +74,9 @@ class LimitChunkCountPlugin {
 				},
 				chunks => {
 					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
+					const maxChunks =
+						/** @type {LimitChunkCountPluginOptions} */
+						(options).maxChunks;
 					if (!maxChunks) return;
 					if (maxChunks < 1) return;
 					if (compilation.chunks.size <= maxChunks) return;
@@ -88,9 +96,17 @@ class LimitChunkCountPlugin {
 						c => c.sizeDiff,
 						(a, b) => b - a,
 						// Layer 2: ordered by smallest combined size
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} integrated size
+						 */
 						c => c.integratedSize,
 						(a, b) => a - b,
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+						/**
+						 * @param {ChunkCombination} c combination
+						 * @returns {number} position difference
+						 */
 						c => c.bIdx - c.aIdx,
 						(a, b) => a - b,
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
@@ -193,14 +209,18 @@ class LimitChunkCountPlugin {
 							// Update all affected combinations
 							// delete all combination with the removed chunk
 							// we will use combinations with the kept chunk instead
-							for (const combination of combinationsByChunk.get(a)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(a)
+							)) {
 								if (combination.deleted) continue;
 								combination.deleted = true;
 								combinations.delete(combination);
 							}
 
 							// Update combinations with the kept chunk with new sizes
-							for (const combination of combinationsByChunk.get(b)) {
+							for (const combination of /** @type {Set<ChunkCombination>} */ (
+								combinationsByChunk.get(b)
+							)) {
 								if (combination.deleted) continue;
 								if (combination.a === b) {
 									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
@@ -243,7 +263,12 @@ class LimitChunkCountPlugin {
 									finishUpdate();
 								}
 							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
+							combinationsByChunk.set(
+								a,
+								/** @type {Set<ChunkCombination>} */ (
+									combinationsByChunk.get(b)
+								)
+							);
 							combinationsByChunk.delete(b);
 						}
 					}

package/lib/optimize/MangleExportsPlugin.js

@@ -39,7 +39,7 @@ const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
- * @param {boolean} isNamespace is namespace object
+ * @param {boolean | undefined} isNamespace is namespace object
  * @returns {void}
  */
 const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {

package/lib/optimize/MinMaxSizeWarning.js

@@ -9,6 +9,11 @@ const SizeFormatHelpers = require("../SizeFormatHelpers");
 const WebpackError = require("../WebpackError");
 
 class MinMaxSizeWarning extends WebpackError {
+	/**
+	 * @param {string[] | undefined} keys keys
+	 * @param {number} minSize minimum size
+	 * @param {number} maxSize maximum size
+	 */
 	constructor(keys, minSize, maxSize) {
 		let keysMessage = "Fallback cache group";
 		if (keys) {

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -40,6 +40,10 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  * @property {number} added
  */
 
+/**
+ * @param {string} msg message
+ * @returns {string} formatted message
+ */
 const formatBailoutReason = msg => {
 	return "ModuleConcatenation bailout: " + msg;
 };
@@ -64,8 +68,13 @@ class ModuleConcatenationPlugin {
 				);
 			}
 			const moduleGraph = compilation.moduleGraph;
+			/** @type {Map<Module, string | ((requestShortener: RequestShortener) => string)>} */
 			const bailoutReasonMap = new Map();
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setBailoutReason = (module, reason) => {
 				setInnerBailoutReason(module, reason);
 				moduleGraph
@@ -77,16 +86,30 @@ class ModuleConcatenationPlugin {
 					);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
+			 */
 			const setInnerBailoutReason = (module, reason) => {
 				bailoutReasonMap.set(module, reason);
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {RequestShortener} requestShortener the request shortener
+			 * @returns {string | ((requestShortener: RequestShortener) => string) | undefined} the reason
+			 */
 			const getInnerBailoutReason = (module, requestShortener) => {
 				const reason = bailoutReasonMap.get(module);
 				if (typeof reason === "function") return reason(requestShortener);
 				return reason;
 			};
 
+			/**
+			 * @param {Module} module the module
+			 * @param {Module | function(RequestShortener): string} problem the problem
+			 * @returns {(requestShortener: RequestShortener) => string} the reason
+			 */
 			const formatBailoutWarning = (module, problem) => requestShortener => {
 				if (typeof problem === "function") {
 					return formatBailoutReason(
@@ -460,7 +483,7 @@ class ModuleConcatenationPlugin {
 										c.module === rootModule ? c.originModule : c.module;
 									const innerConnection =
 										c.dependency instanceof HarmonyImportDependency &&
-										modules.has(otherModule);
+										modules.has(/** @type {Module} */ (otherModule));
 									return !innerConnection;
 								});
 								// add concatenated module to the compilation
@@ -533,7 +556,7 @@ class ModuleConcatenationPlugin {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
 	 * @param {Statistics} statistics gathering metrics
-	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 * @returns {null | Module | function(RequestShortener): string} the problematic module
 	 */
 	_tryToAdd(
 		compilation,
@@ -572,6 +595,10 @@ class ModuleConcatenationPlugin {
 			chunkGraph.getModuleChunksIterable(config.rootModule)
 		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const missingChunksList = Array.from(
 					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
@@ -609,6 +636,10 @@ class ModuleConcatenationPlugin {
 					return connection.isActive(runtime);
 				});
 			if (activeNonModulesConnections.length > 0) {
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
 				const problem = requestShortener => {
 					const importingExplanations = new Set(
 						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
@@ -666,6 +697,10 @@ class ModuleConcatenationPlugin {
 			return false;
 		});
 		if (otherChunkModules.length > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = otherChunkModules
 					.map(m => m.readableIdentifier(requestShortener))
@@ -693,6 +728,10 @@ class ModuleConcatenationPlugin {
 				nonHarmonyConnections.set(originModule, connections);
 		}
 		if (nonHarmonyConnections.size > 0) {
+			/**
+			 * @param {RequestShortener} requestShortener request shortener
+			 * @returns {string} problem description
+			 */
 			const problem = requestShortener => {
 				const names = Array.from(nonHarmonyConnections)
 					.map(([originModule, connections]) => {
@@ -753,6 +792,10 @@ class ModuleConcatenationPlugin {
 				}
 			}
 			if (otherRuntimeConnections.length > 0) {
+				/**
+				 * @param {RequestShortener} requestShortener request shortener
+				 * @returns {string} problem description
+				 */
 				const problem = requestShortener => {
 					return `Module ${module.readableIdentifier(
 						requestShortener
@@ -831,10 +874,17 @@ class ConcatConfiguration {
 		this.warnings = new Map();
 	}
 
+	/**
+	 * @param {Module} module the module
+	 */
 	add(module) {
 		this.modules.add(module);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, when the module is in the module set
+	 */
 	has(module) {
 		return this.modules.has(module);
 	}
@@ -843,10 +893,17 @@ class ConcatConfiguration {
 		return this.modules.size === 1;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | function(RequestShortener): string} problem the problem
+	 */
 	addWarning(module, problem) {
 		this.warnings.set(module, problem);
 	}
 
+	/**
+	 * @returns {Map<Module, Module | function(RequestShortener): string>} warnings
+	 */
 	getWarningsSorted() {
 		return new Map(
 			Array.from(this.warnings).sort((a, b) => {