webpack 5.17.0 → 5.18.0

package/lib/Module.js

@@ -67,6 +67,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {Map<string, Source>} sources the resulting sources for all source types
  * @property {Map<string, any>=} data the resulting data for all source types
  * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
  */
 
 /**
@@ -703,9 +704,7 @@ class Module extends DependenciesBlock {
 		}
 	) {
 		const { chunkGraph, runtime } = context;
-		hash.update(`${chunkGraph.getModuleId(this)}`);
-		const exportsInfo = chunkGraph.moduleGraph.getExportsInfo(this);
-		exportsInfo.updateHash(hash, runtime);
+		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
 		if (this.presentationalDependencies !== undefined) {
 			for (const dep of this.presentationalDependencies) {
 				dep.updateHash(hash, context);

package/lib/Template.js

@@ -349,34 +349,43 @@ class Template {
 
 	/**
 	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext} renderContext render context
+	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
 	 * @returns {Source} rendered runtime modules in a Source object
 	 */
 	static renderRuntimeModules(runtimeModules, renderContext) {
 		const source = new ConcatSource();
 		for (const module of runtimeModules) {
-			const codeGenResult = module.codeGeneration({
-				chunkGraph: renderContext.chunkGraph,
-				dependencyTemplates: renderContext.dependencyTemplates,
-				moduleGraph: renderContext.moduleGraph,
-				runtimeTemplate: renderContext.runtimeTemplate,
-				runtime: renderContext.chunk.runtime
-			});
-			if (codeGenResult) {
-				const moduleSource = codeGenResult.sources.get("runtime");
-				if (moduleSource) {
-					source.add(Template.toNormalComment(module.identifier()) + "\n");
-					if (!module.shouldIsolate()) {
-						source.add(moduleSource);
-					} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-						source.add("(() => {\n");
-						source.add(new PrefixSource("\t", moduleSource));
-						source.add("\n})();\n\n");
-					} else {
-						source.add("!function() {\n");
-						source.add(new PrefixSource("\t", moduleSource));
-						source.add("\n}();\n\n");
-					}
+			const codeGenerationResults = renderContext.codeGenerationResults;
+			let runtimeSource;
+			if (codeGenerationResults) {
+				runtimeSource = codeGenerationResults.getSource(
+					module,
+					renderContext.chunk.runtime,
+					"runtime"
+				);
+			} else {
+				const codeGenResult = module.codeGeneration({
+					chunkGraph: renderContext.chunkGraph,
+					dependencyTemplates: renderContext.dependencyTemplates,
+					moduleGraph: renderContext.moduleGraph,
+					runtimeTemplate: renderContext.runtimeTemplate,
+					runtime: renderContext.chunk.runtime
+				});
+				if (!codeGenResult) continue;
+				runtimeSource = codeGenResult.sources.get("runtime");
+			}
+			if (runtimeSource) {
+				source.add(Template.toNormalComment(module.identifier()) + "\n");
+				if (!module.shouldIsolate()) {
+					source.add(runtimeSource);
+				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+					source.add("(() => {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n})();\n\n");
+				} else {
+					source.add("!function() {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n}();\n\n");
 				}
 			}
 		}

package/lib/dependencies/ExportsInfoDependency.js

@@ -83,26 +83,6 @@ class ExportsInfoDependency extends NullDependency {
 		this.property = property;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		const { moduleGraph } = chunkGraph;
-		const module = moduleGraph.getParentModule(this);
-		const value = getProperty(
-			moduleGraph,
-			module,
-			this.exportName,
-			this.property,
-			runtime
-		);
-		hash.update(value === undefined ? "undefined" : JSON.stringify(value));
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.range);

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -680,35 +680,6 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		return errors;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		super.updateHash(hash, context);
-
-		const mode = this.getMode(chunkGraph.moduleGraph, runtime);
-
-		hash.update(mode.type);
-		if (mode.items) {
-			for (const item of mode.items) {
-				hash.update(item.name);
-				hash.update(item.ids.join());
-				if (item.checked) hash.update("checked");
-			}
-		}
-		if (mode.ignored) {
-			hash.update("ignored");
-			for (const k of mode.ignored) {
-				hash.update(k);
-			}
-		}
-		hash.update(mode.name || "");
-	}
-
 	serialize(context) {
 		const { write } = context;
 

package/lib/dependencies/HarmonyImportDependency.js

@@ -196,47 +196,6 @@ class HarmonyImportDependency extends ModuleDependency {
 		}
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime, runtimeTemplate } = context;
-		const { moduleGraph } = chunkGraph;
-		super.updateHash(hash, context);
-		hash.update(`${this.sourceOrder}`);
-		const connection = moduleGraph.getConnection(this);
-		if (connection) {
-			const importedModule = connection.module;
-			if (importedModule) {
-				const parentModule = moduleGraph.getParentModule(this);
-				hash.update(
-					importedModule.getExportsType(
-						moduleGraph,
-						parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
-					)
-				);
-				if (moduleGraph.isAsync(importedModule)) hash.update("async");
-			}
-			if (runtimeTemplate) {
-				const runtimeRequirements = new Set();
-				hash.update(
-					runtimeTemplate.runtimeConditionExpression({
-						chunkGraph,
-						runtimeCondition: filterRuntime(runtime, runtime => {
-							return connection.isTargetActive(runtime);
-						}),
-						runtime,
-						runtimeRequirements
-					})
-				);
-				for (const rr of runtimeRequirements) hash.update(rr);
-			}
-		}
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.sourceOrder);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -181,25 +181,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return 0;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		super.updateHash(hash, context);
-		const moduleGraph = chunkGraph.moduleGraph;
-		const importedModule = moduleGraph.getModule(this);
-		const ids = this.getIds(moduleGraph);
-		hash.update(ids.join());
-		if (importedModule) {
-			const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-			hash.update(`${exportsInfo.getUsedName(ids, runtime)}`);
-		}
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.ids);

