webpack 5.93.0 → 5.95.0

package/lib/Compiler.js

@@ -14,7 +14,7 @@ const {
 	AsyncSeriesHook
 } = require("tapable");
 const { SizeOnlySource } = require("webpack-sources");
-const webpack = require("./");
+const webpack = require(".");
 const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
@@ -47,13 +47,18 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
 /** @typedef {import("./logging/createConsoleLogger").LoggingFunction} LoggingFunction */
-/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
+/**
+ * @template {any[]} T
+ * @template V
+ * @typedef {import("./util/WeakTupleMap")<T, V>} WeakTupleMap
+ */
+
 /**
  * @typedef {object} CompilationParams
  * @property {NormalModuleFactory} normalModuleFactory
@@ -127,9 +132,8 @@ const includesHash = (filename, hashes) => {
 	if (!hashes) return false;
 	if (Array.isArray(hashes)) {
 		return hashes.some(hash => filename.includes(hash));
-	} else {
-		return filename.includes(hashes);
 	}
+	return filename.includes(hashes);
 };
 
 class Compiler {
@@ -197,7 +201,7 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[]>} */
 			shutdown: new AsyncSeriesHook([]),
 
-			/** @type {SyncBailHook<[string, string, any[]], true>} */
+			/** @type {SyncBailHook<[string, string, any[] | undefined], true>} */
 			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
 
 			// TODO the following hooks are weirdly located here
@@ -284,7 +288,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {Map<Module, { buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap }> | undefined} */
+		/** @type {Map<Module, { buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap<any, any> }> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";
@@ -354,10 +358,11 @@ class Compiler {
 						);
 					}
 				}
-				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
-					if (this.infrastructureLogger !== undefined) {
-						this.infrastructureLogger(name, type, args);
-					}
+				if (
+					this.hooks.infrastructureLog.call(name, type, args) === undefined &&
+					this.infrastructureLogger !== undefined
+				) {
+					this.infrastructureLogger(name, type, args);
 				}
 			},
 			childName => {
@@ -382,36 +387,33 @@ class Compiler {
 							}
 							return `${name}/${childName}`;
 						});
-					} else {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
 					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
+					return this.getInfrastructureLogger(() => {
+						if (typeof name === "function") {
+							name = name();
+							if (!name) {
+								throw new TypeError(
+									"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+								);
 							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getInfrastructureLogger(`${name}/${childName}`);
-					}
+						}
+						return `${name}/${childName}`;
+					});
+				}
+				if (typeof childName === "function") {
+					return this.getInfrastructureLogger(() => {
+						if (typeof childName === "function") {
+							childName = childName();
+							if (!childName) {
+								throw new TypeError(
+									"Logger.getChildLogger(name) called with a function not returning a name"
+								);
+							}
+						}
+						return `${name}/${childName}`;
+					});
 				}
+				return this.getInfrastructureLogger(`${name}/${childName}`);
 			}
 		);
 	}
@@ -623,11 +625,11 @@ class Compiler {
 		const finalCallback = (err, entries, compilation) => {
 			try {
 				callback(err, entries, compilation);
-			} catch (e) {
+			} catch (runAsChildErr) {
 				const err = new WebpackError(
-					`compiler.runAsChild callback error: ${e}`
+					`compiler.runAsChild callback error: ${runAsChildErr}`
 				);
-				err.details = /** @type {Error} */ (e).stack;
+				err.details = /** @type {Error} */ (runAsChildErr).stack;
 				/** @type {Compilation} */
 				(this.parentCompilation).errors.push(err);
 			}
@@ -765,18 +767,17 @@ ${other}`);
 									callback(err);
 								}
 								return true;
-							} else {
-								caseInsensitiveMap.set(
-									caseInsensitiveTargetPath,
-									(similarEntry = /** @type {SimilarEntry} */ ({
-										path: targetPath,
-										source,
-										size: undefined,
-										waiting: undefined
-									}))
-								);
-								return false;
 							}
+							caseInsensitiveMap.set(
+								caseInsensitiveTargetPath,
+								(similarEntry = /** @type {SimilarEntry} */ ({
+									path: targetPath,
+									source,
+									size: undefined,
+									waiting: undefined
+								}))
+							);
+							return false;
 						};
 
 						/**
@@ -786,14 +787,12 @@ ${other}`);
 						const getContent = () => {
 							if (typeof source.buffer === "function") {
 								return source.buffer();
-							} else {
-								const bufferOrString = source.source();
-								if (Buffer.isBuffer(bufferOrString)) {
-									return bufferOrString;
-								} else {
-									return Buffer.from(bufferOrString, "utf8");
-								}
 							}
+							const bufferOrString = source.source();
+							if (Buffer.isBuffer(bufferOrString)) {
+								return bufferOrString;
+							}
+							return Buffer.from(bufferOrString, "utf8");
 						};
 
 						const alreadyWritten = () => {
@@ -917,9 +916,8 @@ ${other}`);
 										!content.equals(/** @type {Buffer} */ (existingContent))
 									) {
 										return doWrite(content);
-									} else {
-										return alreadyWritten();
 									}
+									return alreadyWritten();
 								});
 							}
 
@@ -956,10 +954,9 @@ ${other}`);
 									});
 
 									return callback();
