webpack 5.23.0 → 5.24.3

package/lib/CaseSensitiveModulesWarning.js

@@ -37,12 +37,12 @@ const createModulesListMessage = (modules, moduleGraph) => {
 		.map(m => {
 			let message = `* ${m.identifier()}`;
 			const validReasons = Array.from(
-				moduleGraph.getIncomingConnections(m)
-			).filter(reason => reason.originModule);
+				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
+			).filter(x => x);
 
 			if (validReasons.length > 0) {
 				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-				message += `\n    ${validReasons[0].originModule.identifier()}`;
+				message += `\n    ${validReasons[0].identifier()}`;
 			}
 			return message;
 		})

package/lib/ChunkGraph.js

@@ -69,6 +69,18 @@ const getArray = set => {
 	return Array.from(set);
 };
 
+/**
+ * @param {SortableSet<Chunk>} chunks the chunks
+ * @returns {RuntimeSpecSet} runtimes
+ */
+const getModuleRuntimes = chunks => {
+	const runtimes = new RuntimeSpecSet();
+	for (const chunk of chunks) {
+		runtimes.add(chunk.runtime);
+	}
+	return runtimes;
+};
+
 /**
  * @param {SortableSet<Module>} set the set
  * @returns {Map<string, SortableSet<Module>>} modules by source type
@@ -510,11 +522,7 @@ class ChunkGraph {
 	 */
 	getModuleRuntimes(module) {
 		const cgm = this._getChunkGraphModule(module);
-		const runtimes = new RuntimeSpecSet();
-		for (const chunk of cgm.chunks) {
-			runtimes.add(chunk.runtime);
-		}
-		return runtimes;
+		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
 	}
 
 	/**

package/lib/Compilation.js

@@ -99,6 +99,9 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
 /** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @typedef {import("./util/Hash")} Hash */
 /** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -235,9 +238,9 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean} groupAssetsByPath
  * @property {boolean} groupAssetsByExtension
  * @property {number} assetsSpace
- * @property {Function[]} excludeAssets
- * @property {Function[]} excludeModules
- * @property {Function[]} warningsFilter
+ * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
+ * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
  * @property {boolean} cachedModules
  * @property {boolean} orphanModules
  * @property {boolean} dependentModules
@@ -257,12 +260,12 @@ const { isSourceEqual } = require("./util/source");
  * @property {number} chunkModulesSpace
  * @property {number} nestedModulesSpace
  * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
- * @property {Function[]} loggingDebug
+ * @property {((value: string) => boolean)[]} loggingDebug
  * @property {boolean} loggingTrace
  * @property {any} _env
  */
 
-/** @typedef {KnownNormalizedStatsOptions & StatsOptions & Record<string, any>} NormalizedStatsOptions */
+/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
 
 /**
  * @typedef {Object} KnownCreateStatsOptionsContext
@@ -488,7 +491,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						);
 					}
 				},
-				`${name} is deprecated (use Compilation.hook.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
+				`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
 				code
 			);
 		};
@@ -1485,7 +1488,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 					for (let i = 0; i < dependencies.length; i++) {
 						const dependency = dependencies[i];
-						moduleGraph.setResolvedModule(originModule, dependency, module);
+						moduleGraph.setResolvedModule(
+							recursive ? originModule : null,
+							dependency,
+							module
+						);
 					}
 
 					moduleGraph.setIssuerIfUnset(

package/lib/Dependency.js

@@ -53,12 +53,14 @@
  * @property {(string | ExportSpec)[]=} exports nested exports
  * @property {ModuleGraphConnection=} from when reexported: from which module
  * @property {string[] | null=} export when reexported: from which export
+ * @property {boolean=} hidden export is not visible, because another export blends over it
  */
 
 /**
  * @typedef {Object} ExportsSpec
  * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
  * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
+ * @property {Set<string>=} hideExports list of maybe prior exposed, but now hidden exports
  * @property {ModuleGraphConnection=} from when reexported: from which module
  * @property {boolean=} canMangle can the export be renamed (defaults to true)
  * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts

package/lib/ExportsInfo.js

@@ -1017,6 +1017,15 @@ class ExportInfo {
 		return false;
 	}
 
+	/**
+	 * @param {any} key the key
+	 * @returns {boolean} true, if something has changed
+	 */
+	unsetTarget(key) {
+		if (!this._target) return false;
+		return this._target.delete(key);
+	}
+
 	/**
 	 * @param {any} key the key
 	 * @param {ModuleGraphConnection=} connection the target module if a single one
@@ -1223,7 +1232,7 @@ class ExportInfo {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {function({ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
 	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
 	 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
 	 */
