webpack 5.99.6 → 5.99.8

package/lib/NormalModule.js

@@ -57,6 +57,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
@@ -92,7 +93,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /**
  * @template T
@@ -649,13 +650,13 @@ class NormalModule extends Module {
 					? getContextifyInContext()(request)
 					: getContextify()(context, request),
 			/**
-			 * @param {(string | typeof import("./util/Hash"))=} type type
+			 * @param {HashFunction=} type type
 			 * @returns {Hash} hash
 			 */
 			createHash: type =>
 				createHash(
 					type ||
-						/** @type {Algorithm} */
+						/** @type {HashFunction} */
 						(compilation.outputOptions.hashFunction)
 				)
 		};
@@ -803,7 +804,7 @@ class NormalModule extends Module {
 			webpack: true,
 			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
-			hashFunction: /** @type {TODO} */ (options.output.hashFunction),
+			hashFunction: /** @type {string} */ (options.output.hashFunction),
 			hashDigest: /** @type {string} */ (options.output.hashDigest),
 			hashDigestLength: /** @type {number} */ (options.output.hashDigestLength),
 			hashSalt: /** @type {string} */ (options.output.hashSalt),
@@ -1079,7 +1080,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {TODO} rule rule
+	 * @param {Exclude<NoParse, EXPECTED_ANY[]>} rule rule
 	 * @param {string} content content
 	 * @returns {boolean} result
 	 */
@@ -1097,7 +1098,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {TODO} noParseRule no parse rule
+	 * @param {undefined | NoParse} noParseRule no parse rule
 	 * @param {string} request request
 	 * @returns {boolean} check if module should not be parsed, returns "true" if the module should !not! be parsed, returns "false" if the module !must! be parsed
 	 */
@@ -1132,7 +1133,7 @@ class NormalModule extends Module {
 	 */
 	_initBuildHash(compilation) {
 		const hash = createHash(
-			/** @type {Algorithm} */
+			/** @type {HashFunction} */
 			(compilation.outputOptions.hashFunction)
 		);
 		if (this._source) {
@@ -1632,7 +1633,11 @@ class NormalModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(/** @type {BuildInfo} */ (this.buildInfo).hash);
+		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		hash.update(
+			/** @type {string} */
+			(buildInfo.hash)
+		);
 		/** @type {Generator} */
 		(this.generator).updateHash(hash, {
 			module: this,

package/lib/NormalModuleReplacementPlugin.js

@@ -13,6 +13,8 @@ const { join, dirname } = require("./util/fs");
 
 /** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */
 
+const PLUGIN_NAME = "NormalModuleReplacementPlugin";
+
 class NormalModuleReplacementPlugin {
 	/**
 	 * Create an instance of the plugin
@@ -32,46 +34,41 @@ class NormalModuleReplacementPlugin {
 	apply(compiler) {
 		const resourceRegExp = this.resourceRegExp;
 		const newResource = this.newResource;
-		compiler.hooks.normalModuleFactory.tap(
-			"NormalModuleReplacementPlugin",
-			nmf => {
-				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
-					if (resourceRegExp.test(result.request)) {
-						if (typeof newResource === "function") {
-							newResource(result);
-						} else {
-							result.request = newResource;
-						}
+		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, nmf => {
+			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, result => {
+				if (resourceRegExp.test(result.request)) {
+					if (typeof newResource === "function") {
+						newResource(result);
+					} else {
+						result.request = newResource;
 					}
-				});
-				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
-					const createData = result.createData;
-					if (
-						resourceRegExp.test(/** @type {string} */ (createData.resource))
-					) {
-						if (typeof newResource === "function") {
-							newResource(result);
+				}
+			});
+			nmf.hooks.afterResolve.tap(PLUGIN_NAME, result => {
+				const createData = result.createData;
+				if (resourceRegExp.test(/** @type {string} */ (createData.resource))) {
+					if (typeof newResource === "function") {
+						newResource(result);
+					} else {
+						const fs =
+							/** @type {InputFileSystem} */
+							(compiler.inputFileSystem);
+						if (
+							newResource.startsWith("/") ||
+							(newResource.length > 1 && newResource[1] === ":")
+						) {
+							createData.resource = newResource;
 						} else {
-							const fs =
-								/** @type {InputFileSystem} */
-								(compiler.inputFileSystem);
-							if (
-								newResource.startsWith("/") ||
-								(newResource.length > 1 && newResource[1] === ":")
-							) {
-								createData.resource = newResource;
-							} else {
-								createData.resource = join(
-									fs,
-									dirname(fs, /** @type {string} */ (createData.resource)),
-									newResource
-								);
-							}
+							createData.resource = join(
+								fs,
+								dirname(fs, /** @type {string} */ (createData.resource)),
+								newResource
+							);
 						}
 					}
-				});
-			}
-		);
+				}
+			});
+		});
 	}
 }
 

