webpack 5.97.1 → 5.104.1

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -10,6 +10,8 @@ const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+const PLUGIN_NAME = "InferAsyncModulesPlugin";
+
 class InferAsyncModulesPlugin {
 	/**
 	 * Apply the plugin
@@ -17,37 +19,34 @@ class InferAsyncModulesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("InferAsyncModulesPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const { moduleGraph } = compilation;
-			compilation.hooks.finishModules.tap(
-				"InferAsyncModulesPlugin",
-				modules => {
-					/** @type {Set<Module>} */
-					const queue = new Set();
-					for (const module of modules) {
-						if (module.buildMeta && module.buildMeta.async) {
-							queue.add(module);
-						}
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
+				/** @type {Set<Module>} */
+				const queue = new Set();
+				for (const module of modules) {
+					if (module.buildMeta && module.buildMeta.async) {
+						queue.add(module);
 					}
-					for (const module of queue) {
-						moduleGraph.setAsync(module);
-						for (const [
-							originModule,
-							connections
-						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-							if (
-								connections.some(
-									c =>
-										c.dependency instanceof HarmonyImportDependency &&
-										c.isTargetActive(undefined)
-								)
-							) {
-								queue.add(/** @type {Module} */ (originModule));
-							}
+				}
+				for (const module of queue) {
+					moduleGraph.setAsync(module);
+					for (const [
+						originModule,
+						connections
+					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+						if (
+							connections.some(
+								(c) =>
+									c.dependency instanceof HarmonyImportDependency &&
+									c.isTargetActive(undefined)
+							)
+						) {
+							queue.add(/** @type {Module} */ (originModule));
 						}
 					}
 				}
-			);
+			});
 		});
 	}
 }

package/lib/buildChunkGraph.js

