webpack 5.93.0 → 5.95.0

package/lib/ChunkGraph.js

@@ -30,6 +30,7 @@ const {
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
@@ -73,9 +74,7 @@ class ModuleHashInfo {
  * @param {SortableSet<T>} set the set
  * @returns {T[]} set as array
  */
-const getArray = set => {
-	return Array.from(set);
-};
+const getArray = set => Array.from(set);
 
 /**
  * @param {SortableSet<Chunk>} chunks the chunks
@@ -159,7 +158,7 @@ const getModulesSize = modules => {
  * @returns {Record<string, number>} the sizes of the modules
  */
 const getModulesSizes = modules => {
-	let sizes = Object.create(null);
+	const sizes = Object.create(null);
 	for (const module of modules) {
 		for (const type of module.getSourceTypes()) {
 			sizes[type] = (sizes[type] || 0) + module.size(type);
@@ -199,7 +198,7 @@ class ChunkGraphModule {
 		this.runtimeInChunks = undefined;
 		/** @type {RuntimeSpecMap<ModuleHashInfo> | undefined} */
 		this.hashes = undefined;
-		/** @type {string | number} */
+		/** @type {ModuleId | null} */
 		this.id = null;
 		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
 		this.runtimeRequirements = undefined;
@@ -702,7 +701,7 @@ class ChunkGraph {
 		const modulesWithSourceType = cgc.modules
 			.getFromUnorderedCache(cgc._modulesBySourceType)
 			.get(sourceType);
-		if (modulesWithSourceType === undefined) return undefined;
+		if (modulesWithSourceType === undefined) return;
 		modulesWithSourceType.sortWith(comparator);
 		return modulesWithSourceType;
 	}
@@ -749,9 +748,9 @@ class ChunkGraph {
 				if (filterFn(module)) {
 					if (array === undefined) {
 						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
+						chunkModuleIdMap[/** @type {ChunkId} */ (asyncChunk.id)] = array;
 					}
-					const moduleId = this.getModuleId(module);
+					const moduleId = /** @type {ModuleId} */ (this.getModuleId(module));
 					array.push(moduleId);
 				}
 			}
@@ -773,13 +772,15 @@ class ChunkGraph {
 		hashLength = 0,
 		includeAllChunks = false
 	) {
-		/** @type {Record<string|number, Record<string|number, string>>} */
+		/** @type {Record<ChunkId, Record<string|number, string>>} */
 		const chunkModuleHashMap = Object.create(null);
 
+		/** @typedef {Record<string|number, string>} IdToHashMap  */
+
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
-			/** @type {Record<string|number, string> | undefined} */
+			/** @type {IdToHashMap | undefined} */
 			let idToHashMap;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -788,11 +789,15 @@ class ChunkGraph {
 				if (filterFn(module)) {
 					if (idToHashMap === undefined) {
 						idToHashMap = Object.create(null);
-						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
+						chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] =
+							/** @type {IdToHashMap} */ (idToHashMap);
 					}
 					const moduleId = this.getModuleId(module);
 					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
-					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
+					/** @type {IdToHashMap} */
+					(idToHashMap)[/** @type {ModuleId} */ (moduleId)] = hashLength
+						? hash.slice(0, hashLength)
+						: hash;
 				}
 			}
 		}
@@ -808,7 +813,7 @@ class ChunkGraph {
 	getChunkConditionMap(chunk, filterFn) {
 		const map = Object.create(null);
 		for (const c of chunk.getAllReferencedChunks()) {
-			map[c.id] = filterFn(c, this);
+			map[/** @type {ChunkId} */ (c.id)] = filterFn(c, this);
 		}
 		return map;
 	}
@@ -916,7 +921,7 @@ class ChunkGraph {
 		const cgcB = this._getChunkGraphChunk(chunkB);
 		const allModules = new Set(cgcA.modules);
 		for (const m of cgcB.modules) allModules.add(m);
-		let modulesSize = getModulesSize(allModules);
+		const modulesSize = getModulesSize(allModules);
 		const chunkOverhead =
 			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
 		const entryChunkMultiplicator =
@@ -950,9 +955,9 @@ class ChunkGraph {
 				return isAvailableChunk(chunkA, chunkB);
 			} else if (hasRuntimeB) {
 				return isAvailableChunk(chunkB, chunkA);
-			} else {
-				return false;
 			}
+
+			return false;
 		}
 
 		if (
@@ -1011,7 +1016,12 @@ class ChunkGraph {
 			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
 		)) {
 			this.disconnectChunkAndEntryModule(chunkB, module);
-			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
+			this.connectChunkAndEntryModule(
+				chunkA,
+				module,
+				/** @type {Entrypoint} */
+				(chunkGroup)
+			);
 		}
 
 		for (const chunkGroup of chunkB.groupsIterable) {
@@ -1052,7 +1062,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the new chunk
 	 * @param {Module} module the entry module
-	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
+	 * @param {Entrypoint} entrypoint the chunk group which must be loaded before the module is executed
 	 * @returns {void}
 	 */
 	connectChunkAndEntryModule(chunk, module, entrypoint) {
@@ -1111,8 +1121,9 @@ class ChunkGraph {
 	disconnectChunkAndEntryModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.entryInChunks.delete(chunk);
-		if (cgm.entryInChunks.size === 0) {
+		/** @type {EntryInChunks} */
+		(cgm.entryInChunks).delete(chunk);
+		if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) {
 			cgm.entryInChunks = undefined;
 		}
 		cgc.entryModules.delete(module);
@@ -1126,8 +1137,9 @@ class ChunkGraph {
 	disconnectChunkAndRuntimeModule(chunk, module) {
 		const cgm = this._getChunkGraphModule(module);
 		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.runtimeInChunks.delete(chunk);
-		if (cgm.runtimeInChunks.size === 0) {
+		/** @type {RuntimeInChunks} */
+		(cgm.runtimeInChunks).delete(chunk);
+		if (/** @type {RuntimeInChunks} */ (cgm.runtimeInChunks).size === 0) {
 			cgm.runtimeInChunks = undefined;
 		}
 		cgc.runtimeModules.delete(module);
@@ -1154,8 +1166,9 @@ class ChunkGraph {
 		const cgc = this._getChunkGraphChunk(chunk);
 		for (const module of cgc.entryModules.keys()) {
 			const cgm = this._getChunkGraphModule(module);
-			cgm.entryInChunks.delete(chunk);
-			if (cgm.entryInChunks.size === 0) {
+			/** @type {EntryInChunks} */
+			(cgm.entryInChunks).delete(chunk);
+			if (/** @type {EntryInChunks} */ (cgm.entryInChunks).size === 0) {
 				cgm.entryInChunks = undefined;
 			}
 		}
@@ -1322,7 +1335,7 @@ class ChunkGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {ModuleId} the id of the module
+	 * @returns {ModuleId | null} the id of the module
 	 */
 	getModuleId(module) {
 		const cgm = this._getChunkGraphModule(module);
@@ -1344,7 +1357,7 @@ class ChunkGraph {
 	 * @returns {string | number} the id of the runtime
 	 */
 	getRuntimeId(runtime) {
-		return this._runtimeIds.get(runtime);
+		return /** @type {string | number} */ (this._runtimeIds.get(runtime));
 	}
 
 	/**
@@ -1474,10 +1487,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
 				for (const item of items) runtimeRequirements.add(item);
 				return runtimeRequirements;
-			} else {
-				for (const item of runtimeRequirements) items.add(item);
-				return items;
 			}
+
+			for (const item of runtimeRequirements) items.add(item);
+			return items;
 		});
 	}
 
@@ -1593,6 +1606,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		if (cgm.graphHashesWithConnections === undefined) {
 			cgm.graphHashesWithConnections = new RuntimeSpecMap();
 		}
+
 		/**
 		 * @param {ConnectionState} state state
 		 * @returns {"F" | "T" | "O"} result
@@ -1615,6 +1629,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			const activeNamespaceModules = new Set();
 			/** @type {Map<string, Module | Set<Module>>} */
 			const connectedModules = new Map();
+			/**
+			 * @param {ModuleGraphConnection} connection connection
+			 * @param {string} stateInfo state info
+			 */
 			const processConnection = (connection, stateInfo) => {
 				const module = connection.module;
 				stateInfo += module.getExportsType(this.moduleGraph, strict);
@@ -1696,7 +1714,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				hash.update(xor.toString(16));
 			};
 			if (activeNamespaceModules.size === 1)
-				addModuleToHash(activeNamespaceModules.values().next().value);
+				addModuleToHash(
+					/** @type {Module} */ (activeNamespaceModules.values().next().value)
+				);
 			else if (activeNamespaceModules.size > 1)
 				addModulesToHash(activeNamespaceModules);
 			for (const [stateInfo, modules] of connectedModulesInOrder) {
@@ -1740,12 +1760,13 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				const chunkGraph = chunkGraphForModuleMap.get(module);
 				if (!chunkGraph)
 					throw new Error(
-						deprecateMessage +
-							": There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)"
+						`${
+							deprecateMessage
+						}: There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)`
 					);
 				return chunkGraph;
 			},
-			deprecateMessage + ": Use new ChunkGraph API",
+			`${deprecateMessage}: Use new ChunkGraph API`,
 			deprecationCode
 		);
 		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
@@ -1790,12 +1811,13 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				const chunkGraph = chunkGraphForChunkMap.get(chunk);
 				if (!chunkGraph)
 					throw new Error(
-						deprecateMessage +
-							"There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)"
+						`${
+							deprecateMessage
+						}There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)`
 					);
 				return chunkGraph;
 			},
-			deprecateMessage + ": Use new ChunkGraph API",
+			`${deprecateMessage}: Use new ChunkGraph API`,
 			deprecationCode
 		);
 		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);

package/lib/ChunkGroup.js

@@ -22,7 +22,7 @@ const {
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 
 /** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
+/** @typedef {{module: Module | null, loc: DependencyLocation, request: string}} OriginRecord */
 
 /**
  * @typedef {object} RawChunkGroupOptions
@@ -404,7 +404,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @param {Module} module origin module
+	 * @param {Module | null} module origin module
 	 * @param {DependencyLocation} loc location of the reference in the origin module
 	 * @param {string} request request name of the reference
 	 * @returns {void}
@@ -478,7 +478,6 @@ class ChunkGroup {
 	/**
 	 * Sorting predicate which allows current ChunkGroup to be compared against another.
 	 * Sorting values are based off of number of chunks in ChunkGroup.
-	 *
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
 	 * @returns {-1|0|1} sort position for comparison

package/lib/ChunkTemplate.js

@@ -8,8 +8,21 @@
 const util = require("util");
 const memoize = require("./util/memoize");
 
+/** @typedef {import("tapable").Tap} Tap */
 /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("./Compilation").Hash} Hash */
+/** @typedef {import("./Compilation").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Compilation").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./Compilation").Source} Source */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/**
+ * @template T
+ * @typedef {import("tapable").IfSet<T>} IfSet
+ */
 
 const getJavascriptModulesPlugin = memoize(() =>
 	require("./javascript/JavascriptModulesPlugin")
@@ -26,6 +39,11 @@ class ChunkTemplate {
 		this.hooks = Object.freeze({
 			renderManifest: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn function
+					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
 							options,
@@ -41,6 +59,11 @@ class ChunkTemplate {
 			},
 			modules: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -58,6 +81,11 @@ class ChunkTemplate {
 			},
 			render: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, ModuleTemplate, RenderContext): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -75,6 +103,11 @@ class ChunkTemplate {
 			},
 			renderWithEntry: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, Chunk): Source} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -96,6 +129,11 @@ class ChunkTemplate {
 			},
 			hash: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash): void} fn function
+					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
 					},
@@ -105,6 +143,11 @@ class ChunkTemplate {
 			},
 			hashForChunk: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash, Chunk, ChunkHashContext): void} fn function
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)

package/lib/CleanPlugin.js

@@ -7,7 +7,7 @@
 
 const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
-const Compilation = require("../lib/Compilation");
+const Compilation = require("./Compilation");
 const createSchemaValidation = require("./util/create-schema-validation");
 const { join } = require("./util/fs");
 const processAsyncTree = require("./util/processAsyncTree");
@@ -28,6 +28,12 @@ const processAsyncTree = require("./util/processAsyncTree");
  * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
  */
 
+/**
+ * @callback KeepFn
+ * @param {string} path path
+ * @returns {boolean} true, if the path should be kept
+ */
+
 const validate = createSchemaValidation(
 	undefined,
 	() => {
@@ -326,21 +332,14 @@ class CleanPlugin {
 	apply(compiler) {
 		const { dry, keep } = this.options;
 
+		/** @type {KeepFn} */
 		const keepFn =
 			typeof keep === "function"
 				? keep
 				: typeof keep === "string"
-					? /**
-						 * @param {string} path path
-						 * @returns {boolean} true, if the path should be kept
-						 */
-						path => path.startsWith(keep)
+					? path => path.startsWith(keep)
 					: typeof keep === "object" && keep.test
-						? /**
-							 * @param {string} path path
-							 * @returns {boolean} true, if the path should be kept
-							 */
-							path => keep.test(path)
+						? path => keep.test(path)
 						: () => false;
 
 		// We assume that no external modification happens while the compiler is active

package/lib/CodeGenerationResults.js

@@ -42,7 +42,9 @@ class CodeGenerationResults {
 			);
 		}
 		if (runtime === undefined) {
-			if (entry.size > 1) {
+			if (
+				/** @type {RuntimeSpecMap<CodeGenerationResult>} */ (entry).size > 1
+			) {
 				const results = new Set(entry.values());
 				if (results.size !== 1) {
 					throw new Error(
@@ -53,9 +55,9 @@ class CodeGenerationResults {
 Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 					);
 				}
-				return first(results);
+				return /** @type {CodeGenerationResult} */ (first(results));
 			}
-			return entry.values().next().value;
+			return /** @type {CodeGenerationResult} */ (entry.values().next().value);
 		}
 		const result = entry.get(runtime);
 		if (result === undefined) {
@@ -86,9 +88,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		} else if (entry.size > 1) {
 			const results = new Set(entry.values());
 			return results.size === 1;
-		} else {
-			return entry.size === 1;
 		}
+		return entry.size === 1;
 	}
 
 	/**

package/lib/CommentCompilationWarning.js

@@ -12,7 +12,6 @@ const makeSerializable = require("./util/makeSerializable");
 
 class CommentCompilationWarning extends WebpackError {
 	/**
-	 *
 	 * @param {string} message warning message
 	 * @param {DependencyLocation} loc affected lines of code
 	 */