webpack 5.98.0 → 5.99.1

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -12,10 +12,14 @@ const Cache = require("../Cache");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {object} MemoryWithGcCachePluginOptions
+ * @property {number} maxGenerations max generations
+ */
+
 class MemoryWithGcCachePlugin {
 	/**
-	 * @param {object} options Options
-	 * @param {number} options.maxGenerations max generations
+	 * @param {MemoryWithGcCachePluginOptions} options options
 	 */
 	constructor({ maxGenerations }) {
 		this._maxGenerations = maxGenerations;

package/lib/cache/PackFileCacheStrategy.js

@@ -21,20 +21,21 @@ const {
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
+/** @typedef {import("../FileSystemInfo").ResolveResults} ResolveResults */
 /** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-/** @typedef {Map<string, string | false>} ResolveResults */
 /** @typedef {Set<string>} Items */
 /** @typedef {Set<string>} BuildDependencies */
 /** @typedef {Map<string, PackItemInfo>} ItemInfo */
 
 class PackContainer {
 	/**
-	 * @param {object} data stored data
+	 * @param {Pack} data stored data
 	 * @param {string} version version identifier
 	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
 	 * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured
@@ -95,11 +96,14 @@ const MIN_ITEMS_IN_FRESH_PACK = 100;
 const MAX_ITEMS_IN_FRESH_PACK = 50000;
 const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 
+/** @typedef {TODO | undefined} Value */
+/** @typedef {TODO | undefined} LazyValue */
+
 class PackItemInfo {
 	/**
 	 * @param {string} identifier identifier of item
 	 * @param {string | null | undefined} etag etag of item
-	 * @param {any} value fresh value of item
+	 * @param {Value} value fresh value of item
 	 */
 	constructor(identifier, etag, value) {
 		this.identifier = identifier;
@@ -154,7 +158,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @returns {any} cached content
+	 * @returns {Value} cached content
 	 */
 	get(identifier, etag) {
 		const info = this.itemInfo.get(identifier);
@@ -177,7 +181,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @param {any} data cached content
+	 * @param {Value} data cached content
 	 * @returns {void}
 	 */
 	set(identifier, etag, data) {
@@ -268,7 +272,7 @@ class Pack {
 	}
 
 	_persistFreshContent() {
-		/** @typedef {{ items: Items, map: Map<string, any>, loc: number }} PackItem */
+		/** @typedef {{ items: Items, map: Content, loc: number }} PackItem */
 		const itemsCount = this.freshContent.size;
 		if (itemsCount > 0) {
 			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
@@ -393,7 +397,7 @@ class Pack {
 		const mergedItems = new Set();
 		/** @type {Items} */
 		const mergedUsedItems = new Set();
-		/** @type {(function(Map<string, any>): Promise<void>)[]} */
+		/** @type {((map: Content) => Promise<void>)[]} */
 		const addToMergedMap = [];
 		for (const content of mergedContent) {
 			for (const identifier of content.items) {
@@ -472,6 +476,7 @@ class Pack {
 							await content.unpack(
 								"it should be splitted into used and unused items"
 							);
+							/** @type {Content} */
 							const map = new Map();
 							for (const identifier of usedItems) {
 								map.set(
@@ -597,7 +602,10 @@ class Pack {
 			const content = this.content[i];
 			if (content !== undefined) {
 				write(content.items);
-				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
+				content.writeLazy(lazy =>
+					/** @type {NonNullable<ObjectSerializerContext["writeSeparate"]>} */
+					(writeSeparate)(lazy, { name: `${i}` })
+				);
 			} else {
 				write(undefined); // undefined marks an empty content slot
 			}
@@ -659,7 +667,7 @@ class Pack {
 
 makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
-/** @typedef {Map<string, any>} Content */
+/** @typedef {Map<string, Value>} Content */
 
 class PackContentItems {
 	/**
@@ -670,7 +678,7 @@ class PackContentItems {
 	}
 
 	/**
-	 * @param {ObjectSerializerContext & { snapshot: TODO, rollback: TODO, logger: Logger, profile: boolean | undefined  }} context context
+	 * @param {ObjectSerializerContext & { logger: Logger, profile: boolean | undefined  }} context context
 	 */
 	serialize({ write, snapshot, rollback, logger, profile }) {
 		if (profile) {
@@ -791,7 +799,7 @@ makeSerializable(
 	"PackContentItems"
 );
 
-/** @typedef {(function(): Promise<PackContentItems> | PackContentItems)} LazyFn */
+/** @typedef {(() => Promise<PackContentItems> | PackContentItems)} LazyFunction */
 
 class PackContent {
 	/*
@@ -816,13 +824,13 @@ class PackContent {
 	/**
 	 * @param {Items} items keys
 	 * @param {Items} usedItems used keys
-	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
+	 * @param {PackContentItems | (() => Promise<PackContentItems>)} dataOrFn sync or async content
 	 * @param {Logger=} logger logger for logging
 	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
 		this.items = items;
-		/** @type {LazyFn | undefined} */
+		/** @type {LazyValue} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
 		/** @type {Content | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
@@ -860,7 +868,7 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = /** @type {LazyFn} */ (this.lazy)();
+		const value = /** @type {LazyFunction} */ (this.lazy)();
 		if ("then" in value) {
 			return value.then(data => {
 				const map = data.map;
@@ -870,7 +878,7 @@ class PackContent {
 				// Move to state C
 				this.content = map;
 				this.lazy = SerializerMiddleware.unMemoizeLazy(
-					/** @type {LazyFn} */
+					/** @type {LazyFunction} */
 					(this.lazy)
 				);
 				return map.get(identifier);
@@ -884,7 +892,7 @@ class PackContent {
 		// Move to state C
 		this.content = map;
 		this.lazy = SerializerMiddleware.unMemoizeLazy(
-			/** @type {LazyFn} */
+			/** @type {LazyFunction} */
 			(this.lazy)
 		);
 		return map.get(identifier);
@@ -916,7 +924,9 @@ class PackContent {
 				);
 				logger.time(timeMessage);
 			}
-			const value = this.lazy();
+			const value =
+				/** @type {PackContentItems | Promise<PackContentItems>} */
+				(this.lazy());
 			if ("then" in value) {
 				return value.then(data => {
 					if (timeMessage) {
@@ -937,7 +947,9 @@ class PackContent {
 	 */
 	getSize() {
 		if (!this.lazy) return -1;
-		const options = /** @type {any} */ (this.lazy).options;
+		const options =
+			/** @type {{ options: { size?: number } }} */
+			(this.lazy).options;
 		if (!options) return -1;
 		const size = options.size;
 		if (typeof size !== "number") return -1;
@@ -955,7 +967,7 @@ class PackContent {
 
 	/**
 	 * @template T
-	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
+	 * @param {(item?: LazyValue) => (() => Promise<PackContentItems> | PackContentItems)} write write function
 	 * @returns {void}
 	 */
 	writeLazy(write) {
@@ -1007,7 +1019,7 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = /** @type {LazyFn} */ (this.lazy)();
+		const value = /** @type {LazyFunction} */ (this.lazy)();
 		this.outdated = false;
 		if ("then" in value) {
 			// Move to state B1
@@ -1024,10 +1036,7 @@ class PackContent {
 					}
 					// Move to state C1 (or maybe C2)
 					this.content = map;
-					this.lazy = SerializerMiddleware.unMemoizeLazy(
-						/** @type {LazyFn} */
-						(this.lazy)
-					);
+					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 
 					return new PackContentItems(map);
 				})
@@ -1093,7 +1102,8 @@ class PackFileCacheStrategy {
 	}) {
 		this.fileSerializer = createFileSerializer(
 			fs,
-			compiler.options.output.hashFunction
+			/** @type {string | Hash} */
+			(compiler.options.output.hashFunction)
 		);
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
@@ -1276,7 +1286,7 @@ class PackFileCacheStrategy {
 						logger.timeEnd("check build dependencies");
 						if (buildSnapshotValid && resolveValid) {
 							logger.time("restore cache content metadata");
-							const d = packContainer.data();
+							const d = /** @type {TODO} */ (packContainer).data();
 							logger.timeEnd("restore cache content metadata");
 							return d;
 						}
@@ -1309,7 +1319,7 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @param {any} data cached content
+	 * @param {Value} data cached content
 	 * @returns {Promise<void>} promise
 	 */
 	store(identifier, etag, data) {
@@ -1323,7 +1333,7 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @returns {Promise<any>} promise to the cached content
+	 * @returns {Promise<Value>} promise to the cached content
 	 */
 	restore(identifier, etag) {
 		return this._getPack()
@@ -1372,104 +1382,110 @@ class PackFileCacheStrategy {
 							newBuildDependencies
 						).join(", ")})`
 					);
-					promise = new Promise((resolve, reject) => {
-						this.logger.time("resolve build dependencies");
-						this.fileSystemInfo.resolveBuildDependencies(
-							this.context,
-							newBuildDependencies,
-							(err, result) => {
-								this.logger.timeEnd("resolve build dependencies");
-								if (err) return reject(err);
-
-								this.logger.time("snapshot build dependencies");
-								const {
-									files,
-									directories,
-									missing,
-									resolveResults,
-									resolveDependencies
-								} = /** @type {ResolveBuildDependenciesResult} */ (result);
-								if (this.resolveResults) {
-									for (const [key, value] of resolveResults) {
-										this.resolveResults.set(key, value);
-									}
-								} else {
-									this.resolveResults = resolveResults;
-								}
-								if (reportProgress) {
-									reportProgress(
-										0.6,
-										"snapshot build dependencies",
-										"resolving"
-									);
-								}
-								this.fileSystemInfo.createSnapshot(
-									undefined,
-									resolveDependencies.files,
-									resolveDependencies.directories,
-									resolveDependencies.missing,
-									this.snapshot.resolveBuildDependencies,
-									(err, snapshot) => {
-										if (err) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(err);
+					promise = new Promise(
+						/**
+						 * @param {(value?: undefined) => void} resolve resolve
+						 * @param {(reason?: Error) => void} reject reject
+						 */
+						(resolve, reject) => {
+							this.logger.time("resolve build dependencies");
+							this.fileSystemInfo.resolveBuildDependencies(
+								this.context,
+								newBuildDependencies,
+								(err, result) => {
+									this.logger.timeEnd("resolve build dependencies");
+									if (err) return reject(err);
+
+									this.logger.time("snapshot build dependencies");
+									const {
+										files,
+										directories,
+										missing,
+										resolveResults,
+										resolveDependencies
+									} = /** @type {ResolveBuildDependenciesResult} */ (result);
+									if (this.resolveResults) {
+										for (const [key, value] of resolveResults) {
+											this.resolveResults.set(key, value);
 										}
-										if (!snapshot) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(
-												new Error("Unable to snapshot resolve dependencies")
-											);
-										}
-										if (this.resolveBuildDependenciesSnapshot) {
-											this.resolveBuildDependenciesSnapshot =
-												this.fileSystemInfo.mergeSnapshots(
-													this.resolveBuildDependenciesSnapshot,
-													snapshot
-												);
-										} else {
-											this.resolveBuildDependenciesSnapshot = snapshot;
-										}
-										if (reportProgress) {
-											reportProgress(
-												0.7,
-												"snapshot build dependencies",
-												"modules"
-											);
-										}
-										this.fileSystemInfo.createSnapshot(
-											undefined,
-											files,
-											directories,
-											missing,
-											this.snapshot.buildDependencies,
-											(err, snapshot) => {
+									} else {
+										this.resolveResults = resolveResults;
+									}
+									if (reportProgress) {
+										reportProgress(
+											0.6,
+											"snapshot build dependencies",
+											"resolving"
+										);
+									}
+									this.fileSystemInfo.createSnapshot(
+										undefined,
+										resolveDependencies.files,
+										resolveDependencies.directories,
+										resolveDependencies.missing,
+										this.snapshot.resolveBuildDependencies,
+										(err, snapshot) => {
+											if (err) {
+												this.logger.timeEnd("snapshot build dependencies");
+												return reject(err);
+											}
+											if (!snapshot) {
 												this.logger.timeEnd("snapshot build dependencies");
-												if (err) return reject(err);
-												if (!snapshot) {
-													return reject(
-														new Error("Unable to snapshot build dependencies")
+												return reject(
+													new Error("Unable to snapshot resolve dependencies")
+												);
+											}
+											if (this.resolveBuildDependenciesSnapshot) {
+												this.resolveBuildDependenciesSnapshot =
+													this.fileSystemInfo.mergeSnapshots(
+														this.resolveBuildDependenciesSnapshot,
+														snapshot
 													);
-												}
-												this.logger.debug("Captured build dependencies");
-
-												if (this.buildSnapshot) {
-													this.buildSnapshot =
-														this.fileSystemInfo.mergeSnapshots(
-															this.buildSnapshot,
-															snapshot
+											} else {
+												this.resolveBuildDependenciesSnapshot = snapshot;
+											}
+											if (reportProgress) {
+												reportProgress(
+													0.7,
+													"snapshot build dependencies",
+													"modules"
+												);
+											}
+											this.fileSystemInfo.createSnapshot(
+												undefined,
+												files,
+												directories,
+												missing,
+												this.snapshot.buildDependencies,
+												(err, snapshot) => {
+													this.logger.timeEnd("snapshot build dependencies");
+													if (err) return reject(err);
+													if (!snapshot) {
+														return reject(
+															new Error("Unable to snapshot build dependencies")
 														);
-												} else {
-													this.buildSnapshot = snapshot;
+													}
+													this.logger.debug("Captured build dependencies");
+
+													if (this.buildSnapshot) {
+														this.buildSnapshot =
+															this.fileSystemInfo.mergeSnapshots(
+																this.buildSnapshot,
+																snapshot
+															);
+													} else {
+														this.buildSnapshot = snapshot;
+													}
+
+													resolve();
 												}
-
-												resolve();
-											}
-										);
-									}
-								);
-							}
-						);
-					});
+											);
+										}
+									);
+								}
+							);
+						}
+					);
 				} else {
 					promise = Promise.resolve();
 				}

package/lib/cache/ResolverCachePlugin.js

@@ -26,6 +26,11 @@ const makeSerializable = require("../util/makeSerializable");
  * @typedef {import("tapable").SyncHook<T>} SyncHook
  */
 
+/**
+ * @template H
+ * @typedef {import("tapable").HookMapInterceptor<H>} HookMapInterceptor
+ */
+
 class CacheEntry {
 	/**
 	 * @param {ResolveRequest} result result
@@ -125,7 +130,7 @@ class ResolverCachePlugin {
 			});
 		});
 
-		/** @typedef {function((Error | null)=, ResolveRequest=): void} Callback */
+		/** @typedef {(err?: Error | null, resolveRequest?: ResolveRequest | null) => void} Callback */
 		/** @typedef {ResolveRequest & { _ResolverCachePluginCacheMiss: true }} ResolveRequestWithCacheMiss */
 
 		/**
@@ -244,13 +249,16 @@ class ResolverCachePlugin {
 			);
 		};
 		compiler.resolverFactory.hooks.resolver.intercept({
-			factory(type, hook) {
-				/** @type {Map<string, (function(Error=, ResolveRequest=): void)[]>} */
+			factory(type, _hook) {
+				/** @typedef {(err?: Error, resolveRequest?: ResolveRequest) => void} ActiveRequest */
+				/** @type {Map<string, ActiveRequest[]>} */
 				const activeRequests = new Map();
-				/** @type {Map<string, [function(Error=, ResolveRequest=): void, NonNullable<ResolveContext["yield"]>][]>} */
+				/** @type {Map<string, [ActiveRequest, NonNullable<ResolveContext["yield"]>][]>} */
 				const activeRequestsWithYield = new Map();
-				/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
-				(hook).tap("ResolverCachePlugin", (resolver, options, userOptions) => {
+				const hook =
+					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
+					(_hook);
+				hook.tap("ResolverCachePlugin", (resolver, options, userOptions) => {
 					if (/** @type {TODO} */ (options).cache !== true) return;
 					const optionsIdent = objectToString(userOptions, false);
 					const cacheWithContext =
@@ -299,7 +307,7 @@ class ResolverCachePlugin {
 							let yields;
 
 							/**
-							 * @type {function((Error | null)=, ResolveRequest | ResolveRequest[]=): void}
+							 * @type {(err?: Error | null, result?: ResolveRequest | ResolveRequest[] | null) => void}
 							 */
 							const done = withYield
 								? (err, result) => {

package/lib/cache/getLazyHashedEtag.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 
 /** @typedef {import("../util/Hash")} Hash */
@@ -12,7 +13,7 @@ const createHash = require("../util/createHash");
 
 /**
  * @typedef {object} HashableObject
- * @property {function(Hash): void} updateHash
+ * @property {(hash: Hash) => void} updateHash
  */
 
 class LazyHashedEtag {
@@ -20,7 +21,7 @@ class LazyHashedEtag {
 	 * @param {HashableObject} obj object with updateHash method
 	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	constructor(obj, hashFunction = "md4") {
+	constructor(obj, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		this._obj = obj;
 		this._hash = undefined;
 		this._hashFunction = hashFunction;
@@ -50,7 +51,7 @@ const mapObjects = new WeakMap();
  * @param {(string | HashConstructor)=} hashFunction the hash function to use
  * @returns {LazyHashedEtag} etag
  */
-const getter = (obj, hashFunction = "md4") => {
+const getter = (obj, hashFunction = DEFAULTS.HASH_FUNCTION) => {
 	let innerMap;
 	if (typeof hashFunction === "string") {
 		innerMap = mapStrings.get(hashFunction);