webpack 5.88.0 → 5.88.2

package/lib/buildChunkGraph.js

@@ -16,6 +16,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -39,15 +40,15 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @typedef {Object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
- * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
+ * @property {ModuleSetPlus | undefined} minAvailableModules current minimal set of modules available at this point
+ * @property {boolean | undefined} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
  * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
- * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
- * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
- * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
+ * @property {ModuleSetPlus | undefined} resultingAvailableModules set of modules available including modules from this chunk group
+ * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {Set<ChunkGroupInfo> | undefined} availableSources set of chunk groups that are the source for minAvailableModules
+ * @property {Set<ChunkGroupInfo> | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource
  * @property {number} preOrderIndex next pre order index
  * @property {number} postOrderIndex next post order index
  * @property {boolean} chunkLoading has a chunk loading mechanism
@@ -199,6 +200,7 @@ const visitModules = (
 
 	/** @type {RuntimeSpec | false} */
 	let blockModulesMapRuntime = false;
+	/** @type {Map<DependenciesBlock, (Module | ConnectionState)[]>} */
 	let blockModulesMap;
 
 	/**
@@ -239,7 +241,7 @@ const visitModules = (
 			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
 			blockModules = blockModulesMap.get(block);
 			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
+			return /** @type {(Module | ConnectionState)[]} */ (blockModules);
 		}
 	};
 
@@ -290,7 +292,7 @@ const visitModules = (
 	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
 		const runtime = getEntryRuntime(
 			compilation,
-			chunkGroup.name,
+			/** @type {string} */ (chunkGroup.name),
 			chunkGroup.options
 		);
 		/** @type {ChunkGroupInfo} */
@@ -352,7 +354,9 @@ const visitModules = (
 		const { chunkGroup } = chunkGroupInfo;
 		chunkGroupInfo.availableSources = new Set();
 		for (const parent of chunkGroup.parentsIterable) {
-			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
+			const parentChunkGroupInfo =
+				/** @type {ChunkGroupInfo} */
+				(chunkGroupInfoMap.get(parent));
 			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
 			if (parentChunkGroupInfo.availableChildren === undefined) {
 				parentChunkGroupInfo.availableChildren = new Set();
@@ -399,15 +403,15 @@ const visitModules = (
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
 		let cgi = blockChunkGroups.get(b);
-		/** @type {ChunkGroup} */
+		/** @type {ChunkGroup | undefined} */
 		let c;
-		/** @type {Entrypoint} */
+		/** @type {Entrypoint | undefined} */
 		let entrypoint;
 		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
 		if (cgi === undefined) {
 			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
 			if (entryOptions) {
-				cgi = namedAsyncEntrypoints.get(chunkName);
+				cgi = namedAsyncEntrypoints.get(/** @type {string} */ (chunkName));
 				if (!cgi) {
 					entrypoint = compilation.addAsyncEntrypoint(
 						entryOptions,
@@ -505,7 +509,11 @@ const visitModules = (
 					c = cgi.chunkGroup;
 					if (c.isInitial()) {
 						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
+							new AsyncDependencyToInitialChunkError(
+								/** @type {string} */ (chunkName),
+								module,
+								b.loc
+							)
 						);
 						c = chunkGroup;
 					} else {
@@ -515,7 +523,7 @@ const visitModules = (
 				}
 				blockConnections.set(b, []);
 			}
-			blockChunkGroups.set(b, cgi);
+			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -536,7 +544,7 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(cgi);
+			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
 
 			// TODO check if this really need to be done for each traversal
 			// or if it is enough when it's queued when created
@@ -547,7 +555,7 @@ const visitModules = (
 				module: module,
 				chunk: c.chunks[0],
 				chunkGroup: c,
-				chunkGroupInfo: cgi
+				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
 			});
 		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
@@ -690,7 +698,7 @@ const visitModules = (
 	const processQueue = () => {
 		while (queue.length) {
 			statProcessedQueueItems++;
-			const queueItem = queue.pop();
+			const queueItem = /** @type {QueueItem} */ (queue.pop());
 			module = queueItem.module;
 			block = queueItem.block;
 			chunk = queueItem.chunk;
@@ -1087,7 +1095,9 @@ const visitModules = (
 
 	const processChunkGroupsForCombining = () => {
 		for (const info of chunkGroupsForCombining) {
-			for (const source of info.availableSources) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
 				if (!source.minAvailableModules) {
 					chunkGroupsForCombining.delete(info);
 					break;
@@ -1106,7 +1116,9 @@ const visitModules = (
 				}
 			};
 			// combine minAvailableModules from all resultingAvailableModules
-			for (const source of info.availableSources) {
+			for (const source of /** @type {Set<ChunkGroupInfo>} */ (
+				info.availableSources
+			)) {
 				const resultingAvailableModules =
 					calculateResultingAvailableModules(source);
 				mergeSet(resultingAvailableModules);
@@ -1126,7 +1138,9 @@ const visitModules = (
 		for (const info of outdatedChunkGroupInfo) {
 			// 1. Reconsider skipped items
 			if (info.skippedItems !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {ModuleSetPlus} */
+					(info.minAvailableModules);
 				for (const module of info.skippedItems) {
 					if (
 						!minAvailableModules.has(module) &&
@@ -1147,7 +1161,9 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules } = info;
+				const minAvailableModules =
+					/** @type {ModuleSetPlus} */
+					(info.minAvailableModules);
 				for (const entry of info.skippedModuleConnections) {
 					const [module, activeState] = entry;
 					if (activeState === false) continue;

package/lib/cache/PackFileCacheStrategy.js

@@ -20,19 +20,22 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
 /** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/** @typedef {Map<string, string | false>} ResolveResults */
+
 class PackContainer {
 	/**
 	 * @param {Object} data stored data
 	 * @param {string} version version identifier
 	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
 	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
-	 * @param {Map<string, string | false>} resolveResults result of the resolved build dependencies
+	 * @param {ResolveResults} resolveResults result of the resolved build dependencies
 	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
 	 */
 	constructor(
@@ -977,6 +980,10 @@ class PackContent {
 	}
 }
 
+/**
+ * @param {Buffer} buf buffer
+ * @returns {Buffer} buffer that can be collected
+ */
 const allowCollectingMemory = buf => {
 	const wasted = buf.buffer.byteLength - buf.byteLength;
 	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
@@ -996,10 +1003,10 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
-	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
-	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
-	 * @param {false | "gzip" | "brotli"} options.compression compression used
-	 * @param {boolean} options.readonly disable storing cache into filesystem
+	 * @param {boolean | undefined} options.profile track and log detailed timing information for individual cache items
+	 * @param {boolean | undefined} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli" | undefined} options.compression compression used
+	 * @param {boolean | undefined} options.readonly disable storing cache into filesystem
 	 */
 	constructor({
 		compiler,
@@ -1048,7 +1055,7 @@ class PackFileCacheStrategy {
 		this.newBuildDependencies = new LazySet();
 		/** @type {Snapshot | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
-		/** @type {Map<string, string | false> | undefined} */
+		/** @type {ResolveResults | undefined} */
 		this.resolveResults = undefined;
 		/** @type {Snapshot | undefined} */
 		this.buildSnapshot = undefined;
@@ -1080,7 +1087,7 @@ class PackFileCacheStrategy {
 		let newBuildDependencies;
 		/** @type {Snapshot} */
 		let resolveBuildDependenciesSnapshot;
-		/** @type {Map<string, string | false>} */
+		/** @type {ResolveResults | undefined} */
 		let resolveResults;
 		logger.time("restore cache container");
 		return this.fileSerializer
@@ -1264,6 +1271,9 @@ class PackFileCacheStrategy {
 			});
 	}
 
+	/**
+	 * @param {LazySet<string>} dependencies dependencies to store
+	 */
 	storeBuildDependencies(dependencies) {
 		if (this.readonly) return;
 		this.newBuildDependencies.addAll(dependencies);
@@ -1309,7 +1319,7 @@ class PackFileCacheStrategy {
 									missing,
 									resolveResults,
 									resolveDependencies
-								} = result;
+								} = /** @type {ResolveBuildDependenciesResult} */ (result);
 								if (this.resolveResults) {
 									for (const [key, value] of resolveResults) {
 										this.resolveResults.set(key, value);
@@ -1404,7 +1414,7 @@ class PackFileCacheStrategy {
 					const content = new PackContainer(
 						pack,
 						this.version,
-						this.buildSnapshot,
+						/** @type {Snapshot} */ (this.buildSnapshot),
 						updatedBuildDependencies,
 						this.resolveResults,
 						this.resolveBuildDependenciesSnapshot

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -109,6 +109,9 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 		const used = moduleGraph
 			.getExportInfo(module, dep.name)
 			.getUsedName(dep.name, runtime);
+
+		if (!used) return;
+
 		const moduleId = chunkGraph.getModuleId(module);
 		const identifier =
 			dep.prefix +

package/lib/javascript/JavascriptModulesPlugin.js

@@ -60,14 +60,27 @@ const chunkHasJs = (chunk, chunkGraph) => {
 		: false;
 };
 
+/**
+ * @param {Module} module a module
+ * @param {string} code the code
+ * @returns {string} generated code for the stack
+ */
 const printGeneratedCodeForStack = (module, code) => {
 	const lines = code.split("\n");
 	const n = `${lines.length}`.length;
 	return `\n\nGenerated code for ${module.identifier()}\n${lines
-		.map((line, i, lines) => {
-			const iStr = `${i + 1}`;
-			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
-		})
+		.map(
+			/**
+			 * @param {string} line the line
+			 * @param {number} i the index
+			 * @param {string[]} lines the lines
+			 * @returns {string} the line with line number
+			 */
+			(line, i, lines) => {
+				const iStr = `${i + 1}`;
+				return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
+			}
+		)
 		.join("\n")}`;
 };
 
@@ -443,7 +456,10 @@ class JavascriptModulesPlugin {
 							context.__webpack_require__
 						);
 					} catch (e) {
-						e.stack += printGeneratedCodeForStack(options.module, code);
+						e.stack += printGeneratedCodeForStack(
+							options.module,
+							/** @type {string} */ (code)
+						);
 						throw e;
 					}
 				});
@@ -1007,6 +1023,9 @@ class JavascriptModulesPlugin {
 		const useRequire =
 			requireFunction || interceptModuleExecution || moduleUsed;
 
+		/**
+		 * @type {{startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean}}
+		 */
 		const result = {
 			header: [],
 			beforeStartup: [],

package/lib/library/AmdLibraryPlugin.js

@@ -68,8 +68,8 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string=} */ (name),
-			amdContainer: /** @type {string=} */ (amdContainer)
+			name: /** @type {string} */ (name),
+			amdContainer: /** @type {string} */ (amdContainer)
 		};
 	}
 

package/lib/library/AssignLibraryPlugin.js

@@ -17,6 +17,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -59,6 +60,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 	let i = 1;
 
 	// all properties printed so far (excluding base)
+	/** @type {string[] | undefined} */
 	let propsSoFar;
 
 	// if there is existingLength, print all properties until this position as property access
@@ -142,7 +144,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string|string[]=} */ (name),
+			name: /** @type {string | string[]} */ (name),
 			export: library.export
 		};
 	}
@@ -173,12 +175,22 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {string[]} the prefix
+	 */
 	_getPrefix(compilation) {
 		return this.prefix === "global"
 			? [compilation.runtimeTemplate.globalObject]
 			: this.prefix;
 	}
 
+	/**
+	 * @param {AssignLibraryPluginParsed} options the library options
+	 * @param {Chunk} chunk the chunk
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Array<string>} the resolved full name
+	 */
 	_getResolvedFullName(options, chunk, compilation) {
 		const prefix = this._getPrefix(compilation);
 		const fullName = options.name ? prefix.concat(options.name) : prefix;

package/lib/library/EnableLibraryPlugin.js

@@ -12,6 +12,10 @@
 /** @type {WeakMap<Compiler, Set<LibraryType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler the compiler instance
+ * @returns {Set<LibraryType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {

package/lib/library/SystemLibraryPlugin.js

@@ -59,7 +59,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 			);
 		}
 		return {
-			name: /** @type {string=} */ (name)
+			name: /** @type {string} */ (name)
 		};
 	}
 

package/lib/library/UmdLibraryPlugin.js

@@ -148,6 +148,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			requiredExternals = externals;
 		}
 
+		/**
+		 * @param {string} str the string to replace
+		 * @returns {string} the replaced keys
+		 */
 		const replaceKeys = str => {
 			return compilation.getPath(str, {
 				chunk
@@ -178,6 +182,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			);
 		};
 
+		/**
+		 * @param {string} type the type
+		 * @returns {string} external require array
+		 */
 		const externalsRequireArray = type => {
 			return replaceKeys(
 				externals
@@ -185,7 +193,9 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						let expr;
 						let request = m.request;
 						if (typeof request === "object") {
-							request = request[type];
+							request =
+								/** @type {Record<string, string | string[]>} */
+								(request)[type];
 						}
 						if (request === undefined) {
 							throw new Error(
@@ -246,6 +256,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 
 		const { auxiliaryComment, namedDefine, names } = options;
 
+		/**
+		 * @param {keyof LibraryCustomUmdCommentObject} type type
+		 * @returns {string} comment
+		 */
 		const getAuxiliaryComment = type => {
 			if (auxiliaryComment) {
 				if (typeof auxiliaryComment === "string")
@@ -299,7 +313,11 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						  "	else\n" +
 						  "		" +
 						  replaceKeys(
-								accessorAccess("root", names.root || names.commonjs)
+								accessorAccess(
+									"root",
+									/** @type {string | string[]} */ (names.root) ||
+										/** @type {string} */ (names.commonjs)
+								)
 						  ) +
 						  " = factory(" +
 						  externalsRootArray(externals) +

package/lib/util/StackedCacheMap.js

@@ -19,7 +19,7 @@ class StackedCacheMap {
 
 	/**
 	 * @param {ReadonlyMap<K, V>} map map to add
-	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
+	 * @param {boolean=} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
 	 */
 	addAll(map, immutable) {
 		if (immutable) {

package/lib/util/URLAbsoluteSpecifier.js

@@ -76,7 +76,7 @@ function getScheme(specifier) {
 
 /**
  * @param {string} specifier specifier
- * @returns {string|null} protocol if absolute URL specifier provided
+ * @returns {string | null | undefined} protocol if absolute URL specifier provided
  */
 function getProtocol(specifier) {
 	const scheme = getScheme(specifier);