-								} else {
-									// Settings immutable will make it accept file content without comparing when file exist
-									immutable = true;
 								}
+								// Settings immutable will make it accept file content without comparing when file exist
+								immutable = true;
 							} else if (!immutable) {
 								if (checkSimilarFile()) return;
 								// We wrote to this file before which has very likely a different content
@@ -986,7 +983,7 @@ ${other}`);
 						}
 					};
 
-					if (targetFile.match(/\/|\\/)) {
+					if (/\/|\\/.test(targetFile)) {
 						const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
 						const dir = dirname(fs, join(fs, outputPath, targetFile));
 						mkdirp(fs, dir, writeOut);
@@ -1041,12 +1038,10 @@ ${other}`);
 			} else {
 				this.hooks.emitRecords.callAsync(callback);
 			}
+		} else if (this.recordsOutputPath) {
+			this._emitRecords(callback);
 		} else {
-			if (this.recordsOutputPath) {
-				this._emitRecords(callback);
-			} else {
-				callback();
-			}
+			callback();
 		}
 	}
 
@@ -1115,13 +1110,11 @@ ${other}`);
 				this.records = {};
 				this.hooks.readRecords.callAsync(callback);
 			}
+		} else if (this.recordsInputPath) {
+			this._readRecords(callback);
 		} else {
-			if (this.recordsInputPath) {
-				this._readRecords(callback);
-			} else {
-				this.records = {};
-				callback();
-			}
+			this.records = {};
+			callback();
 		}
 	}
 
@@ -1150,10 +1143,10 @@ ${other}`);
 						this.records = parseJson(
 							/** @type {Buffer} */ (content).toString("utf-8")
 						);
-					} catch (e) {
+					} catch (parseErr) {
 						return callback(
 							new Error(
-								`Cannot parse records: ${/** @type {Error} */ (e).message}`
+								`Cannot parse records: ${/** @type {Error} */ (parseErr).message}`
 							)
 						);
 					}
@@ -1233,11 +1226,17 @@ ${other}`);
 					"invalid",
 					"done",
 					"thisCompilation"
-				].includes(name)
+				].includes(name) &&
+				childCompiler.hooks[/** @type {keyof Compiler["hooks"]} */ (name)]
 			) {
-				if (childCompiler.hooks[name]) {
-					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
-				}
+				childCompiler.hooks[
+					/** @type {keyof Compiler["hooks"]} */
+					(name)
+				].taps =
+					this.hooks[
+						/** @type {keyof Compiler["hooks"]} */
+						(name)
+					].taps.slice();
 			}
 		}
 
@@ -1251,7 +1250,7 @@ ${other}`);
 	}
 
 	isChild() {
-		return !!this.parentCompilation;
+		return Boolean(this.parentCompilation);
 	}
 
 	/**

package/lib/ConcatenationScope.js

@@ -64,7 +64,6 @@ class ConcatenationScope {
 	}
 
 	/**
-	 *
 	 * @param {string} exportName name of the export
 	 * @param {string} symbol identifier of the export in source code
 	 */
@@ -78,7 +77,6 @@ class ConcatenationScope {
 	}
 
 	/**
-	 *
 	 * @param {string} exportName name of the export
 	 * @param {string} expression expression to be used
 	 */