@@ -15,7 +15,6 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @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 */
@@ -256,6 +255,7 @@ const visitModules = (
 ) => {
 	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
+	/** @type {Map<RuntimeSpec, BlockModulesMap>} */
 	const blockModulesRuntimeMap = new Map();
 
 	/** @type {BlockModulesMap | undefined} */
@@ -268,7 +268,7 @@ const visitModules = (
 	 * @param {Module} module The module to look up
 	 * @returns {number} The ordinal of the module in masks
 	 */
-	const getModuleOrdinal = module => {
+	const getModuleOrdinal = (module) => {
 		let ordinal = ordinalByModule.get(module);
 		if (ordinal === undefined) {
 			ordinal = ordinalByModule.size;
@@ -288,11 +288,12 @@ const visitModules = (
 	/**
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
+	 * @returns {BlockModulesInFlattenTuples | undefined} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
 		blockModulesMap = blockModulesRuntimeMap.get(runtime);
 		if (blockModulesMap === undefined) {
+			/** @type {BlockModulesMap} */
 			blockModulesMap = new Map();
 			blockModulesRuntimeMap.set(runtime, blockModulesMap);
 		}
@@ -301,6 +302,7 @@ const visitModules = (
 		const module = /** @type {Module} */ (block.getRootBlock());
 		const memCache = moduleMemCaches && moduleMemCaches.get(module);
 		if (memCache !== undefined) {
+			/** @type {BlockModulesMap} */
 			const map = memCache.provide(
 				"bundleChunkGraph.blockModules",
 				runtime,
@@ -312,8 +314,9 @@ const visitModules = (
 					return map;
 				}
 			);
-			for (const [block, blockModules] of map)
+			for (const [block, blockModules] of map) {
 				blockModulesMap.set(block, blockModules);
+			}
 			return map.get(block);
 		}
 		logger.time("visitModules: prepare");
@@ -349,10 +352,12 @@ const visitModules = (
 	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
 	const blocksByChunkGroups = new Map();
 
-	/** @type {Map<string, ChunkGroupInfo>} */
+	/** @typedef {Map<string, ChunkGroupInfo>} NamedChunkGroup */
+
+	/** @type {NamedChunkGroup} */
 	const namedChunkGroups = new Map();
 
-	/** @type {Map<string, ChunkGroupInfo>} */
+	/** @type {NamedChunkGroup} */
 	const namedAsyncEntrypoints = new Map();
 
 	/** @type {Set<ChunkGroupInfo>} */
@@ -482,7 +487,7 @@ const visitModules = (
 	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
 	 * @returns {void}
 	 */
-	const iteratorBlock = b => {
+	const iteratorBlock = (b) => {
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
 		/** @type {ChunkGroupInfo | undefined} */
@@ -508,7 +513,9 @@ const visitModules = (
 					cgi = {
 						chunkGroup: entrypoint,
 						initialized: false,
-						runtime: entrypoint.options.runtime || entrypoint.name,
+						runtime:
+							entrypoint.options.runtime ||
+							/** @type {string | undefined} */ (entrypoint.name),
 						minAvailableModules: ZERO_BIGINT,
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
@@ -527,11 +534,19 @@ const visitModules = (
 								? entryOptions.asyncChunks
 								: chunkGroupInfo.asyncChunks
 					};
-					chunkGroupInfoMap.set(entrypoint, cgi);
+					chunkGroupInfoMap.set(
+						entrypoint,
+						/** @type {ChunkGroupInfo} */
+						(cgi)
+					);
 
 					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
 					if (chunkName) {
-						namedAsyncEntrypoints.set(chunkName, cgi);
+						namedAsyncEntrypoints.set(
+							chunkName,
+							/** @type {ChunkGroupInfo} */
+							(cgi)
+						);
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
@@ -551,7 +566,7 @@ const visitModules = (
 					module,
 					chunk: entrypoint.chunks[0],
 					chunkGroup: entrypoint,
-					chunkGroupInfo: cgi
+					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
 				});
 			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
 				// Just queue the block into the current chunk group
@@ -659,7 +674,7 @@ const visitModules = (
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
-	const processBlock = block => {
+	const processBlock = (block) => {
 		statProcessedBlocks++;
 		// get prepared block info
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
@@ -751,7 +766,7 @@ const visitModules = (
 	 * @param {DependenciesBlock} block the block
 	 * @returns {void}
 	 */
-	const processEntryBlock = block => {
+	const processEntryBlock = (block) => {
 		statProcessedBlocks++;
 		// get prepared block info
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
@@ -878,9 +893,10 @@ const visitModules = (
 	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
 	 * @returns {bigint} The mask of available modules after the chunk group
 	 */
-	const calculateResultingAvailableModules = chunkGroupInfo => {
-		if (chunkGroupInfo.resultingAvailableModules !== undefined)
+	const calculateResultingAvailableModules = (chunkGroupInfo) => {
+		if (chunkGroupInfo.resultingAvailableModules !== undefined) {
 			return chunkGroupInfo.resultingAvailableModules;
+		}
 
 		let resultingAvailableModules = /** @type {bigint} */ (
 			chunkGroupInfo.minAvailableModules
@@ -1152,7 +1168,9 @@ const visitModules = (
 			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
 			 */
 			const process = (current, visited) => {
-				const blockModules = getBlockModules(current, runtime);
+				const blockModules =
+					/** @type {BlockModulesInFlattenTuples} */
+					(getBlockModules(current, runtime));
 				for (let i = 0, len = blockModules.length; i < len; i += 3) {
 					const activeState = /** @type {ConnectionState} */ (
 						blockModules[i + 1]
@@ -1330,8 +1348,9 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 	logger.timeEnd("connectChunkGroups");
 
 	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
-		for (const chunk of chunkGroup.chunks)
+		for (const chunk of chunkGroup.chunks) {
 			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
+		}
 	}
 
 	// Cleanup work

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -7,6 +7,8 @@
 
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "AddBuildDependenciesPlugin";
+
 class AddBuildDependenciesPlugin {
 	/**
 	 * @param {Iterable<string>} buildDependencies list of build dependencies
@@ -21,12 +23,9 @@ class AddBuildDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AddBuildDependenciesPlugin",
-			compilation => {
-				compilation.buildDependencies.addAll(this.buildDependencies);
-			}
-		);
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.buildDependencies.addAll(this.buildDependencies);
+		});
 	}
 }
 

package/lib/cache/IdleFileCachePlugin.js

@@ -12,6 +12,7 @@ const ProgressPlugin = require("../ProgressPlugin");
 /** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
 const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
+const PLUGIN_NAME = "IdleFileCachePlugin";
 
 class IdleFileCachePlugin {
 	/**
@@ -51,11 +52,11 @@ class IdleFileCachePlugin {
 		let timeSpendInStore = 0;
 		let avgTimeSpendInStore = 0;
 
-		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise<void>>} */
+		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise<void | void[]>>} */
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, data) => {
 				pendingIdleTasks.set(identifier, () =>
 					strategy.store(identifier, etag, data)
@@ -64,10 +65,10 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			(identifier, etag, gotHandlers) => {
 				const restore = () =>
-					strategy.restore(identifier, etag).then(cacheEntry => {
+					strategy.restore(identifier, etag).then((cacheEntry) => {
 						if (cacheEntry === undefined) {
 							gotHandlers.push((result, callback) => {
 								if (result !== undefined) {
@@ -91,8 +92,8 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			dependencies => {
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
+			(dependencies) => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
 						strategy.storeBuildDependencies(dependencies)
@@ -102,7 +103,7 @@ class IdleFileCachePlugin {
 		);
 
 		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -110,9 +111,9 @@ class IdleFileCachePlugin {
 				}
 				isIdle = false;
 				const reportProgress = ProgressPlugin.getReporter(compiler);
-				const jobs = Array.from(pendingIdleTasks.values());
+				const jobs = [...pendingIdleTasks.values()];
 				if (reportProgress) reportProgress(0, "process pending cache items");
-				const promises = jobs.map(fn => fn());
+				const promises = jobs.map((fn) => fn());
 				pendingIdleTasks.clear();
 				promises.push(currentIdlePromise);
 				const promise = Promise.all(promises);
@@ -129,7 +130,7 @@ class IdleFileCachePlugin {
 			}
 		);
 
-		/** @type {Promise<any>} */
+		/** @type {Promise<void | void[]>} */
 		let currentIdlePromise = resolvedPromise;
 		let isIdle = false;
 		let isInitialStore = true;
@@ -145,7 +146,10 @@ class IdleFileCachePlugin {
 						promises.push(factory());
 						if (maxCount-- <= 0 || Date.now() > maxTime) break;
 					}
-					currentIdlePromise = Promise.all(promises);
+					currentIdlePromise = Promise.all(
+						/** @type {Promise<void>[]} */
+						(promises)
+					);
 					currentIdlePromise.then(() => {
 						timeSpendInStore += Date.now() - startTime;
 						// Allow to exit the process between
@@ -164,10 +168,8 @@ class IdleFileCachePlugin {
 						timeSpendInStore = 0;
 						timeSpendInBuild = 0;
 					})
-					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
+					.catch((err) => {
+						const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
 						logger.warn(`Background tasks during idle failed: ${err.message}`);
 						logger.debug(err.stack);
 					});
@@ -177,12 +179,12 @@ class IdleFileCachePlugin {
 		/** @type {ReturnType<typeof setTimeout> | undefined} */
 		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
 				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Initial cache was generated and cache will be persisted in ${
 								idleTimeoutForInitialStore / 1000
@@ -193,7 +195,7 @@ class IdleFileCachePlugin {
 					idleTimeoutAfterLargeChanges < idleTimeout
 				) {
 					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
+						.getInfrastructureLogger(PLUGIN_NAME)
 						.log(
 							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
 								Math.round(avgTimeSpendInStore) / 1000
@@ -218,7 +220,7 @@ class IdleFileCachePlugin {
 			}
 		);
 		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
 			() => {
 				if (idleTimer) {
 					clearTimeout(idleTimer);
@@ -227,7 +229,7 @@ class IdleFileCachePlugin {
 				isIdle = false;
 			}
 		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+		compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
 			timeSpendInBuild +=

package/lib/cache/MemoryCachePlugin.js

@@ -7,10 +7,9 @@
 
 const Cache = require("../Cache");
 
-/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 
 class MemoryCachePlugin {
 	/**
@@ -19,7 +18,7 @@ class MemoryCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any } | null>} */
+		/** @type {Map<string, { etag: Etag | null, data: Data } | null>} */
 		const cache = new Map();
 		compiler.cache.hooks.store.tap(
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
@@ -54,4 +53,5 @@ class MemoryCachePlugin {
 		);
 	}
 }
+
 module.exports = MemoryCachePlugin;

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -7,15 +7,20 @@
 
 const Cache = require("../Cache");
 
-/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+
+/**
+ * @typedef {object} MemoryWithGcCachePluginOptions
+ * @property {number} maxGenerations max generations
+ */
+
+const PLUGIN_NAME = "MemoryWithGcCachePlugin";
 
 class MemoryWithGcCachePlugin {
 	/**
-	 * @param {object} options Options
-	 * @param {number} options.maxGenerations max generations
+	 * @param {MemoryWithGcCachePluginOptions} options options
 	 */
 	constructor({ maxGenerations }) {
 		this._maxGenerations = maxGenerations;
@@ -28,14 +33,14 @@ class MemoryWithGcCachePlugin {
 	 */
 	apply(compiler) {
 		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any } | undefined | null>} */
+		/** @type {Map<string, { etag: Etag | null, data: Data } | undefined | null>} */
 		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any } | null, until: number }>} */
+		/** @type {Map<string, { entry: { etag: Etag | null, data: Data } | null, until: number }>} */
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+		const logger = compiler.getInfrastructureLogger(PLUGIN_NAME);
+		compiler.hooks.afterDone.tap(PLUGIN_NAME, () => {
 			generation++;
 			let clearedEntries = 0;
 			let lastClearedIdentifier;
@@ -86,13 +91,13 @@ class MemoryWithGcCachePlugin {
 			}
 		});
 		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, data) => {
 				cache.set(identifier, { etag, data });
 			}
 		);
 		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			(identifier, etag, gotHandlers) => {
 				const cacheEntry = cache.get(identifier);
 				if (cacheEntry === null) {
@@ -124,7 +129,7 @@ class MemoryWithGcCachePlugin {
 			}
 		);
 		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			{ name: PLUGIN_NAME, stage: Cache.STAGE_MEMORY },
 			() => {
 				cache.clear();
 				oldCache.clear();
@@ -132,4 +137,5 @@ class MemoryWithGcCachePlugin {
 		);
 	}
 }
+
 module.exports = MemoryWithGcCachePlugin;