webpack 5.59.0 → 5.94.0

package/lib/cache/ResolverCachePlugin.js

@@ -8,7 +8,7 @@
 const LazySet = require("../util/LazySet");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
 /** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../FileSystemInfo")} FileSystemInfo */
@@ -50,7 +50,7 @@ const addAllToSet = (set, otherSet) => {
 };
 
 /**
- * @param {Object} object an object
+ * @param {object} object an object
  * @param {boolean} excludeContext if true, context is not included in string
  * @returns {string} stringified version
  */
@@ -59,11 +59,10 @@ const objectToString = (object, excludeContext) => {
 	for (const key in object) {
 		if (excludeContext && key === "context") continue;
 		const value = object[key];
-		if (typeof value === "object" && value !== null) {
-			str += `|${key}=[${objectToString(value, false)}|]`;
-		} else {
-			str += `|${key}=|${value}`;
-		}
+		str +=
+			typeof value === "object" && value !== null
+				? `|${key}=[${objectToString(value, false)}|]`
+				: `|${key}=|${value}`;
 	}
 	return str;
 };
@@ -104,9 +103,9 @@ class ResolverCachePlugin {
 		/**
 		 * @param {ItemCacheFacade} itemCache cache
 		 * @param {Resolver} resolver the resolver
-		 * @param {Object} resolveContext context for resolving meta info
-		 * @param {Object} request the request info object
-		 * @param {function(Error=, Object=): void} callback callback function
+		 * @param {object} resolveContext context for resolving meta info
+		 * @param {object} request the request info object
+		 * @param {function((Error | null)=, object=): void} callback callback function
 		 * @returns {void}
 		 */
 		const doRealResolve = (
@@ -124,10 +123,20 @@ 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()
 			};
+			let yieldResult;
+			let withYield = false;
+			if (typeof newResolveContext.yield === "function") {
+				yieldResult = [];
+				withYield = true;
+				newResolveContext.yield = obj => yieldResult.push(obj);
+			}
 			const propagate = key => {
 				if (resolveContext[key]) {
 					addAllToSet(resolveContext[key], newResolveContext[key]);
@@ -155,15 +164,22 @@ class ResolverCachePlugin {
 						snapshotOptions,
 						(err, snapshot) => {
 							if (err) return callback(err);
+							const resolveResult = withYield ? yieldResult : result;
+							// since we intercept resolve hook
+							// we still can get result in callback
+							if (withYield && result) yieldResult.push(result);
 							if (!snapshot) {
-								if (result) return callback(null, result);
+								if (resolveResult) return callback(null, resolveResult);
 								return callback();
 							}
-							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
-								if (storeErr) return callback(storeErr);
-								if (result) return callback(null, result);
-								callback();
-							});
+							itemCache.store(
+								new CacheEntry(resolveResult, snapshot),
+								storeErr => {
+									if (storeErr) return callback(storeErr);
+									if (resolveResult) return callback(null, resolveResult);
+									callback();
+								}
+							);
 						}
 					);
 				}
