webpack 5.14.0 → 5.18.0

package/hot/lazy-compilation-node.js

@@ -0,0 +1,38 @@
+/* global __resourceQuery */
+
+"use strict";
+
+var urlBase = decodeURIComponent(__resourceQuery.slice(1));
+exports.keepAlive = function (options) {
+	var data = options.data;
+	var onError = options.onError;
+	var active = options.active;
+	var module = options.module;
+	var response;
+	var request = require("http").request(
+		urlBase + data,
+		{
+			agent: false,
+			headers: { accept: "text/event-stream" }
+		},
+		function (res) {
+			response = res;
+			response.on("error", errorHandler);
+			if (!active && !module.hot) {
+				console.log(
+					"Hot Module Replacement is not enabled. Waiting for process restart..."
+				);
+			}
+		}
+	);
+	function errorHandler(err) {
+		err.message =
+			"Problem communicating active modules to the server: " + err.message;
+		onError(err);
+	}
+	request.on("error", errorHandler);
+	request.end();
+	return function () {
+		response.destroy();
+	};
+};

package/hot/lazy-compilation-web.js

@@ -0,0 +1,74 @@
+/* global __resourceQuery */
+
+"use strict";
+
+if (typeof EventSource !== "function") {
+	throw new Error(
+		"Environment doesn't support lazy compilation (requires EventSource)"
+	);
+}
+
+var urlBase = decodeURIComponent(__resourceQuery.slice(1));
+var activeEventSource;
+var activeKeys = new Map();
+var errorHandlers = new Set();
+
+var updateEventSource = function updateEventSource() {
+	if (activeEventSource) activeEventSource.close();
+	if (activeKeys.size) {
+		activeEventSource = new EventSource(
+			urlBase + Array.from(activeKeys.keys()).join("@")
+		);
+		activeEventSource.onerror = function (event) {
+			errorHandlers.forEach(function (onError) {
+				onError(
+					new Error(
+						"Problem communicating active modules to the server: " +
+							event.message +
+							" " +
+							event.filename +
+							":" +
+							event.lineno +
+							":" +
+							event.colno +
+							" " +
+							event.error
+					)
+				);
+			});
+		};
+	} else {
+		activeEventSource = undefined;
+	}
+};
+
+exports.keepAlive = function (options) {
+	var data = options.data;
+	var onError = options.onError;
+	var active = options.active;
+	var module = options.module;
+	errorHandlers.add(onError);
+	var value = activeKeys.get(data) || 0;
+	activeKeys.set(data, value + 1);
+	if (value === 0) {
+		updateEventSource();
+	}
+	if (!active && !module.hot) {
+		console.log(
+			"Hot Module Replacement is not enabled. Waiting for process restart..."
+		);
+	}
+
+	return function () {
+		errorHandlers.delete(onError);
+		setTimeout(function () {
+			var value = activeKeys.get(data);
+			if (value === 1) {
+				activeKeys.delete(data);
+				updateEventSource();
+			} else {
+				activeKeys.set(data, value - 1);
+			}
+		}, 1000);
+	};
+};

package/lib/AutomaticPrefetchPlugin.js

@@ -29,12 +29,16 @@ class AutomaticPrefetchPlugin {
 		);
 		let lastModules = null;
 		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
-			lastModules = Array.from(compilation.modules)
-				.filter(m => m instanceof NormalModule)
-				.map((/** @type {NormalModule} */ m) => ({
-					context: m.context,
-					request: m.request
-				}));
+			lastModules = [];
+
+			for (const m of compilation.modules) {
+				if (m instanceof NormalModule) {
+					lastModules.push({
+						context: m.context,
+						request: m.request
+					});
+				}
+			}
 		});
 		compiler.hooks.make.tapAsync(
 			"AutomaticPrefetchPlugin",
@@ -49,7 +53,10 @@ class AutomaticPrefetchPlugin {
 							callback
 						);
 					},
-					callback
+					err => {
+						lastModules = null;
+						callback(err);
+					}
 				);
 			}
 		);

package/lib/CacheFacade.js