package/lib/PlatformPlugin.js

@@ -8,6 +8,8 @@
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
 
+const PLUGIN_NAME = "PlatformPlugin";
+
 /**
  * Should be used only for "target === false" or
  * when you want to overwrite platform target properties
@@ -27,7 +29,7 @@ class PlatformPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.environment.tap("PlatformPlugin", () => {
+		compiler.hooks.environment.tap(PLUGIN_NAME, () => {
 			compiler.platform = {
 				...compiler.platform,
 				...this.platform

package/lib/PrefetchPlugin.js

@@ -9,6 +9,8 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "PrefetchPlugin";
+
 class PrefetchPlugin {
 	/**
 	 * @param {string} context context or request if context is not set
@@ -31,7 +33,7 @@ class PrefetchPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"PrefetchPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					PrefetchDependency,
@@ -39,7 +41,7 @@ class PrefetchPlugin {
 				);
 			}
 		);
-		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
 			compilation.addModuleChain(
 				this.context || compiler.context,
 				new PrefetchDependency(this.request),

package/lib/ProgressPlugin.js

@@ -140,6 +140,8 @@ const SKIPPED_QUEUE_CONTEXTS = ["import-module", "load-module"];
 /** @type {WeakMap<Compiler, ReportProgress | undefined>} */
 const progressReporters = new WeakMap();
 