@@ -171,14 +187,16 @@ class ResolverCachePlugin {
 		};
 		compiler.resolverFactory.hooks.resolver.intercept({
 			factory(type, hook) {
-				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
+				/** @type {Map<string, (function(Error=, object=): void)[]>} */
 				const activeRequests = new Map();
+				/** @type {Map<string, [function(Error=, object=): void, function(Error=, object=): void][]>} */
+				const activeRequestsWithYield = new Map();
 				hook.tap(
 					"ResolverCachePlugin",
 					/**
 					 * @param {Resolver} resolver the resolver
-					 * @param {Object} options resolve options
-					 * @param {Object} userOptions resolve options passed by the user
+					 * @param {object} options resolve options
+					 * @param {object} userOptions resolve options passed by the user
 					 * @returns {void}
 					 */
 					(resolver, options, userOptions) => {
@@ -194,32 +212,76 @@ class ResolverCachePlugin {
 								stage: -100
 							},
 							(request, resolveContext, callback) => {
-								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
+								if (
+									/** @type {TODO} */ (request)._ResolverCachePluginCacheMiss ||
+									!fileSystemInfo
+								) {
 									return callback();
 								}
-								const identifier = `${type}${optionsIdent}${objectToString(
-									request,
-									!cacheWithContext
-								)}`;
-								const activeRequest = activeRequests.get(identifier);
-								if (activeRequest) {
-									activeRequest.push(callback);
-									return;
+								const withYield = typeof resolveContext.yield === "function";
+								const identifier = `${type}${
+									withYield ? "|yield" : "|default"
+								}${optionsIdent}${objectToString(request, !cacheWithContext)}`;
+
+								if (withYield) {
+									const activeRequest = activeRequestsWithYield.get(identifier);
+									if (activeRequest) {
+										activeRequest[0].push(callback);
+										activeRequest[1].push(
+											/** @type {TODO} */ (resolveContext.yield)
+										);
+										return;
+									}
+								} else {
+									const activeRequest = activeRequests.get(identifier);
+									if (activeRequest) {
+										activeRequest.push(callback);
+										return;
+									}
 								}
 								const itemCache = cache.getItemCache(identifier, null);
 								let callbacks;
-								const done = (err, result) => {
-									if (callbacks === undefined) {
-										callback(err, result);
-										callbacks = false;
-									} else {
-										for (const callback of callbacks) {
-											callback(err, result);
+								let yields;
+								const done = withYield
+									? (err, result) => {
+											if (callbacks === undefined) {
+												if (err) {
+													callback(err);
+												} else {
+													if (result)
+														for (const r of result) resolveContext.yield(r);
+													callback(null, null);
+												}
+												yields = undefined;
+												callbacks = false;
+											} else {
+												if (err) {
+													for (const cb of callbacks) cb(err);
+												} else {
+													for (let i = 0; i < callbacks.length; i++) {
+														const cb = callbacks[i];
+														const yield_ = yields[i];
+														if (result) for (const r of result) yield_(r);
+														cb(null, null);
+													}
+												}
+												activeRequestsWithYield.delete(identifier);
+												yields = undefined;
+												callbacks = false;
+											}
 										}
-										activeRequests.delete(identifier);
-										callbacks = false;
-									}
-								};
+									: (err, result) => {
+											if (callbacks === undefined) {
+												callback(err, result);
+												callbacks = false;
+											} else {
+												for (const callback of callbacks) {
+													callback(err, result);
+												}
+												activeRequests.delete(identifier);
+												callbacks = false;
+											}
+										};
 								/**
 								 * @param {Error=} err error if any
 								 * @param {CacheEntry=} cacheEntry cache entry
@@ -246,19 +308,22 @@ class ResolverCachePlugin {
 												cachedResolves++;
 												if (resolveContext.missingDependencies) {
 													addAllToSet(
-														resolveContext.missingDependencies,
+														/** @type {LazySet<string>} */
+														(resolveContext.missingDependencies),
 														snapshot.getMissingIterable()
 													);
 												}
 												if (resolveContext.fileDependencies) {
 													addAllToSet(
-														resolveContext.fileDependencies,
+														/** @type {LazySet<string>} */
+														(resolveContext.fileDependencies),
 														snapshot.getFileIterable()
 													);
 												}
 												if (resolveContext.contextDependencies) {
 													addAllToSet(
-														resolveContext.contextDependencies,
+														/** @type {LazySet<string>} */
+														(resolveContext.contextDependencies),
 														snapshot.getContextIterable()
 													);
 												}
@@ -276,7 +341,14 @@ class ResolverCachePlugin {
 									}
 								};
 								itemCache.get(processCacheResult);
-								if (callbacks === undefined) {
+								if (withYield && callbacks === undefined) {
+									callbacks = [callback];
+									yields = [resolveContext.yield];
+									activeRequestsWithYield.set(
+										identifier,
+										/** @type {[any, any]} */ ([callbacks, yields])
+									);
+								} else if (callbacks === undefined) {
 									callbacks = [callback];
 									activeRequests.set(identifier, callbacks);
 								}

package/lib/cache/getLazyHashedEtag.js

@@ -11,7 +11,7 @@ const createHash = require("../util/createHash");
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
 
 /**
- * @typedef {Object} HashableObject
+ * @typedef {object} HashableObject
  * @property {function(Hash): void} updateHash
  */
 
@@ -47,7 +47,7 @@ const mapObjects = new WeakMap();
 
 /**
  * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
+ * @param {(string | HashConstructor)=} hashFunction the hash function to use
  * @returns {LazyHashedEtag} etag
  */
 const getter = (obj, hashFunction = "md4") => {

package/lib/cache/mergeEtags.js

@@ -34,27 +34,23 @@ const mergeEtags = (a, b) => {
 	if (typeof a === "string") {
 		if (typeof b === "string") {
 			return `${a}|${b}`;
-		} else {
-			const temp = b;
-			b = a;
-			a = temp;
 		}
-	} else {
-		if (typeof b !== "string") {
-			// both a and b are objects
-			let map = dualObjectMap.get(a);
-			if (map === undefined) {
-				dualObjectMap.set(a, (map = new WeakMap()));
-			}
-			const mergedEtag = map.get(b);
-			if (mergedEtag === undefined) {
-				const newMergedEtag = new MergedEtag(a, b);
-				map.set(b, newMergedEtag);
-				return newMergedEtag;
-			} else {
-				return mergedEtag;
-			}
+		const temp = b;
+		b = a;
+		a = temp;
+	} else if (typeof b !== "string") {
+		// both a and b are objects
+		let map = dualObjectMap.get(a);
+		if (map === undefined) {
+			dualObjectMap.set(a, (map = new WeakMap()));
 		}
+		const mergedEtag = map.get(b);
+		if (mergedEtag === undefined) {
+			const newMergedEtag = new MergedEtag(a, b);
+			map.set(b, newMergedEtag);
+			return newMergedEtag;
+		}
+		return mergedEtag;
 	}
 	// a is object, b is string
 	let map = objectStringMap.get(a);
@@ -66,9 +62,8 @@ const mergeEtags = (a, b) => {
 		const newMergedEtag = new MergedEtag(a, b);
 		map.set(b, newMergedEtag);
 		return newMergedEtag;
-	} else {
-		return mergedEtag;
 	}
+	return mergedEtag;
 };
 
 module.exports = mergeEtags;