@@ -1291,9 +1300,6 @@ class ExportInfo {
 		const target = resolveTarget(values.next().value, newAlreadyVisited);
 		if (target === CIRCULAR) return CIRCULAR;
 		if (target === null) return undefined;
-		if (this._target.size === 1) {
-			return target;
-		}
 		let result = values.next();
 		while (!result.done) {
 			const t = resolveTarget(result.value, newAlreadyVisited);
@@ -1311,15 +1317,25 @@ class ExportInfo {
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the target
+	 * @param {function({ module: Module, export: string[] | undefined }): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the resolved target when moved
 	 */
-	moveTarget(moduleGraph, resolveTargetFilter) {
+	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
 		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
 		if (target === CIRCULAR) return undefined;
 		if (!target) return undefined;
+		const originalTarget = this._target.values().next().value;
+		if (
+			originalTarget.connection === target.connection &&
+			originalTarget.export === target.export
+		) {
+			return undefined;
+		}
 		this._target.clear();
 		this._target.set(undefined, {
-			connection: target.connection,
+			connection: updateOriginalConnection
+				? updateOriginalConnection(target)
+				: target.connection,
 			export: target.export
 		});
 		return target;

package/lib/FlagDependencyExportsPlugin.js

@@ -122,6 +122,12 @@ class FlagDependencyExportsPlugin {
 									const globalTerminalBinding =
 										exportDesc.terminalBinding || false;
 									const exportDeps = exportDesc.dependencies;
+									if (exportDesc.hideExports) {
+										for (const name of exportDesc.hideExports) {
+											const exportInfo = exportsInfo.getExportInfo(name);
+											exportInfo.unsetTarget(dep);
+										}
+									}
 									if (exports === true) {
 										// unknown exports
 										if (
@@ -148,6 +154,7 @@ class FlagDependencyExportsPlugin {
 												let exports = undefined;
 												let from = globalFrom;
 												let fromExport = undefined;
+												let hidden = false;
 												if (typeof exportNameOrSpec === "string") {
 													name = exportNameOrSpec;
 												} else {
@@ -162,6 +169,8 @@ class FlagDependencyExportsPlugin {
 														from = exportNameOrSpec.from;
 													if (exportNameOrSpec.terminalBinding !== undefined)
 														terminalBinding = exportNameOrSpec.terminalBinding;
+													if (exportNameOrSpec.hidden !== undefined)
+														hidden = exportNameOrSpec.hidden;
 												}
 												const exportInfo = exportsInfo.getExportInfo(name);
 
@@ -190,11 +199,13 @@ class FlagDependencyExportsPlugin {
 
 												if (
 													from &&
-													exportInfo.setTarget(
-														dep,
-														from,
-														fromExport === undefined ? [name] : fromExport
-													)
+													(hidden
+														? exportInfo.unsetTarget(dep)
+														: exportInfo.setTarget(
+																dep,
+																from,
+																fromExport === undefined ? [name] : fromExport
+														  ))
 												) {
 													changed = true;
 												}

package/lib/Module.js

@@ -631,9 +631,11 @@ class Module extends DependenciesBlock {
 	 */
 	hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
 		// check for each reason if we need the chunk
-		for (const connection of moduleGraph.getIncomingConnections(this)) {
-			if (!connection.isTargetActive(chunk.runtime)) continue;
-			const fromModule = connection.originModule;
+		for (const [
+			fromModule,
+			connections
+		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
+			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
 			for (const originChunk of chunkGraph.getModuleChunksIterable(
 				fromModule
 			)) {

package/lib/ModuleGraph.js

@@ -8,6 +8,7 @@
 const util = require("util");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
+const SortableSet = require("./util/SortableSet");
 
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency")} Dependency */
@@ -15,7 +16,6 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleProfile")} ModuleProfile */
 /** @typedef {import("./RequestShortener")} RequestShortener */
-/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<t> */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
@@ -26,10 +26,40 @@ const ModuleGraphConnection = require("./ModuleGraphConnection");
 
 const EMPTY_ARRAY = [];
 
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} mapped by origin module
+ */
+const getConnectionsByOriginModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { originModule } = connection;
+		if (lastModule === originModule) {
+			lastList.push(connection);
+		} else {
+			lastModule = originModule;
+			const list = map.get(originModule);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(originModule, list);
+			}
+		}
+	}
+	return map;
+};
+
 class ModuleGraphModule {
 	constructor() {
-		/** @type {Set<ModuleGraphConnection>} */
-		this.incomingConnections = new Set();
+		/** @type {SortableSet<ModuleGraphConnection>} */
+		this.incomingConnections = new SortableSet();
 		/** @type {Set<ModuleGraphConnection> | undefined} */
 		this.outgoingConnections = undefined;
 		/** @type {Module | null} */
@@ -319,9 +349,6 @@ class ModuleGraph {
 					newConnections.add(newConnection);
 					if (newConnection.module !== undefined) {
 						const otherMgm = this._getModuleGraphModule(newConnection.module);
-						if (otherMgm.incomingConnections === undefined) {
-							otherMgm.incomingConnections = new Set();
-						}
 						otherMgm.incomingConnections.add(newConnection);
 					}
 				}
@@ -402,6 +429,15 @@ class ModuleGraph {
 		return connections === undefined ? EMPTY_ARRAY : connections;
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 */
+	getIncomingConnectionsByOriginModule(module) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @returns {ModuleProfile | null} the module profile

package/lib/ModuleGraphConnection.js

@@ -51,8 +51,8 @@ const intersectConnectionStates = (a, b) => {
 
 class ModuleGraphConnection {
 	/**
-	 * @param {Module|undefined} originModule the referencing module
-	 * @param {Dependency|undefined} dependency the referencing dependency
+	 * @param {Module|null} originModule the referencing module
+	 * @param {Dependency|null} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak

package/lib/MultiCompiler.js

@@ -350,6 +350,12 @@ module.exports = class MultiCompiler {
 		let errored = false;
 		let running = 0;
 		const parallelism = this._options.parallelism;
+		/**
+		 * @param {Node} node node
+		 * @param {Error=} err error
+		 * @param {Stats=} stats result
+		 * @returns {void}
+		 */
 		const nodeDone = (node, err, stats) => {
 			if (errored) return;
 			if (err) {
@@ -367,27 +373,35 @@ module.exports = class MultiCompiler {
 				);
 			}
 			node.result = stats;
+			running--;
 			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);
-					}
+			}
+			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);
 			}
+			process.nextTick(processQueue);
 		};
+		/**
+		 * @param {Node} node node
+		 * @returns {void}
+		 */
 		const nodeInvalid = node => {
-			if (node.state === "done") {
+			if (node.state === "done" || node.state === "running") {
 				node.state = "blocked";
-				for (const child of node.children) {
-					nodeInvalid(child);
-				}
+			}
+			for (const child of node.children) {
+				nodeInvalid(child);
 			}
 		};
+		/**
+		 * @param {Node} node node
+		 * @returns {void}
+		 */
 		const nodeChange = node => {
 			nodeInvalid(node);
 			if (
@@ -415,6 +429,7 @@ module.exports = class MultiCompiler {
 		const processQueue = () => {
 			while (running < parallelism && queue.length > 0 && !errored) {
 				const node = queue.dequeue();
+				if (node.state !== "queued") continue;
 				running++;
 				node.state = "running";
 				run(node.compiler, nodeDone.bind(null, node));
@@ -446,6 +461,7 @@ module.exports = class MultiCompiler {
 		if (this.running) {
 			return handler(new ConcurrentCompilationError());
 		}
+		this.running = true;
 
 		if (this.validateDependencies(handler)) {
 			const watchings = this._runGraph(
@@ -480,6 +496,7 @@ module.exports = class MultiCompiler {
 		if (this.running) {
 			return callback(new ConcurrentCompilationError());
 		}
+		this.running = true;
 
 		if (this.validateDependencies(callback)) {
 			this._runGraph(

package/lib/Watching.js

@@ -54,7 +54,6 @@ class Watching {
 		this.running = false;
 		this._initial = true;
 		this._needRecords = true;
-		this._needWatcherInfo = false;
 		this.watcher = undefined;
 		this.pausedWatcher = undefined;
 		this._done = this._done.bind(this);
@@ -84,21 +83,6 @@ class Watching {
 				});
 			}
 			this.invalid = false;
-			if (this._needWatcherInfo) {
-				this._needWatcherInfo = false;
-				const watcher = this.pausedWatcher;
-				if (watcher) {
-					this.compiler.modifiedFiles = watcher.aggregatedChanges;
-					this.compiler.removedFiles = watcher.aggregatedRemovals;
-					this.compiler.fileTimestamps = watcher.getFileTimeInfoEntries();
-					this.compiler.contextTimestamps = watcher.getContextTimeInfoEntries();
-				} else {
-					this.compiler.modifiedFiles = undefined;
-					this.compiler.removedFiles = undefined;
-					this.compiler.fileTimestamps = undefined;
-					this.compiler.contextTimestamps = undefined;
-				}
-			}
 			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
 				if (err) return this._done(err);
 				const onCompiled = (err, compilation) => {
@@ -277,6 +261,11 @@ class Watching {
 				this.compiler.contextTimestamps = contextTimeInfoEntries;
 				this.compiler.removedFiles = removedFiles;
 				this.compiler.modifiedFiles = changedFiles;
+				if (this.watcher) {
+					this.pausedWatcher = this.watcher;
+					this.watcher.pause();
+					this.watcher = null;
+				}
 				this._invalidate();
 				this._onChange();
 			},
@@ -297,7 +286,6 @@ class Watching {
 		}
 		if (!this._initial) {
 			this.compiler.hooks.invalid.call(null, Date.now());
-			this._needWatcherInfo = true;
 		}
 		this._invalidate();
 	}
@@ -309,6 +297,14 @@ class Watching {
 			return;
 		}
 		if (this.watcher) {
+			this.compiler.modifiedFiles =
+				this.watcher.getAggregatedChanges &&
+				this.watcher.getAggregatedChanges();
+			this.compiler.removedFiles =
+				this.watcher.getAggregatedRemovals &&
+				this.watcher.getAggregatedRemovals();
+			this.compiler.fileTimestamps = this.watcher.getFileTimeInfoEntries();
+			this.compiler.contextTimestamps = this.watcher.getContextTimeInfoEntries();
 			this.pausedWatcher = this.watcher;
 			this.watcher.pause();
 			this.watcher = null;
@@ -328,7 +324,6 @@ class Watching {
 	resume() {
 		if (this.suspended) {
 			this.suspended = false;
-			this._needWatcherInfo = true;
 			this._invalidate();
 		}
 	}

package/lib/WebpackOptionsApply.js

@@ -271,7 +271,7 @@ class WebpackOptionsApply extends OptionsApply {
 					),
 				entries: !lazyOptions || lazyOptions.entries !== false,
 				imports: !lazyOptions || lazyOptions.imports !== false,
-				test: lazyOptions && lazyOptions.test
+				test: (lazyOptions && lazyOptions.test) || undefined
 			}).apply(compiler);
 		}
 

package/lib/async-modules/InferAsyncModulesPlugin.js

@@ -31,14 +31,18 @@ class InferAsyncModulesPlugin {
 					}
 					for (const module of queue) {
 						moduleGraph.setAsync(module);
-						const connections = moduleGraph.getIncomingConnections(module);
-						for (const connection of connections) {
-							const dep = connection.dependency;
+						for (const [
+							originModule,
+							connections
+						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
 							if (
-								dep instanceof HarmonyImportDependency &&
-								connection.isTargetActive(undefined)
+								connections.some(
+									c =>
+										c.dependency instanceof HarmonyImportDependency &&
+										c.isTargetActive(undefined)
+								)
 							) {
-								queue.add(connection.originModule);
+								queue.add(originModule);
 							}
 						}
 					}