webpack 5.85.0 → 5.88.1

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) => {

package/lib/optimize/RealContentHashPlugin.js

@@ -13,12 +13,18 @@ const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {typeof import("../util/Hash")} Hash */
 
 const EMPTY_SET = new Set();
 
+/**
+ * @template T
+ * @param {T | T[]} itemOrItems item or items
+ * @param {Set<T>} list list
+ */
 const addToList = (itemOrItems, list) => {
 	if (Array.isArray(itemOrItems)) {
 		for (const item of itemOrItems) {
@@ -61,6 +67,10 @@ const quoteMeta = str => {
 
 const cachedSourceMap = new WeakMap();
 
+/**
+ * @param {Source} source source
+ * @returns {CachedSource} cached source
+ */
 const toCachedSource = source => {
 	if (source instanceof CachedSource) {
 		return source;
@@ -72,6 +82,10 @@ const toCachedSource = source => {
 	return newSource;
 };
 
+/** @typedef {Set<string>} OwnHashes */
+/** @typedef {Set<string>} ReferencedHashes */
+/** @typedef {Set<string>} Hashes */
+
 /**
  * @typedef {Object} AssetInfoForRealContentHash
  * @property {string} name
@@ -80,11 +94,11 @@ const toCachedSource = source => {
  * @property {RawSource | undefined} newSource
  * @property {RawSource | undefined} newSourceWithoutOwn
  * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
+ * @property {OwnHashes | undefined} ownHashes
+ * @property {Promise<void> | undefined} contentComputePromise
+ * @property {Promise<void> | undefined} contentComputeWithoutOwnPromise
+ * @property {ReferencedHashes | undefined} referencedHashes
+ * @property {Hashes} hashes
  */
 
 /**
@@ -149,27 +163,25 @@ class RealContentHashPlugin {
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
+					/** @type {Map<string, [AssetInfoForRealContentHash]>} */
 					const hashToAssets = new Map();
 					for (const { source, info, name } of assets) {
 						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
+						const content = /** @type {string} */ (cachedSource.source());
+						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						/** @type {AssetInfoForRealContentHash} */
 						const data = {
 							name,
 							info,
 							source: cachedSource,
-							/** @type {RawSource | undefined} */
 							newSource: undefined,
-							/** @type {RawSource | undefined} */
 							newSourceWithoutOwn: undefined,
 							content,
-							/** @type {Set<string>} */
 							ownHashes: undefined,
 							contentComputePromise: undefined,
 							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
 							referencedHashes: undefined,
 							hashes
 						};
@@ -218,11 +230,17 @@ class RealContentHashPlugin {
 								});
 						})
 					);
+					/**
+					 * @param {string} hash the hash
+					 * @returns {undefined | ReferencedHashes} the referenced hashes
+					 */
 					const getDependencies = hash => {
 						const assets = hashToAssets.get(hash);
 						if (!assets) {
 							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
+								/** @type {ReferencedHashes} */ (asset.referencedHashes).has(
+									hash
+								)
 							);
 							const err = new WebpackError(`RealContentHashPlugin
 Some kind of unexpected caching problem occurred.
@@ -242,23 +260,36 @@ ${referencingAssets
 						}
 						const hashes = new Set();
 						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
+							if (!(/** @type {OwnHashes} */ (ownHashes).has(hash))) {
+								for (const hash of /** @type {OwnHashes} */ (ownHashes)) {
 									hashes.add(hash);
 								}
 							}
-							for (const hash of referencedHashes) {
+							for (const hash of /** @type {ReferencedHashes} */ (
+								referencedHashes
+							)) {
 								hashes.add(hash);
 							}
 						}
 						return hashes;
 					};
+					/**
+					 * @param {string} hash the hash
+					 * @returns {string} the hash info
+					 */
 					const hashInfo = hash => {
 						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
+						return `${hash} (${Array.from(
+							/** @type {AssetInfoForRealContentHash[]} */ (assets),
+							a => a.name
+						)})`;
 					};
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
+						/**
+						 * @param {string} hash the hash
+						 * @param {Set<string>} stack stack of hashes
+						 */
 						const add = (hash, stack) => {
 							const deps = getDependencies(hash);
 							if (!deps) return;
@@ -282,21 +313,31 @@ ${referencingAssets
 						add(hash, new Set());
 					}
 					const hashToNewHash = new Map();
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Etag} etag
+					 */
 					const getEtag = asset =>
 						cacheGenerate.mergeEtags(
 							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
+							Array.from(
+								/** @type {ReferencedHashes} */ (asset.referencedHashes),
+								hash => hashToNewHash.get(hash)
 							).join("|")
 						);
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContent = asset => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -313,15 +354,20 @@ ${referencingAssets
 							}
 						})());
 					};
+					/**
+					 * @param {AssetInfoForRealContentHash} asset asset info
+					 * @returns {Promise<void>}
+					 */
 					const computeNewContentWithoutOwn = asset => {
 						if (asset.contentComputeWithoutOwnPromise)
 							return asset.contentComputeWithoutOwnPromise;
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
+								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
+								Array.from(
+									/** @type {ReferencedHashes} */
+									(asset.referencedHashes)
+								).some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name + "|without-own";
 								const etag = getEtag(asset);
@@ -332,7 +378,9 @@ ${referencingAssets
 										const newContent = asset.content.replace(
 											hashRegExp,
 											hash => {
-												if (asset.ownHashes.has(hash)) {
+												if (
+													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+												) {
 													return "";
 												}
 												return hashToNewHash.get(hash);
@@ -346,17 +394,19 @@ ${referencingAssets
 					};
 					const comparator = compareSelect(a => a.name, compareStrings);
 					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
+						const assets =
+							/** @type {AssetInfoForRealContentHash[]} */
+							(hashToAssets.get(oldHash));
 						assets.sort(comparator);
 						await Promise.all(
 							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
+								/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)
 									? computeNewContentWithoutOwn(asset)
 									: computeNewContent(asset)
 							)
 						);
 						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
+							if (/** @type {OwnHashes} */ (asset.ownHashes).has(oldHash)) {
 								return asset.newSourceWithoutOwn
 									? asset.newSourceWithoutOwn.buffer()
 									: asset.source.buffer();

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -9,6 +9,8 @@ const { STAGE_BASIC } = require("../OptimizationStages");
 const Queue = require("../util/Queue");
 const { intersect } = require("../util/SetHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compiler")} Compiler */
 
 class RemoveParentModulesPlugin {
@@ -18,6 +20,10 @@ class RemoveParentModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks
+			 * @param {ChunkGroup[]} chunkGroups the chunk groups
+			 */
 			const handler = (chunks, chunkGroups) => {
 				const chunkGraph = compilation.chunkGraph;
 				const queue = new Queue();

package/lib/optimize/RuntimeChunkPlugin.js

@@ -5,11 +5,17 @@
 
 "use strict";
 
+/** @typedef {import("../Compilation").EntryData} EntryData */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class RuntimeChunkPlugin {
 	constructor(options) {
 		this.options = {
+			/**
+			 * @param {Entrypoint} entrypoint entrypoint name
+			 * @returns {string} runtime chunk name
+			 */
 			name: entrypoint => `runtime~${entrypoint.name}`,
 			...options
 		};
@@ -26,7 +32,9 @@ class RuntimeChunkPlugin {
 				"RuntimeChunkPlugin",
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
+					const data =
+						/** @type {EntryData} */
+						(compilation.entries.get(entryName));
 					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
 						let name = this.options.name;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -16,6 +16,8 @@ const HarmonyExportImportedSpecifierDependency = require("../dependencies/Harmon
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const formatLocation = require("../formatLocation");
 
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
+/** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Module")} Module */
@@ -117,6 +119,7 @@ class SideEffectsFlagPlugin {
 					 * @returns {void}
 					 */
 					const parserHandler = parser => {
+						/** @type {undefined | Statement | ModuleDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
 							sideEffectsStatement = undefined;
@@ -258,7 +261,7 @@ class SideEffectsFlagPlugin {
 										// TODO improve for export *
 										if (isReexport && dep.name) {
 											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
+												/** @type {Module} */ (connection.originModule),
 												dep.name
 											);
 											exportInfo.moveTarget(
@@ -319,6 +322,12 @@ class SideEffectsFlagPlugin {
 		);
 	}
 
+	/**
+	 * @param {string} moduleName the module name
+	 * @param {undefined | boolean | string | string[]} flagValue the flag value
+	 * @param {Map<string, RegExp>} cache cache for glob to regexp
+	 * @returns {boolean | undefined} true, when the module has side effects, undefined or false when not
+	 */
 	static moduleHasSideEffects(moduleName, flagValue, cache) {
 		switch (typeof flagValue) {
 			case "undefined":