webpack 5.21.0 → 5.23.0

package/lib/MultiCompiler.js

@@ -11,6 +11,7 @@ const { SyncHook, MultiHook } = require("tapable");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 const MultiStats = require("./MultiStats");
 const MultiWatching = require("./MultiWatching");
+const ArrayQueue = require("./util/ArrayQueue");
 
 /** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
 /** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
@@ -23,12 +24,6 @@ const MultiWatching = require("./MultiWatching");
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
-/** @typedef {number} CompilerStatus */
-
-const STATUS_PENDING = 0;
-const STATUS_DONE = 1;
-const STATUS_NEW = 2;
-
 /**
  * @template T
  * @callback Callback
@@ -42,11 +37,17 @@ const STATUS_NEW = 2;
  * @param {Callback<MultiStats>} callback
  */
 
+/**
+ * @typedef {Object} MultiCompilerOptions
+ * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
+ */
+
 module.exports = class MultiCompiler {
 	/**
 	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
+	 * @param {MultiCompilerOptions} options options
 	 */
-	constructor(compilers) {
+	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
 			compilers = Object.keys(compilers).map(name => {
 				compilers[name].name = name;
@@ -71,6 +72,10 @@ module.exports = class MultiCompiler {
 			)
 		});
 		this.compilers = compilers;
+		/** @type {MultiCompilerOptions} */
+		this._options = {
+			parallelism: options.parallelism || Infinity
+		};
 		/** @type {WeakMap<Compiler, string[]>} */
 		this.dependencies = new WeakMap();
 		this.running = false;
@@ -104,7 +109,10 @@ module.exports = class MultiCompiler {
 	}
 
 	get options() {
-		return this.compilers.map(c => c.options);
+		return Object.assign(
+			this.compilers.map(c => c.options),
+			this._options
+		);
 	}
 
 	get outputPath() {
@@ -257,7 +265,9 @@ module.exports = class MultiCompiler {
 		return true;
 	}
 
+	// TODO webpack 6 remove
 	/**
+	 * @deprecated This method should have been private
 	 * @param {Compiler[]} compilers the child compilers
 	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
 	 * @param {Callback<MultiStats>} callback the compiler's handler
@@ -300,6 +310,133 @@ module.exports = class MultiCompiler {
 		runCompilers(callback);
 	}
 
+	/**
+	 * @template SetupResult
+	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
+	 * @param {function(Compiler, Callback<Stats>): void} run run/continue a single compiler
+	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
+	 * @returns {SetupResult[]} result of setup
+	 */
+	_runGraph(setup, run, callback) {
+		/** @typedef {{ compiler: Compiler, result: Stats, state: "blocked" | "queued" | "running" | "done", children: Node[], parents: Node[] }} Node */
+
+		/** @type {Node[]} */
+		const nodes = this.compilers.map(compiler => ({
+			compiler,
+			result: undefined,
+			state: "blocked",
+			children: [],
+			parents: []
+		}));
+		/** @type {Map<string, Node>} */
+		const compilerToNode = new Map();
+		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
+		for (const node of nodes) {
+			const dependencies = this.dependencies.get(node.compiler);
+			if (!dependencies) continue;
+			for (const dep of dependencies) {
+				const parent = compilerToNode.get(dep);
+				node.parents.push(parent);
+				parent.children.push(node);
+			}
+		}
+		const queue = new ArrayQueue();
+		for (const node of nodes) {
+			if (node.parents.length === 0) {
+				node.state = "queued";
+				queue.enqueue(node);
+			}
+		}
+		let errored = false;
+		let running = 0;
+		const parallelism = this._options.parallelism;
+		const nodeDone = (node, err, stats) => {
+			if (errored) return;
+			if (err) {
+				errored = true;
+				return asyncLib.each(
+					nodes,
+					(node, callback) => {
+						if (node.compiler.watching) {
+							node.compiler.watching.close(callback);
+						} else {
+							callback();
+						}
+					},
+					() => callback(err)
+				);
+			}
+			node.result = stats;
+			if (node.state === "running") {
+				running--;
+				node.state = "done";
+				for (const child of node.children) {
+					if (child.state !== "blocked") continue;
+					if (child.parents.every(p => p.state === "done")) {
+						child.state = "queued";
+						queue.enqueue(child);
+					}
+				}
+				process.nextTick(processQueue);
+			}
+		};
+		const nodeInvalid = node => {
+			if (node.state === "done") {
+				node.state = "blocked";
+				for (const child of node.children) {
+					nodeInvalid(child);
+				}
+			}
+		};
+		const nodeChange = node => {
+			nodeInvalid(node);
+			if (
+				node.state === "blocked" &&
+				node.parents.every(p => p.state === "done")
+			) {
+				node.state = "queued";
+				queue.enqueue(node);
+				processQueue();
+			}
+		};
+		const setupResults = [];
+		nodes.forEach((node, i) => {
+			setupResults.push(
+				setup(
+					node.compiler,
+					i,
+					nodeDone.bind(null, node),
+					() => node.state === "blocked" || node.state === "queued",
+					() => nodeChange(node),
+					() => nodeInvalid(node)
+				)
+			);
+		});
+		const processQueue = () => {
+			while (running < parallelism && queue.length > 0 && !errored) {
+				const node = queue.dequeue();
+				running++;
+				node.state = "running";
+				run(node.compiler, nodeDone.bind(null, node));
+			}
+			if (!errored && running === 0) {
+				const stats = [];
+				for (const node of nodes) {
+					const result = node.result;
+					if (result) {
+						node.result = undefined;
+						stats.push(result);
+					}
+				}
+				if (stats.length > 0) {
+					callback(null, new MultiStats(stats));
+				}
+			}
+		};
+		processQueue();
+		return setupResults;
+	}
+
 	/**
 	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
 	 * @param {Callback<MultiStats>} handler signals when the call finishes
@@ -310,55 +447,29 @@ module.exports = class MultiCompiler {
 			return handler(new ConcurrentCompilationError());
 		}
 
-		/** @type {Watching[]} */
-		const watchings = [];
-
-		/** @type {Stats[]} */
-		const allStats = this.compilers.map(() => null);
-
-		/** @type {CompilerStatus[]} */
-		const compilerStatus = this.compilers.map(() => STATUS_PENDING);
-
 		if (this.validateDependencies(handler)) {
-			this.running = true;
-			this.runWithDependencies(
-				this.compilers,
-				(compiler, callback) => {
-					const compilerIdx = this.compilers.indexOf(compiler);
-					let firstRun = true;
-					let watching = compiler.watch(
-						Array.isArray(watchOptions)
-							? watchOptions[compilerIdx]
-							: watchOptions,
-						(err, stats) => {
-							if (err) handler(err);
-							if (stats) {
-								allStats[compilerIdx] = stats;
-								compilerStatus[compilerIdx] = STATUS_NEW;
-								if (compilerStatus.every(status => status !== STATUS_PENDING)) {
-									const freshStats = allStats.filter((s, idx) => {
-										return compilerStatus[idx] === STATUS_NEW;
-									});
-									compilerStatus.fill(STATUS_DONE);
-									const multiStats = new MultiStats(freshStats);
-									handler(null, multiStats);
-								}
-							}
-							if (firstRun && !err) {
-								firstRun = false;
-								callback();
-							}
-						}
+			const watchings = this._runGraph(
+				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
+					const watching = compiler.watch(
+						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
+						callback
 					);
-					watchings.push(watching);
+					if (watching) {
+						watching._onInvalid = setInvalid;
+						watching._onChange = setChanged;
+						watching._isBlocked = isBlocked;
+					}
+					return watching;
 				},
-				() => {
-					// ignore
-				}
+				(compiler, initial, callback) => {
+					if (!compiler.watching.running) compiler.watching.invalidate();
+				},
+				handler
 			);
+			return new MultiWatching(watchings, this);
 		}
 
-		return new MultiWatching(watchings, this);
+		return new MultiWatching([], this);
 	}
 
 	/**
@@ -370,34 +481,16 @@ module.exports = class MultiCompiler {
 			return callback(new ConcurrentCompilationError());
 		}
 
-		const finalCallback = (err, stats) => {
-			this.running = false;
-
-			if (callback !== undefined) {
-				return callback(err, stats);
-			}
-		};
-
-		const allStats = this.compilers.map(() => null);
 		if (this.validateDependencies(callback)) {
-			this.running = true;
-			this.runWithDependencies(
-				this.compilers,
-				(compiler, callback) => {
-					const compilerIdx = this.compilers.indexOf(compiler);
-					compiler.run((err, stats) => {
-						if (err) {
-							return callback(err);
-						}
-						allStats[compilerIdx] = stats;
-						callback();
-					});
-				},
-				err => {
-					if (err) {
-						return finalCallback(err);
+			this._runGraph(
+				() => {},
+				(compiler, callback) => compiler.run(callback),
+				(err, stats) => {
+					this.running = false;
+
+					if (callback !== undefined) {
+						return callback(err, stats);
 					}
-					finalCallback(null, new MultiStats(allStats));
 				}
 			);
 		}

package/lib/MultiStats.js

@@ -47,17 +47,20 @@ class MultiStats {
 		if (!options) {
 			options = {};
 		}
-		const { children: _, ...baseOptions } = options;
+		const { children: childrenOptions = undefined, ...baseOptions } =
+			typeof options === "string" ? { preset: options } : options;
 		const children = this.stats.map((stat, idx) => {
-			const childOptions = Array.isArray(options.children)
-				? options.children[idx]
-				: options.children;
+			const childOptions = Array.isArray(childrenOptions)
+				? childrenOptions[idx]
+				: childrenOptions;
 			return stat.compilation.createStatsOptions(
 				{
 					...baseOptions,
-					...(childOptions && typeof childOptions === "object"
+					...(typeof childOptions === "string"
+						? { preset: childOptions }
+						: childOptions && typeof childOptions === "object"
 						? childOptions
-						: { preset: childOptions })
+						: undefined)
 				},
 				context
 			);

package/lib/NormalModuleFactory.js

@@ -750,35 +750,148 @@ class NormalModuleFactory extends ModuleFactory {
 			resolveContext,
 			(err, resolvedResource, resolvedResourceResolveData) => {
 				if (err) {
-					if (resolver.options.fullySpecified) {
-						resolver
-							.withOptions({
-								fullySpecified: false
-							})
-							.resolve(
-								contextInfo,
-								context,
-								unresolvedResource,
-								resolveContext,
-								(err2, resolvedResource) => {
-									if (!err2 && resolvedResource) {
-										const resource = parseResource(
-											resolvedResource
-										).path.replace(/^.*[\\/]/, "");
-										err.message += `
-Did you mean '${resource}'?
+					return this._resolveResourceErrorHints(
+						err,
+						contextInfo,
+						context,
+						unresolvedResource,
+						resolver,
+						resolveContext,
+						(err2, hints) => {
+							if (err2) {
+								err.message += `
+An fatal error happened during resolving additional hints for this error: ${err2.message}`;
+								err.stack += `
+
+An fatal error happened during resolving additional hints for this error:
+${err2.stack}`;
+								return callback(err);
+							}
+							if (hints && hints.length > 0) {
+								err.message += `
+${hints.join("\n\n")}`;
+							}
+							callback(err);
+						}
+					);
+				}
+				callback(err, resolvedResource, resolvedResourceResolveData);
+			}
+		);
+	}
+
+	_resolveResourceErrorHints(
+		error,
+		contextInfo,
+		context,
+		unresolvedResource,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		asyncLib.parallel(
+			[
+				callback => {
+					if (!resolver.options.fullySpecified) return callback();
+					resolver
+						.withOptions({
+							fullySpecified: false
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									const resource = parseResource(resolvedResource).path.replace(
+										/^.*[\\/]/,
+										""
+									);
+									return callback(
+										null,
+										`Did you mean '${resource}'?
 BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
 (probably because the origin is a '*.mjs' file or a '*.js' file where the package.json contains '"type": "module"').
 The extension in the request is mandatory for it to be fully specified.
-Add the extension to the request.`;
+Add the extension to the request.`
+									);
+								}
+								callback();
+							}
+						);
+				},
+				callback => {
+					if (!resolver.options.enforceExtension) return callback();
+					resolver
+						.withOptions({
+							enforceExtension: false,
+							extensions: []
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									let hint = "";
+									const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
+									if (match) {
+										const fixedRequest = unresolvedResource.replace(
+											/(\.[^.]+)(\?|$)/,
+											"$2"
+										);
+										if (resolver.options.extensions.has(match[1])) {
+											hint = `Did you mean '${fixedRequest}'?`;
+										} else {
+											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
+										}
+									} else {
+										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
 									}
-									callback(err);
+									return callback(
+										null,
+										`The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
+${hint}
+Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`
+									);
 								}
-							);
-						return;
+								callback();
+							}
+						);
+				},
+				callback => {
+					if (
+						/^\.\.?\//.test(unresolvedResource) ||
+						resolver.options.preferRelative
+					) {
+						return callback();
 					}
+					resolver.resolve(
+						contextInfo,
+						context,
+						`./${unresolvedResource}`,
+						resolveContext,
+						(err, resolvedResource) => {
+							if (err || !resolvedResource) return callback();
+							const moduleDirectories = resolver.options.modules
+								.map(m => (Array.isArray(m) ? m.join(", ") : m))
+								.join(", ");
+							callback(
+								null,
+								`Did you mean './${unresolvedResource}'?
+Requests that should resolve in the current directory need to start with './'.
+Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
+If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`
+							);
+						}
+					);
 				}
-				callback(err, resolvedResource, resolvedResourceResolveData);
+			],
+			(err, hints) => {
+				if (err) return callback(err);
+				callback(null, hints.filter(Boolean));
 			}
 		);
 	}

package/lib/RuntimeGlobals.js

@@ -304,6 +304,11 @@ exports.systemContext = "__webpack_require__.y";
  */
 exports.baseURI = "__webpack_require__.b";
 
+/**
+ * a RelativeURL class when relative URLs are used
+ */
+exports.relativeUrl = "__webpack_require__.U";
+
 /**
  * Creates an async module. The body function must be a async function.
  * "module.exports" will be decorated with an AsyncModulePromise.

package/lib/RuntimePlugin.js

@@ -22,6 +22,7 @@ const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModu
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
 const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule");
+const RelativeUrlRuntimeModule = require("./runtime/RelativeUrlRuntimeModule");
 const RuntimeIdRuntimeModule = require("./runtime/RuntimeIdRuntimeModule");
 const SystemContextRuntimeModule = require("./runtime/SystemContextRuntimeModule");
 const ShareRuntimeModule = require("./sharing/ShareRuntimeModule");
@@ -48,6 +49,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.interceptModuleExecution,
 	RuntimeGlobals.publicPath,
 	RuntimeGlobals.baseURI,
+	RuntimeGlobals.relativeUrl,
 	RuntimeGlobals.scriptNonce,
 	RuntimeGlobals.uncaughtErrorHandler,
 	RuntimeGlobals.asyncModule,
@@ -55,7 +57,8 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.instantiateWasm,
 	RuntimeGlobals.shareScopeMap,
 	RuntimeGlobals.initializeSharing,
-	RuntimeGlobals.loadScript
+	RuntimeGlobals.loadScript,
+	RuntimeGlobals.systemContext
 ];
 
 const MODULE_DEPENDENCIES = {
@@ -312,6 +315,12 @@ class RuntimePlugin {
 					compilation.addRuntimeModule(chunk, new LoadScriptRuntimeModule());
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.relativeUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule());
+					return true;
+				});
 			// TODO webpack 6: remove CompatRuntimeModule
 			compilation.hooks.additionalTreeRuntimeRequirements.tap(
 				"RuntimePlugin",