@@ -99,7 +97,6 @@ class ConcatenationScope {
 	}
 
 	/**
-	 *
 	 * @param {Module} module the referenced module
 	 * @param {Partial<ModuleReferenceOptions>} options options
 	 * @returns {string} the reference as identifier
@@ -138,7 +135,7 @@ class ConcatenationScope {
 	static matchModuleReference(name) {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);
 		if (!match) return null;
-		const index = +match[1];
+		const index = Number(match[1]);
 		const asiSafe = match[5];
 		return {
 			index,
@@ -146,8 +143,8 @@ class ConcatenationScope {
 				match[2] === "ns"
 					? []
 					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
-			call: !!match[3],
-			directImport: !!match[4],
+			call: Boolean(match[3]),
+			directImport: Boolean(match[4]),
 			asiSafe: asiSafe ? asiSafe === "1" : undefined
 		};
 	}

package/lib/ConditionalInitFragment.js

@@ -27,13 +27,12 @@ const wrapInCondition = (condition, source) => {
 			"}",
 			""
 		]);
-	} else {
-		return new ConcatSource(
-			`if (${condition}) {\n`,
-			new PrefixSource("\t", source),
-			"}\n"
-		);
 	}
+	return new ConcatSource(
+		`if (${condition}) {\n`,
+		new PrefixSource("\t", source),
+		"}\n"
+	);
 };
 
 /**
@@ -54,7 +53,7 @@ class ConditionalInitFragment extends InitFragment {
 		position,
 		key,
 		runtimeCondition = true,
-		endContent
+		endContent = undefined
 	) {
 		super(content, stage, position, key, endContent);
 		this.runtimeCondition = runtimeCondition;

package/lib/ConstPlugin.js

@@ -207,21 +207,13 @@ class ConstPlugin {
 								// NOTE: When code runs in strict mode, `var` declarations
 								// are hoisted but `function` declarations don't.
 								//
-								let declarations;
-								if (parser.scope.isStrict) {
-									// If the code runs in strict mode, variable declarations
-									// using `var` must be hoisted.
-									declarations = getHoistedDeclarations(branchToRemove, false);
-								} else {
-									// Otherwise, collect all hoisted declaration.
-									declarations = getHoistedDeclarations(branchToRemove, true);
-								}
-								let replacement;
-								if (declarations.length > 0) {
-									replacement = `{ var ${declarations.join(", ")}; }`;
-								} else {
-									replacement = "{}";
-								}
+								const declarations = parser.scope.isStrict
+									? getHoistedDeclarations(branchToRemove, false)
+									: getHoistedDeclarations(branchToRemove, true);
+								const replacement =
+									declarations.length > 0
+										? `{ var ${declarations.join(", ")}; }`
+										: "{}";
 								const dep = new ConstDependency(
 									replacement,
 									/** @type {Range} */ (branchToRemove.range)

package/lib/ContextExclusionPlugin.js

@@ -22,9 +22,9 @@ class ContextExclusionPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {
-				return files.filter(filePath => !this.negativeMatcher.test(filePath));
-			});
+			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files =>
+				files.filter(filePath => !this.negativeMatcher.test(filePath))
+			);
 		});
 	}
 }

package/lib/ContextModule.js

@@ -30,6 +30,7 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
@@ -86,7 +87,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @callback ResolveDependenciesCallback
- * @param {(Error | null)=} err
+ * @param {Error | null} err
  * @param {ContextElementDependency[]=} dependencies
  */
 
@@ -99,7 +100,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {1 | 3 | 7 | 9} FakeMapType */
 
-/** @typedef {Map<string, string | number> | FakeMapType} FakeMap */
+/** @typedef {Record<ModuleId, FakeMapType>} FakeMap */
 
 const SNAPSHOT_OPTIONS = { timestamp: true };
 