package/lib/dependencies/JsonExportsDependency.js

@@ -73,7 +73,6 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		hash.update(this.exports ? JSON.stringify(this.exports) : "undefined");
-		super.updateHash(hash, context);
 	}
 
 	serialize(context) {

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -69,7 +69,6 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		super.updateHash(hash, context);
 		hash.update(this.decorator);
 		hash.update(`${this.allowExportsAccess}`);
 	}

package/lib/dependencies/NullDependency.js

@@ -20,14 +20,6 @@ class NullDependency extends Dependency {
 		return "null";
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {}
-
 	serialize({ write }) {
 		write(this.loc);
 	}

package/lib/dependencies/ProvidedDependency.js

@@ -51,7 +51,6 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		super.updateHash(hash, context);
 		hash.update(this.identifier);
 		hash.update(this.path ? this.path.join(",") : "null");
 	}

package/lib/dependencies/StaticExportsDependency.js

@@ -43,18 +43,6 @@ class StaticExportsDependency extends NullDependency {
 		};
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(JSON.stringify(this.exports));
-		if (this.canMangle) hash.update("canMangle");
-		super.updateHash(hash, context);
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.exports);

package/lib/optimize/ConcatenatedModule.js

@@ -1650,18 +1650,6 @@ ${defineGetters}`
 		}
 	}
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {DependencyTemplates} dependencyTemplates dependency templates
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	_getHashDigest(chunkGraph, dependencyTemplates, runtime) {
-		const hash = chunkGraph.getModuleHash(this, runtime);
-		const dtHash = dependencyTemplates.getHash();
-		return `${hash}-${dtHash}`;
-	}
-
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {RuntimeSpec} runtime the runtime

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -48,6 +48,7 @@ const NAMED_PRESETS = {
 		runtimeModules: true,
 		exclude: false,
 		modulesSpace: Infinity,
+		chunkModulesSpace: Infinity,
 		assetsSpace: Infinity,
 		children: true
 	},

package/lib/util/MapHelpers.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map a map
+ * @param {K} key the key
+ * @param {function(): V} computer compute value
+ * @returns {V} value
+ */
+exports.provide = (map, key, computer) => {
+	const value = map.get(key);
+	if (value !== undefined) return value;
+	const newValue = computer();
+	map.set(key, newValue);
+	return newValue;
+};

package/lib/util/createHash.js

@@ -7,9 +7,11 @@
 
 const Hash = require("./Hash");
 
-const BULK_SIZE = 1000;
+const BULK_SIZE = 2000;
 
-const digestCache = new Map();
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
 
 class BulkUpdateDecorator extends Hash {
 	/**
@@ -64,11 +66,15 @@ class BulkUpdateDecorator extends Hash {
 	 * @returns {string|Buffer} digest
 	 */
 	digest(encoding) {
-		let cacheKey;
+		let digestCache;
 		if (this.hash === undefined) {
 			// short data for hash, we can use caching
-			cacheKey = `${this.hashKey}-${encoding}-${this.buffer}`;
-			const cacheEntry = digestCache.get(cacheKey);
+			const cacheKey = `${this.hashKey}-${encoding}`;
+			digestCache = digestCaches[cacheKey];
+			if (digestCache === undefined) {
+				digestCache = digestCaches[cacheKey] = new Map();
+			}
+			const cacheEntry = digestCache.get(this.buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
 			this.hash = this.hashFactory();
 		}
@@ -78,8 +84,8 @@ class BulkUpdateDecorator extends Hash {
 		const digestResult = this.hash.digest(encoding);
 		const result =
 			typeof digestResult === "string" ? digestResult : digestResult.toString();
-		if (cacheKey !== undefined) {
-			digestCache.set(cacheKey, result);
+		if (digestCache !== undefined) {
+			digestCache.set(this.buffer, result);
 		}
 		return result;
 	}

package/lib/util/runtime.js

@@ -54,14 +54,16 @@ exports.getEntryRuntime = (compilation, name, options) => {
 /**
  * @param {RuntimeSpec} runtime runtime
  * @param {function(string): void} fn functor
+ * @param {boolean} deterministicOrder enforce a deterministic order
  * @returns {void}
  */
-exports.forEachRuntime = (runtime, fn) => {
+exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 	if (runtime === undefined) {
 		fn(undefined);
 	} else if (typeof runtime === "string") {
 		fn(runtime);
 	} else {
+		if (deterministicOrder) runtime.sort();
 		for (const r of runtime) {
 			fn(r);
 		}
@@ -448,6 +450,15 @@ class RuntimeSpecMap {
 		this._map.set(getRuntimeKey(runtime), value);
 	}
 
+	provide(runtime, computer) {
+		const key = getRuntimeKey(runtime);
+		const value = this._map.get(key);
+		if (value !== undefined) return value;
+		const newValue = computer();
+		this._map.set(key, newValue);
+		return newValue;
+	}
+
 	delete(runtime) {
 		this._map.delete(getRuntimeKey(runtime));
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.17.0",
+  "version": "5.18.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",

package/types.d.ts

@@ -799,6 +799,9 @@ declare class ChunkGraph {
 	getChunkFullHashModulesIterable(
 		chunk: Chunk
 	): undefined | Iterable<RuntimeModule>;
+	getChunkFullHashModulesSet(
+		chunk: Chunk
+	): undefined | ReadonlySet<RuntimeModule>;
 	getChunkEntryModulesWithChunkGroupIterable(
 		chunk: Chunk
 	): Iterable<[Module, undefined | Entrypoint]>;
@@ -833,6 +836,11 @@ declare class ChunkGraph {
 		runtime: RuntimeSpec
 	): ReadonlySet<string>;
 	getChunkRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;
+	getModuleGraphHash(
+		module?: any,
+		runtime?: any,
+		withConnections?: boolean
+	): any;
 	getTreeRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;
 	static getChunkGraphForModule(
 		module: Module,
@@ -1063,16 +1071,24 @@ declare interface CodeGenerationResult {
 	 * the runtime requirements
 	 */
 	runtimeRequirements: ReadonlySet<string>;
+
+	/**
+	 * a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
+	 */
+	hash?: string;
 }
 declare abstract class CodeGenerationResults {
 	map: Map<Module, RuntimeSpecMap<CodeGenerationResult>>;
+	hashes: Map<Module, RuntimeSpecMap<string>>;
 	get(module: Module, runtime: RuntimeSpec): CodeGenerationResult;
+	has(module: Module, runtime: RuntimeSpec): boolean;
 	getSource(module: Module, runtime: RuntimeSpec, sourceType: string): Source;
 	getRuntimeRequirements(
 		module: Module,
 		runtime: RuntimeSpec
 	): ReadonlySet<string>;
 	getData(module: Module, runtime: RuntimeSpec, key: string): any;
+	getHash(module: Module, runtime: RuntimeSpec): any;
 	add(module: Module, runtime: RuntimeSpec, result: CodeGenerationResult): void;
 }
 type CodeValue =
@@ -1437,7 +1453,12 @@ declare class Compilation {
 	sortItemsWithChunkIds(): void;
 	summarizeDependencies(): void;
 	createModuleHashes(): void;
-	createHash(): void;
+	createHash(): {
+		module: Module;
+		hash: string;
+		runtime: RuntimeSpec;
+		runtimes: RuntimeSpec[];
+	}[];
 	fullHash?: string;
 	hash?: string;
 	emitAsset(file: string, source: Source, assetInfo?: AssetInfo): void;
@@ -8728,6 +8749,7 @@ declare abstract class RuntimeSpecMap<T> {
 	get(runtime: RuntimeSpec): T;
 	has(runtime: RuntimeSpec): boolean;
 	set(runtime?: any, value?: any): void;
+	provide(runtime?: any, computer?: any): any;
 	delete(runtime?: any): void;
 	update(runtime?: any, fn?: any): void;
 	keys(): RuntimeSpec[];
@@ -10117,7 +10139,9 @@ declare class Template {
 	): Source;
 	static renderRuntimeModules(
 		runtimeModules: RuntimeModule[],
-		renderContext: RenderContextModuleTemplate
+		renderContext: RenderContextModuleTemplate & {
+			codeGenerationResults?: CodeGenerationResults;
+		}
 	): Source;
 	static renderChunkRuntimeModules(
 		runtimeModules: RuntimeModule[],