webpack 5.14.0 → 5.18.0

package/lib/ExternalModuleFactoryPlugin.js

@@ -7,12 +7,13 @@
 
 const util = require("util");
 const ExternalModule = require("./ExternalModule");
-const { resolveByProperty } = require("./util/cleverMerge");
+const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9]+ /;
+const EMPTY_RESOLVE_OPTIONS = {};
 
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
@@ -171,14 +172,56 @@ class ExternalModuleFactoryPlugin {
 								cb
 							);
 						} else {
-							externals(
+							const promise = externals(
 								{
 									context,
 									request: dependency.request,
-									contextInfo
+									contextInfo,
+									getResolve: options => (context, request, callback) => {
+										const dependencyType = dependency.category || "";
+										const resolveContext = {
+											fileDependencies: data.fileDependencies,
+											missingDependencies: data.missingDependencies,
+											contextDependencies: data.contextDependencies
+										};
+										let resolver = normalModuleFactory.getResolver(
+											"normal",
+											dependencyType
+												? cachedSetProperty(
+														data.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+														"dependencyType",
+														dependencyType
+												  )
+												: data.resolveOptions
+										);
+										if (options) resolver = resolver.withOptions(options);
+										if (callback) {
+											resolver.resolve(
+												{},
+												context,
+												request,
+												resolveContext,
+												callback
+											);
+										} else {
+											return new Promise((resolve, reject) => {
+												resolver.resolve(
+													{},
+													context,
+													request,
+													resolveContext,
+													(err, result) => {
+														if (err) reject(err);
+														else resolve(result);
+													}
+												);
+											});
+										}
+									}
 								},
 								cb
 							);
+							if (promise && promise.then) promise.then(r => cb(null, r), cb);
 						}
 						return;
 					} else if (typeof externals === "object") {

package/lib/FileSystemInfo.js

@@ -11,6 +11,7 @@ const AsyncQueue = require("./util/AsyncQueue");
 const createHash = require("./util/createHash");
 const { join, dirname, relative } = require("./util/fs");
 const makeSerializable = require("./util/makeSerializable");
+const processAsyncTree = require("./util/processAsyncTree");
 
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
@@ -18,26 +19,19 @@ const makeSerializable = require("./util/makeSerializable");
 
 const supportsEsm = +process.versions.modules >= 83;
 
-const resolveContext = createResolver({
-	resolveToContext: true,
-	exportsFields: []
-});
-const resolve = createResolver({
-	extensions: [".js", ".json", ".node"],
-	conditionNames: ["require"]
-});
-
 let FS_ACCURACY = 2000;
 
 const EMPTY_SET = new Set();
 
-const RBDT_RESOLVE = 0;
-const RBDT_RESOLVE_DIRECTORY = 1;
-const RBDT_RESOLVE_FILE = 2;
-const RBDT_DIRECTORY = 3;
-const RBDT_FILE = 4;
-const RBDT_DIRECTORY_DEPENDENCIES = 5;
-const RBDT_FILE_DEPENDENCIES = 6;
+const RBDT_RESOLVE_CJS = 0;
+const RBDT_RESOLVE_ESM = 1;
+const RBDT_RESOLVE_DIRECTORY = 2;
+const RBDT_RESOLVE_CJS_FILE = 3;
+const RBDT_RESOLVE_ESM_FILE = 4;
+const RBDT_DIRECTORY = 5;
+const RBDT_FILE = 6;
+const RBDT_DIRECTORY_DEPENDENCIES = 7;
+const RBDT_FILE_DEPENDENCIES = 8;
 
 const INVALID = Symbol("invalid");
 
@@ -1056,6 +1050,26 @@ class FileSystemInfo {
 		this.contextHashQueue.add(path, callback);
 	}
 
+	_createBuildDependenciesResolvers() {
+		const resolveContext = createResolver({
+			resolveToContext: true,
+			exportsFields: [],
+			fileSystem: this.fs
+		});
+		const resolveCjs = createResolver({
+			extensions: [".js", ".json", ".node"],
+			conditionNames: ["require", "node"],
+			fileSystem: this.fs
+		});
+		const resolveEsm = createResolver({
+			extensions: [".js", ".json", ".node"],
+			fullySpecified: true,
+			conditionNames: ["import", "node"],
+			fileSystem: this.fs
+		});
+		return { resolveContext, resolveEsm, resolveCjs };
+	}
+
 	/**
 	 * @param {string} context context directory
 	 * @param {Iterable<string>} deps dependencies
@@ -1063,11 +1077,21 @@ class FileSystemInfo {
 	 * @returns {void}
 	 */
 	resolveBuildDependencies(context, deps, callback) {
+		const {
+			resolveContext,
+			resolveEsm,
+			resolveCjs
+		} = this._createBuildDependenciesResolvers();
+
 		/** @type {Set<string>} */
 		const files = new Set();
 		/** @type {Set<string>} */
+		const fileSymlinks = new Set();
+		/** @type {Set<string>} */
 		const directories = new Set();
 		/** @type {Set<string>} */
+		const directorySymlinks = new Set();
+		/** @type {Set<string>} */
 		const missing = new Set();
 		/** @type {Set<string>} */
 		const resolveFiles = new Set();
@@ -1077,83 +1101,99 @@ class FileSystemInfo {
 		const resolveMissing = new Set();
 		/** @type {Map<string, string>} */
 		const resolveResults = new Map();
-		/** @type {asyncLib.QueueObject<{type: number, path: string, context?: string, expected?: string }, Error>} */
-		const queue = asyncLib.queue(
-			({ type, context, path, expected }, callback) => {
+		const invalidResolveResults = new Set();
+		const resolverContext = {
+			fileDependencies: resolveFiles,
+			contextDependencies: resolveDirectories,
+			missingDependencies: resolveMissing
+		};
+		processAsyncTree(
+			Array.from(deps, dep => ({
+				type: RBDT_RESOLVE_CJS,
+				context,
+				path: dep,
+				expected: undefined
+			})),
+			20,
+			({ type, context, path, expected }, push, callback) => {
 				const resolveDirectory = path => {
 					const key = `d\n${context}\n${path}`;
 					if (resolveResults.has(key)) {
 						return callback();
 					}
-					resolveContext(
-						context,
-						path,
-						{
-							fileDependencies: resolveFiles,
-							contextDependencies: resolveDirectories,
-							missingDependencies: resolveMissing
-						},
-						(err, result) => {
+					resolveResults.set(key, undefined);
+					resolveContext(context, path, resolverContext, (err, result) => {
+						if (err) {
+							invalidResolveResults.add(key);
+							if (
+								err.code === "ENOENT" ||
+								err.code === "UNDECLARED_DEPENDENCY"
+							) {
+								return callback();
+							}
+							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
+							return callback(err);
+						}
+						resolveResults.set(key, result);
+						push({
+							type: RBDT_DIRECTORY,
+							context: undefined,
+							path: result,
+							expected: undefined
+						});
+						callback();
+					});
+				};
+				const resolveFile = (path, symbol, resolve) => {
+					const key = `${symbol}\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
+					}
+					resolveResults.set(key, undefined);
+					resolve(context, path, resolverContext, (err, result) => {
+						if (expected) {
+							if (result === expected) {
+								resolveResults.set(key, result);
+							} else {
+								invalidResolveResults.add(key);
+								this.logger.debug(
+									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${result}' instead. Resolving dependencies are ignored for this path.`
+								);
+							}
+						} else {
 							if (err) {
+								invalidResolveResults.add(key);
 								if (
 									err.code === "ENOENT" ||
 									err.code === "UNDECLARED_DEPENDENCY"
 								) {
 									return callback();
 								}
-								err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
+								err.message += `\nwhile resolving '${path}' in ${context} as file`;
 								return callback(err);
 							}
 							resolveResults.set(key, result);
-							queue.push({
-								type: RBDT_DIRECTORY,
-								path: result
+							push({
+								type: RBDT_FILE,
+								context: undefined,
+								path: result,
+								expected: undefined
 							});
-							callback();
 						}
-					);
-				};
-				const resolveFile = path => {
-					const key = `f\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
-					}
-					resolve(
-						context,
-						path,
-						{
-							fileDependencies: resolveFiles,
-							contextDependencies: resolveDirectories,
-							missingDependencies: resolveMissing
-						},
-						(err, result) => {
-							if (expected) {
-								if (result === expected) {
-									resolveResults.set(key, result);
-								}
-							} else {
-								if (err) {
-									if (
-										err.code === "ENOENT" ||
-										err.code === "UNDECLARED_DEPENDENCY"
-									) {
-										return callback();
-									}
-									err.message += `\nwhile resolving '${path}' in ${context} as file`;
-									return callback(err);
-								}
-								resolveResults.set(key, result);
-								queue.push({
-									type: RBDT_FILE,
-									path: result
-								});
-							}
-							callback();
-						}
-					);
+						callback();
+					});
 				};
 				switch (type) {
-					case RBDT_RESOLVE: {
+					case RBDT_RESOLVE_CJS: {
+						const isDirectory = /[\\/]$/.test(path);
+						if (isDirectory) {
+							resolveDirectory(path.slice(0, path.length - 1));
+						} else {
+							resolveFile(path, "f", resolveCjs);
+						}
+						break;
+					}
+					case RBDT_RESOLVE_ESM: {
 						const isDirectory = /[\\/]$/.test(path);
 						if (isDirectory) {
 							resolveDirectory(path.slice(0, path.length - 1));
@@ -1166,8 +1206,12 @@ class FileSystemInfo {
 						resolveDirectory(path);
 						break;
 					}
-					case RBDT_RESOLVE_FILE: {
-						resolveFile(path);
+					case RBDT_RESOLVE_CJS_FILE: {
+						resolveFile(path, "f", resolveCjs);
+						break;
+					}
+					case RBDT_RESOLVE_ESM_FILE: {
+						resolveFile(path, "e", resolveEsm);
 						break;
 					}
 					case RBDT_FILE: {
@@ -1175,19 +1219,22 @@ class FileSystemInfo {
 							callback();
 							break;
 						}
+						files.add(path);
 						this.fs.realpath(path, (err, _realPath) => {
 							if (err) return callback(err);
 							const realPath = /** @type {string} */ (_realPath);
 							if (realPath !== path) {
+								fileSymlinks.add(path);
 								resolveFiles.add(path);
-							}
-							if (!files.has(realPath)) {
+								if (files.has(realPath)) return callback();
 								files.add(realPath);
-								queue.push({
-									type: RBDT_FILE_DEPENDENCIES,
-									path: realPath
-								});
 							}
+							push({
+								type: RBDT_FILE_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined
+							});
 							callback();
 						});
 						break;
@@ -1197,19 +1244,22 @@ class FileSystemInfo {
 							callback();
 							break;
 						}
+						directories.add(path);
 						this.fs.realpath(path, (err, _realPath) => {
 							if (err) return callback(err);
 							const realPath = /** @type {string} */ (_realPath);
 							if (realPath !== path) {
+								directorySymlinks.add(path);
 								resolveFiles.add(path);
-							}
-							if (!directories.has(realPath)) {
+								if (directories.has(realPath)) return callback();
 								directories.add(realPath);
-								queue.push({
-									type: RBDT_DIRECTORY_DEPENDENCIES,
-									path: realPath
-								});
 							}
+							push({
+								type: RBDT_DIRECTORY_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined
+							});
 							callback();
 						});
 						break;
@@ -1227,30 +1277,33 @@ class FileSystemInfo {
 							children: for (const child of module.children) {
 								let childPath = child.filename;
 								if (childPath) {
-									queue.push({
+									push({
 										type: RBDT_FILE,
-										path: childPath
+										context: undefined,
+										path: childPath,
+										expected: undefined
 									});
-									if (childPath.endsWith(".js"))
-										childPath = childPath.slice(0, -3);
 									const context = dirname(this.fs, path);
 									for (const modulePath of module.paths) {
 										if (childPath.startsWith(modulePath)) {
-											const request = childPath.slice(modulePath.length + 1);
-											queue.push({
-												type: RBDT_RESOLVE_FILE,
+											let request = childPath.slice(modulePath.length + 1);
+											if (request.endsWith(".js"))
+												request = request.slice(0, -3);
+											push({
+												type: RBDT_RESOLVE_CJS_FILE,
 												context,
 												path: request,
-												expected: childPath
+												expected: child.filename
 											});
 											continue children;
 										}
 									}
 									let request = relative(this.fs, context, childPath);
+									if (request.endsWith(".js")) request = request.slice(0, -3);
 									request = request.replace(/\\/g, "/");
 									if (!request.startsWith("../")) request = `./${request}`;
-									queue.push({
-										type: RBDT_RESOLVE_FILE,
+									push({
+										type: RBDT_RESOLVE_CJS_FILE,
 										context,
 										path: request,
 										expected: child.filename
@@ -1294,10 +1347,11 @@ class FileSystemInfo {
 													// e.g. import.meta
 													continue;
 												}
-												queue.push({
-													type: RBDT_RESOLVE_FILE,
+												push({
+													type: RBDT_RESOLVE_ESM_FILE,
 													context,
-													path: dependency
+													path: dependency,
+													expected: undefined
 												});
 											} catch (e) {
 												this.logger.warn(
@@ -1340,9 +1394,11 @@ class FileSystemInfo {
 									resolveMissing.add(packageJson);
 									const parent = dirname(this.fs, packagePath);
 									if (parent !== packagePath) {
-										queue.push({
+										push({
 											type: RBDT_DIRECTORY_DEPENDENCIES,
-											path: parent
+											context: undefined,
+											path: parent,
+											expected: undefined
 										});
 									}
 									callback();
@@ -1360,10 +1416,11 @@ class FileSystemInfo {
 							const depsObject = packageData.dependencies;
 							if (typeof depsObject === "object" && depsObject) {
 								for (const dep of Object.keys(depsObject)) {
-									queue.push({
+									push({
 										type: RBDT_RESOLVE_DIRECTORY,
 										context: packagePath,
-										path: dep
+										path: dep,
+										expected: undefined
 									});
 								}
 							}
@@ -1373,38 +1430,24 @@ class FileSystemInfo {
 					}
 				}
 			},
-			50
+			err => {
+				if (err) return callback(err);
+				for (const l of fileSymlinks) files.delete(l);
+				for (const l of directorySymlinks) directories.delete(l);
+				for (const k of invalidResolveResults) resolveResults.delete(k);
+				callback(null, {
+					files,
+					directories,
+					missing,
+					resolveResults,
+					resolveDependencies: {
+						files: resolveFiles,
+						directories: resolveDirectories,
+						missing: resolveMissing
+					}
+				});
+			}
 		);
-		queue.drain = () => {
-			callback(null, {
-				files,
-				directories,
-				missing,
-				resolveResults,
-				resolveDependencies: {
-					files: resolveFiles,
-					directories: resolveDirectories,
-					missing: resolveMissing
-				}
-			});
-		};
-		queue.error = err => {
-			callback(err);
-			callback = () => {};
-		};
-		let jobQueued = false;
-		for (const dep of deps) {
-			queue.push({
-				type: RBDT_RESOLVE,
-				context,
-				path: dep
-			});
-			jobQueued = true;
-		}
-		if (!jobQueued) {
-			// queue won't call drain when no jobs are queue
-			queue.drain();
-		}
 	}
 
 	/**
@@ -1413,6 +1456,11 @@ class FileSystemInfo {
 	 * @returns {void}
 	 */
 	checkResolveResultsValid(resolveResults, callback) {
+		const {
+			resolveCjs,
+			resolveEsm,
+			resolveContext
+		} = this._createBuildDependenciesResolvers();
 		asyncLib.eachLimit(
 			resolveResults,
 			20,
@@ -1427,7 +1475,14 @@ class FileSystemInfo {
 						});
 						break;
 					case "f":
-						resolve(context, path, {}, (err, result) => {
+						resolveCjs(context, path, {}, (err, result) => {
+							if (err) return callback(err);
+							if (result !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "e":
+						resolveEsm(context, path, {}, (err, result) => {
 							if (err) return callback(err);
 							if (result !== expectedResult) return callback(INVALID);
 							callback();