@@ -36,6 +36,7 @@ class MultiItemCache {
 	 */
 	constructor(items) {
 		this._items = items;
+		if (items.length === 1) return /** @type {any} */ (items[0]);
 	}
 
 	/**

package/lib/ChunkGraph.js

@@ -8,6 +8,7 @@
 const util = require("util");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const SortableSet = require("./util/SortableSet");
+const StringXor = require("./util/StringXor");
 const {
 	compareModulesById,
 	compareIterables,
@@ -16,12 +17,14 @@ const {
 	compareSelect,
 	compareIds
 } = require("./util/comparators");
+const createHash = require("./util/createHash");
 const findGraphRoots = require("./util/findGraphRoots");
 const {
 	RuntimeSpecMap,
 	RuntimeSpecSet,
 	runtimeToString,
-	mergeRuntime
+	mergeRuntime,
+	forEachRuntime
 } = require("./util/runtime");
 
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -47,11 +50,12 @@ const compareModuleIterables = compareIterables(compareModulesByIdentifier);
  * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
  */
 
-/**
- * @typedef {Object} ModuleHashInfo
- * @property {string} hash
- * @property {string} renderedHash
- */
+class ModuleHashInfo {
+	constructor(hash, renderedHash) {
+		this.hash = hash;
+		this.renderedHash = renderedHash;
+	}
+}
 
 /** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
 
@@ -170,6 +174,10 @@ class ChunkGraphModule {
 		this.id = null;
 		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
 		this.runtimeRequirements = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashes = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashesWithConnections = undefined;
 	}
 }
 
@@ -1096,6 +1104,15 @@ class ChunkGraph {
 		return cgc.fullHashModules;
 	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<RuntimeModule> | undefined} set of modules (do not modify)
+	 */
+	getChunkFullHashModulesSet(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules;
+	}
+
 	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
 
 	/**
@@ -1174,14 +1191,20 @@ class ChunkGraph {
 	}
 
 	/**
+	 * @template T
 	 * @param {Module} module the module
+	 * @param {RuntimeSpecMap<T>} hashes hashes data
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ModuleHashInfo} hash
-	 */
-	_getModuleHashInfo(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		if (hashes && runtime === undefined) {
+	 * @returns {T} hash
+	 */
+	_getModuleHashInfo(module, hashes, runtime) {
+		if (!hashes) {
+			throw new Error(
+				`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
+					runtime
+				)} (hashes not set at all)`
+			);
+		} else if (runtime === undefined) {
 			const hashInfoItems = new Set(hashes.values());
 			if (hashInfoItems.size !== 1) {
 				throw new Error(
@@ -1194,14 +1217,15 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			}
 			return hashInfoItems.values().next().value;
 		} else {
-			const hashInfo = hashes && hashes.get(runtime);
+			const hashInfo = hashes.get(runtime);
 			if (!hashInfo) {
 				throw new Error(
 					`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
 						runtime
-					)} (available runtimes ${
-						hashes && Array.from(hashes.keys(), runtimeToString).join(", ")
-					})`
+					)} (available runtimes ${Array.from(
+						hashes.keys(),
+						runtimeToString
+					).join(", ")})`
 				);
 			}
 			return hashInfo;
@@ -1225,7 +1249,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {string} hash
 	 */
 	getModuleHash(module, runtime) {
-		return this._getModuleHashInfo(module, runtime).hash;
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).hash;
 	}
 
 	/**
@@ -1234,7 +1260,9 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {string} hash
 	 */
 	getRenderedModuleHash(module, runtime) {
-		return this._getModuleHashInfo(module, runtime).renderedHash;
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
 	}
 
 	/**
@@ -1249,7 +1277,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		if (cgm.hashes === undefined) {
 			cgm.hashes = new RuntimeSpecMap();
 		}
-		cgm.hashes.set(runtime, { hash, renderedHash });
+		cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
 	}
 
 	/**
@@ -1331,6 +1359,91 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
 	}
 
+	getModuleGraphHash(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		if (cgm.graphHashes === undefined) {
+			cgm.graphHashes = new RuntimeSpecMap();
+		}
+		const graphHash = cgm.graphHashes.provide(runtime, () => {
+			const hash = createHash("md4");
+			hash.update(`${cgm.id}`);
+			hash.update(`${this.moduleGraph.isAsync(module)}`);
+			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
+			return /** @type {string} */ (hash.digest("hex"));
+		});
+		if (!withConnections) return graphHash;
+		if (cgm.graphHashesWithConnections === undefined) {
+			cgm.graphHashesWithConnections = new RuntimeSpecMap();
+		}
+		const activeStateToString = state => {
+			if (state === false) return "false";
+			if (state === true) return "true";
+			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "transitive";
+			throw new Error("Not implemented active state");
+		};
+		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
+		return cgm.graphHashesWithConnections.provide(runtime, () => {
+			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Map<string, Module | Set<Module>>} */
+			const connectedModules = new Map();
+			for (const connection of connections) {
+				let stateInfo;
+				if (typeof runtime === "string") {
+					const state = connection.getActiveState(runtime);
+					if (state === false) continue;
+					stateInfo = activeStateToString(state);
+				} else {
+					const states = new Set();
+					stateInfo = "";
+					forEachRuntime(
+						runtime,
+						runtime => {
+							const state = connection.getActiveState(runtime);
+							states.add(state);
+							stateInfo += runtime + activeStateToString(state);
+						},
+						true
+					);
+					if (states.size === 1) {
+						const state = states.values().next().value;
+						if (state === false) continue;
+						stateInfo = activeStateToString(state);
+					}
+				}
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				const oldModule = connectedModules.get(stateInfo);
+				if (oldModule === undefined) {
+					connectedModules.set(stateInfo, module);
+				} else if (oldModule instanceof Set) {
+					oldModule.add(module);
+				} else if (oldModule !== module) {
+					connectedModules.set(stateInfo, new Set([oldModule, module]));
+				}
+			}
+			if (connectedModules.size === 0) return graphHash;
+			const connectedModulesInOrder =
+				connectedModules.size > 1
+					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
+					: connectedModules;
+			const hash = createHash("md4");
+			for (const [stateInfo, modules] of connectedModulesInOrder) {
+				hash.update(stateInfo);
+				if (modules instanceof Set) {
+					const xor = new StringXor();
+					for (const m of modules) {
+						xor.add(this.getModuleGraphHash(m, runtime, false));
+					}
+					xor.updateHash(hash);
+				} else {
+					hash.update(this.getModuleGraphHash(modules, runtime, false));
+				}
+			}
+			hash.update(graphHash);
+			return /** @type {string} */ (hash.digest("hex"));
+		});
+	}
+
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @returns {ReadonlySet<string>} runtime requirements

package/lib/CodeGenerationResults.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { provide } = require("./util/MapHelpers");
+const createHash = require("./util/createHash");
 const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -16,6 +18,8 @@ class CodeGenerationResults {
 	constructor() {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
+		/** @type {Map<Module, RuntimeSpecMap<string>>} */
+		this.hashes = new Map();
 	}
 
 	/**
@@ -61,6 +65,24 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		}
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {boolean} true, when we have data for this
+	 */
+	has(module, runtime) {
+		const entry = this.map.get(module);
+		if (entry === undefined) {
+			return false;
+		}
+		if (runtime === undefined) {
+			const results = new Set(entry.values());
+			return results.size === 1;
+		} else {
+			return entry.has(runtime);
+		}
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
@@ -91,6 +113,25 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		return data === undefined ? undefined : data.get(key);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {any} hash of the code generation
+	 */
+	getHash(module, runtime) {
+		const info = this.get(module, runtime);
+		if (info.hash !== undefined) return info.hash;
+		const hash = createHash("md4");
+		for (const [type, source] of info.sources) {
+			hash.update(type);
+			source.updateHash(hash);
+		}
+		if (info.runtimeRequirements) {
+			for (const rr of info.runtimeRequirements) hash.update(rr);
+		}
+		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime runtime(s)
@@ -98,14 +139,8 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {void}
 	 */
 	add(module, runtime, result) {
-		const map = this.map.get(module);
-		if (map !== undefined) {
-			map.set(runtime, result);
-		} else {
-			const newMap = new RuntimeSpecMap();
-			newMap.set(runtime, result);
-			this.map.set(module, newMap);
-		}
+		const map = provide(this.map, module, () => new RuntimeSpecMap());
+		map.set(runtime, result);
 	}
 }