fix yield

- handle in ignore for AliasPlugin
- handle in ignore for AliasFieldPlugin
- handle for unsafe cache
- handle yield for custom plugins
- use real fs in yield tests
- add tests for AliasField and Alias in yield

Author: vankop

lib/AliasFieldPlugin.js

@@ -60,6 +60,10 @@ module.exports = class AliasFieldPlugin {
 						...request,
 						path: false
 					};
+					if (typeof resolveContext.yield === "function") {
+						resolveContext.yield(ignoreObj);
+						return callback(null, null);
+					}
 					return callback(null, ignoreObj);
 				}
 				const obj = {

lib/AliasPlugin.js

@@ -8,6 +8,7 @@
 const forEachBail = require("./forEachBail");
 
 /** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
 /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 /** @typedef {{alias: string|Array<string>|false, name: string, onlyModule?: boolean}} AliasOption */
 
@@ -45,10 +46,15 @@ module.exports = class AliasPlugin {
 							const remainingRequest = innerRequest.substr(item.name.length);
 							const resolveWithAlias = (alias, callback) => {
 								if (alias === false) {
+									/** @type {ResolveRequest} */
 									const ignoreObj = {
 										...request,
 										path: false
 									};
+									if (typeof resolveContext.yield === "function") {
+										resolveContext.yield(ignoreObj);
+										return callback(null, null);
+									}
 									return callback(null, ignoreObj);
 								}
 								if (

lib/Resolver.js

@@ -274,12 +274,24 @@ class Resolver {
 		};
 
 		let yield_;
-		let yieldCalled = false;
+		let ignoredObj;
+		let finishYield;
+		let yieldCalled = 0;
 		if (typeof resolveContext.yield === "function") {
 			const old = resolveContext.yield;
 			yield_ = obj => {
-				yieldCalled = true;
-				old(obj);
+				if (obj.path === false) {
+					if (ignoredObj) return;
+					ignoredObj = obj;
+				} else {
+					old(obj);
+				}
+				yieldCalled++;
+			};
+			finishYield = result => {
+				if (result) yield_(result);
+				if (yieldCalled === 1 && ignoredObj) old(ignoredObj);
+				callback(null);
 			};
 		}
 
@@ -329,8 +341,8 @@ class Resolver {
 				(err, result) => {
 					if (err) return callback(err);
 
+					if (yieldCalled || (result && yield_)) return finishYield(result);
 					if (result) return finishResolved(result);
-					if (yieldCalled) return callback(null);
 
 					return finishWithoutResolve(log);
 				}
@@ -353,8 +365,8 @@ class Resolver {
 				(err, result) => {
 					if (err) return callback(err);
 
+					if (yieldCalled || (result && yield_)) return finishYield(result);
 					if (result) return finishResolved(result);
-					if (yieldCalled) return callback(null);
 
 					// log is missing for the error details
 					// so we redo the resolving for the log info
@@ -372,11 +384,11 @@ class Resolver {
 							yield: yield_,
 							stack: resolveContext.stack
 						},
-						err => {
+						(err, result) => {
 							if (err) return callback(err);
 
 							// In a case that there is a race condition and yield will be called
-							if (yieldCalled) return callback(null);
+							if (yieldCalled || (result && yield_)) return finishYield(result);
 
 							return finishWithoutResolve(log);
 						}

lib/UnsafeCachePlugin.js

@@ -10,8 +10,9 @@
 /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 /** @typedef {{[k: string]: any}} Cache */
 
-function getCacheId(request, withContext) {
+function getCacheId(type, request, withContext) {
 	return JSON.stringify({
+		type,
 		context: withContext ? request.context : "",
 		path: request.path,
 		query: request.query,
@@ -46,18 +47,49 @@ module.exports = class UnsafeCachePlugin {
 			.getHook(this.source)
 			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
 				if (!this.filterPredicate(request)) return callback();
-				const cacheId = getCacheId(request, this.withContext);
+				const isYield = typeof resolveContext.yield === "function";
+				const cacheId = getCacheId(
+					isYield ? "yield" : "default",
+					request,
+					this.withContext
+				);
 				const cacheEntry = this.cache[cacheId];
 				if (cacheEntry) {
+					if (isYield) {
+						const yield_ = /** @type {Function} */ (resolveContext.yield);
+						if (Array.isArray(cacheEntry)) {
+							for (const result of cacheEntry) yield_(result);
+						} else {
+							yield_(cacheEntry);
+						}
+						return callback(null, null);
+					}
 					return callback(null, cacheEntry);
 				}
+
+				let yieldFn;
+				let yield_;
+				const yieldResult = [];
+				if (isYield) {
+					yieldFn = resolveContext.yield;
+					yield_ = result => {
+						yieldResult.push(result);
+					};
+				}
+
 				resolver.doResolve(
 					target,
 					request,
 					null,
-					resolveContext,
+					yield_ ? { ...resolveContext, yield: yield_ } : resolveContext,
 					(err, result) => {
 						if (err) return callback(err);
+						if (isYield) {
+							if (result) yieldResult.push(result);
+							for (const result of yieldResult) yieldFn(result);
+							this.cache[cacheId] = yieldResult;
+							return callback(null, null);
+						}
 						if (result) return callback(null, (this.cache[cacheId] = result));
 						callback();
 					}