webpack 5.97.1 → 5.104.1

package/lib/cache/ResolverCachePlugin.js

@@ -26,6 +26,8 @@ const makeSerializable = require("../util/makeSerializable");
  * @typedef {import("tapable").SyncHook<T>} SyncHook
  */
 
+/** @typedef {Set<string>} Dependencies  */
+
 class CacheEntry {
 	/**
 	 * @param {ResolveRequest} result result
@@ -90,6 +92,10 @@ const objectToString = (object, excludeContext) => {
 	return str;
 };
 
+/** @typedef {NonNullable<ResolveContext["yield"]>} Yield */
+
+const PLUGIN_NAME = "ResolverCachePlugin";
+
 class ResolverCachePlugin {
 	/**
 	 * Apply the plugin
@@ -97,7 +103,7 @@ class ResolverCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
+		const cache = compiler.getCache(PLUGIN_NAME);
 		/** @type {FileSystemInfo} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
@@ -106,12 +112,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+			compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
 				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 					logger.log(
 						`${Math.round(
 							(100 * realResolves) / (realResolves + cachedResolves)
@@ -125,7 +131,7 @@ class ResolverCachePlugin {
 			});
 		});
 
-		/** @typedef {function((Error | null)=, ResolveRequest=): void} Callback */
+		/** @typedef {(err?: Error | null, resolveRequest?: ResolveRequest | null) => void} Callback */
 		/** @typedef {ResolveRequest & { _ResolverCachePluginCacheMiss: true }} ResolveRequestWithCacheMiss */
 
 		/**
@@ -154,11 +160,8 @@ class ResolverCachePlugin {
 			const newResolveContext = {
 				...resolveContext,
 				stack: new Set(),
-				/** @type {LazySet<string>} */
 				missingDependencies: new LazySet(),
-				/** @type {LazySet<string>} */
 				fileDependencies: new LazySet(),
-				/** @type {LazySet<string>} */
 				contextDependencies: new LazySet()
 			};
 			/** @type {ResolveRequest[] | undefined} */
@@ -167,18 +170,18 @@ class ResolverCachePlugin {
 			if (typeof newResolveContext.yield === "function") {
 				yieldResult = [];
 				withYield = true;
-				newResolveContext.yield = obj =>
+				newResolveContext.yield = (obj) =>
 					/** @type {ResolveRequest[]} */
 					(yieldResult).push(obj);
 			}
 			/**
 			 * @param {"fileDependencies" | "contextDependencies" | "missingDependencies"} key key
 			 */
-			const propagate = key => {
+			const propagate = (key) => {
 				if (resolveContext[key]) {
 					addAllToSet(
-						/** @type {Set<string>} */ (resolveContext[key]),
-						/** @type {Set<string>} */ (newResolveContext[key])
+						/** @type {Dependencies} */ (resolveContext[key]),
+						/** @type {Dependencies} */ (newResolveContext[key])
 					);
 				}
 			};
@@ -198,11 +201,11 @@ class ResolverCachePlugin {
 					const missingDependencies = newResolveContext.missingDependencies;
 					fileSystemInfo.createSnapshot(
 						resolveTime,
-						/** @type {Set<string>} */
+						/** @type {Dependencies} */
 						(fileDependencies),
-						/** @type {Set<string>} */
+						/** @type {Dependencies} */
 						(contextDependencies),
-						/** @type {Set<string>} */
+						/** @type {Dependencies} */
 						(missingDependencies),
 						snapshotOptions,
 						(err, snapshot) => {
@@ -210,15 +213,18 @@ class ResolverCachePlugin {
 							const resolveResult = withYield ? yieldResult : result;
 							// since we intercept resolve hook
 							// we still can get result in callback
-							if (withYield && result)
-								/** @type {ResolveRequest[]} */ (yieldResult).push(result);
+							if (withYield && result) {
+								/** @type {ResolveRequest[]} */
+								(yieldResult).push(result);
+							}
 							if (!snapshot) {
-								if (resolveResult)
+								if (resolveResult) {
 									return callback(
 										null,
 										/** @type {ResolveRequest} */
 										(resolveResult)
 									);
+								}
 								return callback();
 							}
 							itemCache.store(
@@ -227,14 +233,15 @@ class ResolverCachePlugin {
 									(resolveResult),
 									snapshot
 								),
-								storeErr => {
+								(storeErr) => {
 									if (storeErr) return callback(storeErr);
-									if (resolveResult)
+									if (resolveResult) {
 										return callback(
 											null,
 											/** @type {ResolveRequest} */
 											(resolveResult)
 										);
+									}
 									callback();
 								}
 							);
@@ -244,14 +251,22 @@ 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[], Yield[]]>} */
 				const activeRequestsWithYield = new Map();
-				/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
-				(hook).tap("ResolverCachePlugin", (resolver, options, userOptions) => {
-					if (/** @type {TODO} */ (options).cache !== true) return;
+				const hook =
+					/** @type {SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>} */
+					(_hook);
+				hook.tap(PLUGIN_NAME, (resolver, options, userOptions) => {
+					if (
+						/** @type {ResolveOptions & { cache: boolean }} */
+						(options).cache !== true
+					) {
+						return;
+					}
 					const optionsIdent = objectToString(userOptions, false);
 					const cacheWithContext =
 						options.cacheWithContext !== undefined
@@ -259,7 +274,7 @@ class ResolverCachePlugin {
 							: false;
 					resolver.hooks.resolve.tapAsync(
 						{
-							name: "ResolverCachePlugin",
+							name: PLUGIN_NAME,
 							stage: -100
 						},
 						(request, resolveContext, callback) => {
@@ -280,7 +295,7 @@ class ResolverCachePlugin {
 								if (activeRequest) {
 									activeRequest[0].push(callback);
 									activeRequest[1].push(
-										/** @type {NonNullable<ResolveContext["yield"]>} */
+										/** @type {Yield} */
 										(resolveContext.yield)
 									);
 									return;
@@ -295,11 +310,11 @@ class ResolverCachePlugin {
 							const itemCache = cache.getItemCache(identifier, null);
 							/** @type {Callback[] | false | undefined} */
 							let callbacks;
-							/** @type {NonNullable<ResolveContext["yield"]>[] | undefined} */
+							/** @type {Yield[] | undefined} */
 							let yields;
 
 							/**
-							 * @type {function((Error | null)=, ResolveRequest | ResolveRequest[]=): void}
+							 * @type {(err?: Error | null, result?: ResolveRequest | ResolveRequest[] | null) => void}
 							 */
 							const done = withYield
 								? (err, result) => {
@@ -307,13 +322,14 @@ class ResolverCachePlugin {
 											if (err) {
 												callback(err);
 											} else {
-												if (result)
+												if (result) {
 													for (const r of /** @type {ResolveRequest[]} */ (
 														result
 													)) {
-														/** @type {NonNullable<ResolveContext["yield"]>} */
+														/** @type {Yield} */
 														(resolveContext.yield)(r);
 													}
+												}
 												callback(null, null);
 											}
 											yields = undefined;
@@ -328,14 +344,14 @@ class ResolverCachePlugin {
 											} else {
 												for (let i = 0; i < definedCallbacks.length; i++) {
 													const cb = definedCallbacks[i];
-													const yield_ =
-														/** @type {NonNullable<ResolveContext["yield"]>[]} */
-														(yields)[i];
-													if (result)
+													const yield_ = /** @type {Yield[]} */ (yields)[i];
+													if (result) {
 														for (const r of /** @type {ResolveRequest[]} */ (
 															result
-														))
+														)) {
 															yield_(r);
+														}
+													}
 													cb(null, null);
 												}
 											}
@@ -382,21 +398,21 @@ class ResolverCachePlugin {
 										cachedResolves++;
 										if (resolveContext.missingDependencies) {
 											addAllToSet(
-												/** @type {Set<string>} */
+												/** @type {Dependencies} */
 												(resolveContext.missingDependencies),
 												snapshot.getMissingIterable()
 											);
 										}
 										if (resolveContext.fileDependencies) {
 											addAllToSet(
-												/** @type {Set<string>} */
+												/** @type {Dependencies} */
 												(resolveContext.fileDependencies),
 												snapshot.getFileIterable()
 											);
 										}
 										if (resolveContext.contextDependencies) {
 											addAllToSet(
-												/** @type {Set<string>} */
+												/** @type {Dependencies} */
 												(resolveContext.contextDependencies),
 												snapshot.getContextIterable()
 											);
@@ -416,14 +432,8 @@ class ResolverCachePlugin {
 							itemCache.get(processCacheResult);
 							if (withYield && callbacks === undefined) {
 								callbacks = [callback];
-								yields = [
-									/** @type {NonNullable<ResolveContext["yield"]>} */
-									(resolveContext.yield)
-								];
-								activeRequestsWithYield.set(
-									identifier,
-									/** @type {[any, any]} */ ([callbacks, yields])
-								);
+								yields = [/** @type {Yield} */ (resolveContext.yield)];
+								activeRequestsWithYield.set(identifier, [callbacks, yields]);
 							} else if (callbacks === undefined) {
 								callbacks = [callback];
 								activeRequests.set(identifier, callbacks);

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;
@@ -33,7 +34,7 @@ class LazyHashedEtag {
 		if (this._hash === undefined) {
 			const hash = createHash(this._hashFunction);
 			this._obj.updateHash(hash);
-			this._hash = /** @type {string} */ (hash.digest("base64"));
+			this._hash = hash.digest("base64");
 		}
 		return this._hash;
 	}
@@ -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);