webpack 5.101.3 → 5.102.1

package/lib/ChunkGraph.js

@@ -31,6 +31,8 @@ const {
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").Chunks} Chunks */
+/** @typedef {import("./Chunk").Entrypoints} Entrypoints */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
@@ -79,7 +81,7 @@ class ModuleHashInfo {
 const getArray = (set) => [...set];
 
 /**
- * @param {SortableSet<Chunk>} chunks the chunks
+ * @param {SortableChunks} chunks the chunks
  * @returns {RuntimeSpecSet} runtimes
  */
 const getModuleRuntimes = (chunks) => {
@@ -91,7 +93,7 @@ const getModuleRuntimes = (chunks) => {
 };
 
 /**
- * @param {WeakMap<Module, Set<string>> | undefined} sourceTypesByModule sourceTypesByModule
+ * @param {SourceTypesByModule | undefined} sourceTypesByModule sourceTypesByModule
  * @returns {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} modules by source type
  */
 const modulesBySourceType = (sourceTypesByModule) => (set) => {
@@ -192,13 +194,14 @@ const isAvailableChunk = (a, b) => {
 	return true;
 };
 
+/** @typedef {SortableSet<Chunk>} SortableChunks */
 /** @typedef {Set<Chunk>} EntryInChunks */
 /** @typedef {Set<Chunk>} RuntimeInChunks */
 /** @typedef {string | number} ModuleId */
 
 class ChunkGraphModule {
 	constructor() {
-		/** @type {SortableSet<Chunk>} */
+		/** @type {SortableChunks} */
 		this.chunks = new SortableSet();
 		/** @type {EntryInChunks | undefined} */
 		this.entryInChunks = undefined;
@@ -217,13 +220,16 @@ class ChunkGraphModule {
 	}
 }
 
+/** @typedef {WeakMap<Module, Set<string>>} SourceTypesByModule */
+/** @typedef {Map<Module, Entrypoint>} EntryModules */
+
 class ChunkGraphChunk {
 	constructor() {
 		/** @type {SortableSet<Module>} */
 		this.modules = new SortableSet();
-		/** @type {WeakMap<Module, Set<string>> | undefined} */
+		/** @type {SourceTypesByModule | undefined} */
 		this.sourceTypesByModule = undefined;
-		/** @type {Map<Module, Entrypoint>} */
+		/** @type {EntryModules} */
 		this.entryModules = new Map();
 		/** @type {SortableSet<RuntimeModule>} */
 		this.runtimeModules = new SortableSet();
@@ -231,7 +237,7 @@ class ChunkGraphChunk {
 		this.fullHashModules = undefined;
 		/** @type {Set<RuntimeModule> | undefined} */
 		this.dependentHashModules = undefined;
-		/** @type {Set<string> | undefined} */
+		/** @type {RuntimeRequirements | undefined} */
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
 		this.runtimeRequirementsInTree = new Set();
@@ -240,6 +246,11 @@ class ChunkGraphChunk {
 	}
 }
 
+/** @typedef {string | number} RuntimeId */
+/** @typedef {Record<ModuleId, string>} IdToHashMap */
+/** @typedef {Record<ChunkId, IdToHashMap>} ChunkModuleHashMap */
+/** @typedef {Record<ChunkId, ModuleId[]>} ChunkModuleIdMap */
+
 /** @typedef {(a: Module, b: Module) => -1 | 0 | 1} ModuleComparator */
 
 class ChunkGraph {
@@ -265,7 +276,7 @@ class ChunkGraph {
 		this._blockChunkGroups = new WeakMap();
 		/**
 		 * @private
-		 * @type {Map<string, string | number>}
+		 * @type {Map<string, RuntimeId>}
 		 */
 		this._runtimeIds = new Map();
 		/** @type {ModuleGraph} */
@@ -452,7 +463,7 @@ class ChunkGraph {
 			for (const chunk of oldCgm.entryInChunks) {
 				const cgc = this._getChunkGraphChunk(chunk);
 				const old = /** @type {Entrypoint} */ (cgc.entryModules.get(oldModule));
-				/** @type {Map<Module, Entrypoint>} */
+				/** @type {EntryModules} */
 				const newEntryModules = new Map();
 				for (const [m, cg] of cgc.entryModules) {
 					if (m === oldModule) {
@@ -740,16 +751,16 @@ class ChunkGraph {
 	 * @param {Chunk} chunk the chunk
 	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
 	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
+	 * @returns {ChunkModuleIdMap} chunk to module ids object
 	 */
 	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
-		/** @type {Record<string|number, (string|number)[]>} */
+		/** @type {ChunkModuleIdMap} */
 		const chunkModuleIdMap = Object.create(null);
 
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
-			/** @type {(string | number)[] | undefined} */
+			/** @type {ModuleId[] | undefined} */
 			let array;
 			for (const module of this.getOrderedChunkModulesIterable(
 				asyncChunk,
@@ -774,7 +785,7 @@ class ChunkGraph {
 	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
 	 * @param {number} hashLength length of the hash
 	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
+	 * @returns {ChunkModuleHashMap} chunk to module id to module hash object
 	 */
 	getChunkModuleRenderedHashMap(
 		chunk,
@@ -782,11 +793,9 @@ class ChunkGraph {
 		hashLength = 0,
 		includeAllChunks = false
 	) {
-		/** @type {Record<ChunkId, Record<string|number, string>>} */
+		/** @type {ChunkModuleHashMap} */
 		const chunkModuleHashMap = Object.create(null);
 
-		/** @typedef {Record<string|number, string>} IdToHashMap  */
-
 		for (const asyncChunk of includeAllChunks
 			? chunk.getAllReferencedChunks()
 			: chunk.getAllAsyncChunks()) {
@@ -800,7 +809,8 @@ class ChunkGraph {
 					if (idToHashMap === undefined) {
 						idToHashMap = Object.create(null);
 						chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] =
-							/** @type {IdToHashMap} */ (idToHashMap);
+							/** @type {IdToHashMap} */
+							(idToHashMap);
 					}
 					const moduleId = this.getModuleId(module);
 					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
@@ -818,7 +828,7 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
-	 * @returns {Record<string|number, boolean>} chunk map
+	 * @returns {Record<ChunkId, boolean>} chunk map
 	 */
 	getChunkConditionMap(chunk, filterFn) {
 		const map = Object.create(null);
@@ -1219,7 +1229,7 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks
 	 */
 	getChunkEntryDependentChunksIterable(chunk) {
-		/** @type {Set<Chunk>} */
+		/** @type {Chunks} */
 		const set = new Set();
 		for (const chunkGroup of chunk.groupsIterable) {
 			if (chunkGroup instanceof Entrypoint) {
@@ -1243,10 +1253,10 @@ class ChunkGraph {
 	 * @returns {Iterable<Chunk>} iterable of chunks and include chunks from children entrypoints
 	 */
 	getRuntimeChunkDependentChunksIterable(chunk) {
-		/** @type {Set<Chunk>} */
+		/** @type {Chunks} */
 		const set = new Set();
 
-		/** @type {Set<Entrypoint>} */
+		/** @type {Entrypoints} */
 		const entrypoints = new Set();
 
 		for (const chunkGroup of chunk.groupsIterable) {
@@ -1423,15 +1433,15 @@ class ChunkGraph {
 
 	/**
 	 * @param {string} runtime runtime
-	 * @returns {string | number} the id of the runtime
+	 * @returns {RuntimeId} the id of the runtime
 	 */
 	getRuntimeId(runtime) {
-		return /** @type {string | number} */ (this._runtimeIds.get(runtime));
+		return /** @type {RuntimeId} */ (this._runtimeIds.get(runtime));
 	}
 
 	/**
 	 * @param {string} runtime runtime
-	 * @param {string | number} id the id of the runtime
+	 * @param {RuntimeId} id the id of the runtime
 	 * @returns {void}
 	 */
 	setRuntimeId(runtime, id) {
@@ -1531,7 +1541,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
 	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
 	 * @returns {void}
 	 */
@@ -1565,7 +1575,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 
 	/**
 	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @param {RuntimeRequirements} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
 	 * @returns {void}
 	 */
 	addChunkRuntimeRequirements(chunk, items) {
@@ -1660,7 +1670,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				for (const type of sourceTypes) hash.update(type);
 			}
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
-			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
+			return BigInt(`0x${hash.digest("hex")}`);
 		});
 		return graphHash;
 	}
@@ -1798,7 +1808,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				}
 			}
 			hash.update(graphHash);
-			return /** @type {string} */ (hash.digest("hex"));
+			return hash.digest("hex");
 		});
 	}
 

package/lib/ChunkGroup.js

@@ -21,8 +21,7 @@ const {
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-/** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module | null, loc: DependencyLocation, request: string}} OriginRecord */
+/** @typedef {{ module: Module | null, loc: DependencyLocation, request: string }} OriginRecord */
 
 /**
  * @typedef {object} RawChunkGroupOptions
@@ -114,13 +113,12 @@ class ChunkGroup {
 	 * @returns {void}
 	 */
 	addOptions(options) {
-		for (const _key of Object.keys(options)) {
-			const key =
-				/** @type {keyof ChunkGroupOptions} */
-				(_key);
+		for (const key of /** @type {(keyof ChunkGroupOptions)[]} */ (
+			Object.keys(options)
+		)) {
 			if (this.options[key] === undefined) {
-				/** @type {EXPECTED_ANY} */
-				(this.options)[key] = options[key];
+				/** @type {ChunkGroupOptions[keyof ChunkGroupOptions]} */
+				(this.options[key]) = options[key];
 			} else if (this.options[key] !== options[key]) {
 				if (key.endsWith("Order")) {
 					const orderKey =
@@ -144,7 +142,7 @@ class ChunkGroup {
 
 	/**
 	 * returns the name of current ChunkGroup
-	 * @returns {string | null | undefined} returns the ChunkGroup name
+	 * @returns {ChunkGroupOptions["name"]} returns the ChunkGroup name
 	 */
 	get name() {
 		return this.options.name;
@@ -373,7 +371,7 @@ class ChunkGroup {
 	}
 
 	/**
-	 * @returns {Array<AsyncDependenciesBlock>} an array containing the blocks
+	 * @returns {AsyncDependenciesBlock[]} an array containing the blocks
 	 */
 	getBlocks() {
 		return this._blocks.getFromCache(getArray);

package/lib/ChunkTemplate.js

@@ -9,7 +9,7 @@ const util = require("util");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */

package/lib/CleanPlugin.js

@@ -30,7 +30,7 @@ const processAsyncTree = require("./util/processAsyncTree");
 /**
  * @callback KeepFn
  * @param {string} path path
- * @returns {boolean | void} true, if the path should be kept
+ * @returns {boolean | undefined} true, if the path should be kept
  */
 
 const validate = createSchemaValidation(
@@ -170,7 +170,7 @@ const doStat = (fs, filename, callback) => {
  * @param {boolean} dry only log instead of fs modification
  * @param {Logger} logger logger
  * @param {Diff} diff filenames of the assets that shouldn't be there
- * @param {(path: string) => boolean | void} isKept check if the entry is ignored
+ * @param {KeepFn} isKept check if the entry is ignored
  * @param {(err?: Error, assets?: Assets) => void} callback callback
  * @returns {void}
  */
@@ -436,7 +436,7 @@ class CleanPlugin {
 
 				/**
 				 * @param {string} path path
-				 * @returns {boolean | void} true, if needs to be kept
+				 * @returns {boolean | undefined} true, if needs to be kept
 				 */
 				const isKept = (path) => {
 					const result = hooks.keep.call(path);

package/lib/CodeGenerationResults.js

@@ -14,6 +14,7 @@ const { RuntimeSpecMap, runtimeToString } = require("./util/runtime");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -117,7 +118,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
 	 * @param {string} key data key
-	 * @returns {TODO | undefined} data generated by code generation
+	 * @returns {ReturnType<CodeGenerationResultData["get"]>} data generated by code generation
 	 */
 	getData(module, runtime, key) {
 		const data = this.get(module, runtime).data;
@@ -140,7 +141,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		if (info.runtimeRequirements) {
 			for (const rr of info.runtimeRequirements) hash.update(rr);
 		}
-		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+		return (info.hash = hash.digest("hex"));
 	}
 
 	/**

package/lib/CompatibilityPlugin.js

@@ -16,9 +16,22 @@ const ConstDependency = require("./dependencies/ConstDependency");
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./javascript/JavascriptParser").TagData} TagData */
+
+/**
+ * @typedef {object} CompatibilitySettingsDeclaration
+ * @property {boolean} updated
+ * @property {DependencyLocation} loc
+ * @property {Range} range
+ */
+
+/**
+ * @typedef {object} CompatibilitySettings
+ * @property {string} name
+ * @property {CompatibilitySettingsDeclaration} declaration
+ */
 
 const nestedWebpackIdentifierTag = Symbol("nested webpack identifier");
 const PLUGIN_NAME = "CompatibilityPlugin";
@@ -67,9 +80,12 @@ class CompatibilityPlugin {
 								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								if (parser.state.current.dependencies.length > 0) {
 									const last =
-										parser.state.current.dependencies[
-											parser.state.current.dependencies.length - 1
-										];
+										/** @type {ContextDependency} */
+										(
+											parser.state.current.dependencies[
+												parser.state.current.dependencies.length - 1
+											]
+										);
 									if (
 										last.critical &&
 										last.options &&
@@ -99,7 +115,8 @@ class CompatibilityPlugin {
 							statement.id.name === RuntimeGlobals.require
 						) {
 							const newName = `__nested_webpack_require_${
-								/** @type {Range} */ (statement.range)[0]
+								/** @type {Range} */
+								(statement.range)[0]
 							}__`;
 							parser.tagVariable(
 								statement.id.name,
@@ -108,8 +125,8 @@ class CompatibilityPlugin {
 									name: newName,
 									declaration: {
 										updated: false,
-										loc: statement.id.loc,
-										range: statement.id.range
+										loc: /** @type {DependencyLocation} */ (statement.id.loc),
+										range: /** @type {Range} */ (statement.id.range)
 									}
 								}
 							);
@@ -126,8 +143,8 @@ class CompatibilityPlugin {
 								name: newName,
 								declaration: {
 									updated: false,
-									loc: pattern.loc,
-									range: pattern.range
+									loc: /** @type {DependencyLocation} */ (pattern.loc),
+									range: /** @type {Range} */ (pattern.range)
 								}
 							});
 							return true;
@@ -139,8 +156,8 @@ class CompatibilityPlugin {
 								name: "__nested_webpack_exports__",
 								declaration: {
 									updated: false,
-									loc: pattern.loc,
-									range: pattern.range
+									loc: /** @type {DependencyLocation} */ (pattern.loc),
+									range: /** @type {Range} */ (pattern.range)
 								}
 							});
 							return true;
@@ -149,7 +166,7 @@ class CompatibilityPlugin {
 						.for(nestedWebpackIdentifierTag)
 						.tap(PLUGIN_NAME, (expr) => {
 							const { name, declaration } =
-								/** @type {TagData} */
+								/** @type {CompatibilitySettings} */
 								(parser.currentTagData);
 							if (!declaration.updated) {
 								const dep = new ConstDependency(name, declaration.range);