+const PLUGIN_NAME = "ProgressPlugin";
+
 class ProgressPlugin {
 	/**
 	 * @param {Compiler} compiler the current compiler
@@ -395,14 +397,12 @@ class ProgressPlugin {
 			update();
 		};
 
-		const cache = compiler
-			.getCache("ProgressPlugin")
-			.getItemCache("counts", null);
+		const cache = compiler.getCache(PLUGIN_NAME).getItemCache("counts", null);
 
 		/** @type {Promise<CountsData> | undefined} */
 		let cacheGetPromise;
 
-		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
+		compiler.hooks.beforeCompile.tap(PLUGIN_NAME, () => {
 			if (!cacheGetPromise) {
 				cacheGetPromise = cache.getPromise().then(
 					data => {
@@ -420,7 +420,7 @@ class ProgressPlugin {
 			}
 		});
 
-		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
+		compiler.hooks.afterCompile.tapPromise(PLUGIN_NAME, compilation => {
 			if (compilation.compiler.isChild()) return Promise.resolve();
 			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
 				async oldData => {
@@ -442,7 +442,7 @@ class ProgressPlugin {
 			);
 		});
 
-		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			if (compilation.compiler.isChild()) return;
 			lastModulesCount = modulesCount;
 			lastEntriesCount = entriesCount;
@@ -455,35 +455,32 @@ class ProgressPlugin {
 					0;
 			doneModules = doneDependencies = doneEntries = 0;
 
-			compilation.factorizeQueue.hooks.added.tap("ProgressPlugin", item =>
+			compilation.factorizeQueue.hooks.added.tap(PLUGIN_NAME, item =>
 				factorizeAdd(compilation.factorizeQueue, item)
 			);
-			compilation.factorizeQueue.hooks.result.tap(
-				"ProgressPlugin",
-				factorizeDone
-			);
+			compilation.factorizeQueue.hooks.result.tap(PLUGIN_NAME, factorizeDone);
 
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", item =>
+			compilation.addModuleQueue.hooks.added.tap(PLUGIN_NAME, item =>
 				moduleAdd(compilation.addModuleQueue, item)
 			);
 			compilation.processDependenciesQueue.hooks.result.tap(
-				"ProgressPlugin",
+				PLUGIN_NAME,
 				moduleDone
 			);
 
 			if (showActiveModules) {
-				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+				compilation.hooks.buildModule.tap(PLUGIN_NAME, moduleBuild);
 			}
 
-			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
-			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
-			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+			compilation.hooks.addEntry.tap(PLUGIN_NAME, entryAdd);
+			compilation.hooks.failedEntry.tap(PLUGIN_NAME, entryDone);
+			compilation.hooks.succeedEntry.tap(PLUGIN_NAME, entryDone);
 
 			// @ts-expect-error avoid dynamic require if bundled with webpack
 			if (typeof __webpack_require__ !== "function") {
 				const requiredLoaders = new Set();
 				NormalModule.getCompilationHooks(compilation).beforeLoaders.tap(
-					"ProgressPlugin",
+					PLUGIN_NAME,
 					loaders => {
 						for (const loader of loaders) {
 							if (
@@ -550,7 +547,7 @@ class ProgressPlugin {
 				const title = hooks[/** @type {keyof typeof hooks} */ (name)];
 				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
 				compilation.hooks[/** @type {keyof typeof hooks} */ (name)].intercept({
-					name: "ProgressPlugin",
+					name: PLUGIN_NAME,
 					call() {
 						handler(percentage, "sealing", title);
 					},
@@ -576,7 +573,7 @@ class ProgressPlugin {
 			}
 		});
 		compiler.hooks.make.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0.1, "building");
 			},
@@ -592,7 +589,7 @@ class ProgressPlugin {
 		 */
 		const interceptHook = (hook, progress, category, name) => {
 			hook.intercept({
-				name: "ProgressPlugin",
+				name: PLUGIN_NAME,
 				call() {
 					handler(progress, category, name);
 				},
@@ -618,14 +615,14 @@ class ProgressPlugin {
 			});
 		};
 		compiler.cache.hooks.endIdle.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0, "");
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
 		compiler.hooks.beforeRun.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			call() {
 				handler(0, "");
 			}
@@ -659,7 +656,7 @@ class ProgressPlugin {
 		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
 		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
 		compiler.hooks.done.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(0.99, "");
 			}
@@ -679,13 +676,13 @@ class ProgressPlugin {
 			"closing watch compilation"
 		);
 		compiler.cache.hooks.beginIdle.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(1, "");
 			}
 		});
 		compiler.cache.hooks.shutdown.intercept({
-			name: "ProgressPlugin",
+			name: PLUGIN_NAME,
 			done() {
 				handler(1, "");
 			}

package/lib/RecordIdsPlugin.js

@@ -37,6 +37,8 @@ const identifierUtils = require("./util/identifier");
  * @property {boolean=} portableIds true, when ids need to be portable
  */
 
+const PLUGIN_NAME = "RecordIdsPlugin";
+
 class RecordIdsPlugin {
 	/**
 	 * @param {RecordIdsPluginOptions=} options object
@@ -69,59 +71,43 @@ class RecordIdsPlugin {
 			return module.identifier();
 		};
 
-		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
-			compilation.hooks.recordModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Iterable<Module>} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.recordModules.tap(PLUGIN_NAME, (modules, records) => {
+				const chunkGraph = compilation.chunkGraph;
+				if (!records.modules) records.modules = {};
+				if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
+				/** @type {Set<number>} */
+				const usedIds = new Set();
+				for (const module of modules) {
+					const moduleId = chunkGraph.getModuleId(module);
+					if (typeof moduleId !== "number") continue;
+					const identifier = getModuleIdentifier(module);
+					records.modules.byIdentifier[identifier] = moduleId;
+					usedIds.add(moduleId);
+				}
+				records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
+			});
+			compilation.hooks.reviveModules.tap(PLUGIN_NAME, (modules, records) => {
+				if (!records.modules) return;
+				if (records.modules.byIdentifier) {
 					const chunkGraph = compilation.chunkGraph;
-					if (!records.modules) records.modules = {};
-					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
 					/** @type {Set<number>} */
 					const usedIds = new Set();
 					for (const module of modules) {
 						const moduleId = chunkGraph.getModuleId(module);
-						if (typeof moduleId !== "number") continue;
+						if (moduleId !== null) continue;
 						const identifier = getModuleIdentifier(module);
-						records.modules.byIdentifier[identifier] = moduleId;
-						usedIds.add(moduleId);
+						const id = records.modules.byIdentifier[identifier];
+						if (id === undefined) continue;
+						if (usedIds.has(id)) continue;
+						usedIds.add(id);
+						chunkGraph.setModuleId(module, id);
 					}
-					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
 				}
-			);
-			compilation.hooks.reviveModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Iterable<Module>} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
-					if (!records.modules) return;
-					if (records.modules.byIdentifier) {
-						const chunkGraph = compilation.chunkGraph;
-						/** @type {Set<number>} */
-						const usedIds = new Set();
-						for (const module of modules) {
-							const moduleId = chunkGraph.getModuleId(module);
-							if (moduleId !== null) continue;
-							const identifier = getModuleIdentifier(module);
-							const id = records.modules.byIdentifier[identifier];
-							if (id === undefined) continue;
-							if (usedIds.has(id)) continue;
-							usedIds.add(id);
-							chunkGraph.setModuleId(module, id);
-						}
-					}
-					if (Array.isArray(records.modules.usedIds)) {
-						compilation.usedModuleIds = new Set(records.modules.usedIds);
-					}
+				if (Array.isArray(records.modules.usedIds)) {
+					compilation.usedModuleIds = new Set(records.modules.usedIds);
 				}
-			);
+			});
 
 			/**
 			 * @param {Chunk} chunk the chunk
@@ -167,75 +153,59 @@ class RecordIdsPlugin {
 				return sources;
 			};
 
-			compilation.hooks.recordChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Iterable<Chunk>} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) records.chunks = {};
-					if (!records.chunks.byName) records.chunks.byName = {};
-					if (!records.chunks.bySource) records.chunks.bySource = {};
-					/** @type {Set<number>} */
-					const usedIds = new Set();
+			compilation.hooks.recordChunks.tap(PLUGIN_NAME, (chunks, records) => {
+				if (!records.chunks) records.chunks = {};
+				if (!records.chunks.byName) records.chunks.byName = {};
+				if (!records.chunks.bySource) records.chunks.bySource = {};
+				/** @type {Set<number>} */
+				const usedIds = new Set();
+				for (const chunk of chunks) {
+					if (typeof chunk.id !== "number") continue;
+					const name = chunk.name;
+					if (name) records.chunks.byName[name] = chunk.id;
+					const sources = getChunkSources(chunk);
+					for (const source of sources) {
+						records.chunks.bySource[source] = chunk.id;
+					}
+					usedIds.add(chunk.id);
+				}
+				records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
+			});
+			compilation.hooks.reviveChunks.tap(PLUGIN_NAME, (chunks, records) => {
+				if (!records.chunks) return;
+				/** @type {Set<number>} */
+				const usedIds = new Set();
+				if (records.chunks.byName) {
 					for (const chunk of chunks) {
-						if (typeof chunk.id !== "number") continue;
-						const name = chunk.name;
-						if (name) records.chunks.byName[name] = chunk.id;
-						const sources = getChunkSources(chunk);
-						for (const source of sources) {
-							records.chunks.bySource[source] = chunk.id;
-						}
-						usedIds.add(chunk.id);
+						if (chunk.id !== null) continue;
+						if (!chunk.name) continue;
+						const id = records.chunks.byName[chunk.name];
+						if (id === undefined) continue;
+						if (usedIds.has(id)) continue;
+						usedIds.add(id);
+						chunk.id = id;
+						chunk.ids = [id];
 					}
-					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
 				}
-			);
-			compilation.hooks.reviveChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Iterable<Chunk>} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) return;
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					if (records.chunks.byName) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							if (!chunk.name) continue;
-							const id = records.chunks.byName[chunk.name];
+				if (records.chunks.bySource) {
+					for (const chunk of chunks) {
+						if (chunk.id !== null) continue;
+						const sources = getChunkSources(chunk);
+						for (const source of sources) {
+							const id = records.chunks.bySource[source];
 							if (id === undefined) continue;
 							if (usedIds.has(id)) continue;
 							usedIds.add(id);
 							chunk.id = id;
 							chunk.ids = [id];
+							break;
 						}
 					}
-					if (records.chunks.bySource) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							const sources = getChunkSources(chunk);
-							for (const source of sources) {
-								const id = records.chunks.bySource[source];
-								if (id === undefined) continue;
-								if (usedIds.has(id)) continue;
-								usedIds.add(id);
-								chunk.id = id;
-								chunk.ids = [id];
-								break;
-							}
-						}
-					}
-					if (Array.isArray(records.chunks.usedIds)) {
-						compilation.usedChunkIds = new Set(records.chunks.usedIds);
-					}
 				}
-			);
+				if (Array.isArray(records.chunks.usedIds)) {
+					compilation.usedChunkIds = new Set(records.chunks.usedIds);
+				}
+			});
 		});
 	}
 }