@@ -192,7 +193,7 @@ class ContextModule extends Module {
 	_prettyRegExp(regexString, stripSlash = true) {
 		const str = stripSlash
 			? regexString.source + regexString.flags
-			: regexString + "";
+			: `${regexString}`;
 		return str.replace(/!/g, "%21").replace(/\|/g, "%7C");
 	}
 
@@ -272,15 +273,15 @@ class ContextModule extends Module {
 	readableIdentifier(requestShortener) {
 		let identifier;
 		if (this.context) {
-			identifier = requestShortener.shorten(this.context) + "/";
+			identifier = `${requestShortener.shorten(this.context)}/`;
 		} else if (
 			typeof this.options.resource === "string" ||
 			this.options.resource === false
 		) {
-			identifier = requestShortener.shorten(`${this.options.resource}`) + "/";
+			identifier = `${requestShortener.shorten(`${this.options.resource}`)}/`;
 		} else {
 			identifier = this.options.resource
-				.map(r => requestShortener.shorten(r) + "/")
+				.map(r => `${requestShortener.shorten(r)}/`)
 				.join(" ");
 		}
 		if (this.options.resourceQuery) {
@@ -565,7 +566,7 @@ class ContextModule extends Module {
 		} else if (typeof this.options.resource === "string") {
 			contextDependencies.add(this.options.resource);
 		} else if (this.options.resource === false) {
-			return;
+			// Do nothing
 		} else {
 			for (const res of this.options.resource) contextDependencies.add(res);
 		}
@@ -602,7 +603,7 @@ class ContextModule extends Module {
 	/**
 	 * @param {Dependency[]} dependencies all dependencies
 	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {FakeMap} fake map
+	 * @returns {FakeMap | FakeMapType} fake map
 	 */
 	getFakeMap(dependencies, chunkGraph) {
 		if (!this.options.namespaceObject) {
@@ -621,13 +622,14 @@ class ContextModule extends Module {
 			)
 			.filter(Boolean)
 			.sort(comparator);
+		/** @type {FakeMap} */
 		const fakeMap = Object.create(null);
 		for (const module of sortedModules) {
 			const exportsType = module.getExportsType(
 				moduleGraph,
 				this.options.namespaceObject === "strict"
 			);
-			const id = chunkGraph.getModuleId(module);
+			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 			switch (exportsType) {
 				case "namespace":
 					fakeMap[id] = 9;
@@ -668,7 +670,7 @@ class ContextModule extends Module {
 	}
 
 	/**
-	 * @param {FakeMap} fakeMap fake map
+	 * @param {FakeMap | FakeMapType} fakeMap fake map
 	 * @returns {string} fake map init statement
 	 */
 	getFakeMapInitStatement(fakeMap) {
@@ -692,7 +694,7 @@ class ContextModule extends Module {
 	}
 
 	/**
-	 * @param {FakeMap} fakeMap fake map
+	 * @param {FakeMap | FakeMapType} fakeMap fake map
 	 * @param {boolean=} asyncModule us async module
 	 * @param {string=} fakeMapDataExpression fake map data expression
 	 * @returns {string} module object source
@@ -944,15 +946,19 @@ module.exports = webpackAsyncContext;`;
 			chunkGraph
 		);
 		const hasFakeMap = typeof fakeMap === "object";
+		/** @typedef {{userRequest: string, dependency: ContextElementDependency, chunks: undefined | Chunk[], module: Module, block: AsyncDependenciesBlock}} Item */
+		/**
+		 * @type {Item[]}
+		 */
 		const items = blocks
 			.map(block => {
 				const dependency =
 					/** @type {ContextElementDependency} */
 					(block.dependencies[0]);
 				return {
-					dependency: dependency,
+					dependency,
 					module: /** @type {Module} */ (moduleGraph.getModule(dependency)),
-					block: block,
+					block,
 					userRequest: dependency.userRequest,
 					chunks: undefined
 				};
@@ -974,18 +980,23 @@ module.exports = webpackAsyncContext;`;
 			if (a.userRequest === b.userRequest) return 0;
 			return a.userRequest < b.userRequest ? -1 : 1;
 		});
+		/** @type {Record<string, ModuleId | (ModuleId[] | ChunkId[])>} */
 		const map = Object.create(null);
 		for (const item of sortedItems) {
-			const moduleId = chunkGraph.getModuleId(item.module);
+			const moduleId =
+				/** @type {ModuleId} */
+				(chunkGraph.getModuleId(item.module));
 			if (shortMode) {
 				map[item.userRequest] = moduleId;
 			} else {
+				/** @type {(ModuleId | ChunkId)[]} */
 				const arrayStart = [moduleId];
 				if (hasFakeMap) {
 					arrayStart.push(fakeMap[moduleId]);
 				}
 				map[item.userRequest] = arrayStart.concat(
-					item.chunks.map(chunk => chunk.id)
+					/** @type {Chunk[]} */
+					(item.chunks).map(chunk => /** @type {ChunkId} */ (chunk.id))
 				);
 			}
 		}
@@ -1086,7 +1097,7 @@ module.exports = webpackEmptyAsyncContext;`;
 	 * @returns {string} the source code
 	 */
 	getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
-		const id = chunkGraph.getModuleId(this);
+		const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(this));
 		if (asyncMode === "lazy") {
 			if (this.blocks && this.blocks.length > 0) {
 				return this.getLazySource(this.blocks, id, {
@@ -1124,10 +1135,12 @@ module.exports = webpackEmptyAsyncContext;`;
 			}
 			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		if (asyncMode === "weak") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
-			}
+		if (
+			asyncMode === "weak" &&
+			this.dependencies &&
+			this.dependencies.length > 0
+		) {
+			return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
 		}
 		if (this.dependencies && this.dependencies.length > 0) {
 			return this.getSyncSource(this.dependencies, id, chunkGraph);