webpack 5.111.0 → 5.112.0

package/lib/graph/Entrypoint.js

@@ -0,0 +1,136 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const SortableSet = require("../util/SortableSet");
+const ChunkGroup = require("./ChunkGroup");
+
+/**
+ * @import {
+ * 	EntryDescriptionNormalized as EntryDescription
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Chunk from "./Chunk" */
+
+/** @typedef {{ name?: string, worklet?: boolean } & Omit<EntryDescription, "import">} EntryOptions */
+
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
+class Entrypoint extends ChunkGroup {
+	/**
+	 * Creates an instance of Entrypoint.
+	 * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name)
+	 * @param {boolean=} initial false, when the entrypoint is not initial loaded
+	 */
+	constructor(entryOptions, initial = true) {
+		if (typeof entryOptions === "string") {
+			entryOptions = { name: entryOptions };
+		}
+		super({
+			name: entryOptions.name
+		});
+		this.options = entryOptions;
+		/** @type {Chunk=} */
+		this._runtimeChunk = undefined;
+		/** @type {Chunk=} */
+		this._entrypointChunk = undefined;
+		/** @type {boolean} */
+		this._initial = initial;
+		/** @type {SortableSet<Entrypoint>} */
+		this._dependOn = new SortableSet();
+	}
+
+	/**
+	 * Indicates whether this chunk group is loaded as part of the initial page
+	 * load instead of being created lazily.
+	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
+	 */
+	isInitial() {
+		return this._initial;
+	}
+
+	/**
+	 * Returns whether this chunk group is an entrypoint, an async one (e.g. a worker) included.
+	 * @returns {this is Entrypoint} true for an entrypoint
+	 */
+	isEntrypoint() {
+		return true;
+	}
+
+	/**
+	 * Sets the runtimeChunk for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the runtime chunk.
+	 * @returns {void}
+	 */
+	setRuntimeChunk(chunk) {
+		this._runtimeChunk = chunk;
+	}
+
+	/**
+	 * Fetches the chunk reference containing the webpack bootstrap code
+	 * @returns {Chunk | null} returns the runtime chunk or null if there is none
+	 */
+	getRuntimeChunk() {
+		if (this._runtimeChunk) return this._runtimeChunk;
+		for (const parent of this.parentsIterable) {
+			if (parent.isEntrypoint()) return parent.getRuntimeChunk();
+		}
+		return null;
+	}
+
+	/**
+	 * Sets the chunk with the entrypoint modules for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the entrypoint chunk.
+	 * @returns {void}
+	 */
+	setEntrypointChunk(chunk) {
+		this._entrypointChunk = chunk;
+	}
+
+	/**
+	 * Returns the chunk which contains the entrypoint modules
+	 * (or at least the execution of them)
+	 * @returns {Chunk} chunk
+	 */
+	getEntrypointChunk() {
+		return /** @type {Chunk} */ (this._entrypointChunk);
+	}
+
+	/**
+	 * Replaces one member chunk with another while preserving the group's
+	 * ordering and avoiding duplicates.
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean | undefined} returns true if the replacement was successful
+	 */
+	replaceChunk(oldChunk, newChunk) {
+		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;
+		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
+		return super.replaceChunk(oldChunk, newChunk);
+	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {void}
+	 */
+	addDependOn(entrypoint) {
+		this._dependOn.add(entrypoint);
+	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {boolean} true if the entrypoint is in the dependOn set
+	 */
+	dependOn(entrypoint) {
+		return this._dependOn.has(entrypoint);
+	}
+}
+
+module.exports = Entrypoint;

package/lib/{ExportsInfo.js → graph/ExportsInfo.js}

@@ -5,12 +5,14 @@
 
 "use strict";
 
-const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const { InlinedUsedName } = require("./optimize/InlineExports");
-const { equals } = require("./util/ArrayHelpers");
-const SortableSet = require("./util/SortableSet");
-const makeSerializable = require("./util/makeSerializable");
-const { forEachRuntime } = require("./util/runtime");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const {
+	InlinedUsedName,
+	isInlinedUsedName
+} = require("../optimize/InlineExports");
+const { equals } = require("../util/ArrayHelpers");
+const SortableSet = require("../util/SortableSet");
+const makeSerializable = require("../util/makeSerializable");
 
 /**
  * @import Dependency, {
@@ -18,22 +20,22 @@ const { forEachRuntime } = require("./util/runtime");
  * 	ExportsSpecExcludeExports
  * } from "./Dependency"
  */
-/** @import HarmonyImportDependency from "./dependencies/HarmonyImportDependency" */
-/** @import Module from "./Module" */
+/** @import ESMImportDependency from "../dependencies/esm/ESMImportDependency" */
+/** @import Module from "../module/Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import ModuleGraphConnection from "./ModuleGraphConnection" */
-/** @import { InlinedValue } from "./optimize/InlineExports" */
+/** @import { InlinedValue } from "../optimize/InlineExports" */
 /** @typedef {[RestoreProvidedDataExports[], ExportInfo["provided"], ExportInfo["canMangleProvide"], ExportInfo["terminalBinding"]]} RestoreProvidedDataTuple */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<RestoreProvidedDataTuple>} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<RestoreProvidedDataTuple>} ObjectSerializerContext */
-/** @import Hash from "./util/Hash" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<RestoreProvidedDataTuple>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<RestoreProvidedDataTuple>} ObjectSerializerContext */
+/** @import Hash from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
 /** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
 /** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */
-/** @typedef {{ module: Module, export: ExportInfoName[], deferred: boolean }} TargetItemWithoutConnection */
+/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[], deferred: boolean }} FoundTargetItem */
 /** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[] | undefined }} TargetItemWithConnection */
 /** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */
 /** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */
@@ -69,11 +71,69 @@ const UsageState = Object.freeze({
 
 const RETURNS_TRUE = () => true;
 
+/**
+ * Condition for `setUsedConditionally`, hoisted so no closure is made per call.
+ * @param {UsageStateType} used usage state
+ * @returns {boolean} true, when the export is unused
+ */
+const isUnused = (used) => used === UsageState.Unused;
+
+/**
+ * Condition for `setUsedConditionally`, hoisted so no closure is made per call.
+ * @param {UsageStateType} used usage state
+ * @returns {boolean} true, when the usage is less than unknown
+ */
+const isBelowUnknown = (used) => used < UsageState.Unknown;
+
+/**
+ * Sets the usage of one runtime in a per-runtime usage map.
+ * @param {UsedInRuntime} usedInRuntime usage per runtime
+ * @param {string} runtime the runtime
+ * @param {UsageStateType} newValue new usage state
+ * @param {((condition: UsageStateType) => boolean) | undefined} condition only set when it holds for the old value
+ * @returns {boolean} true, when the usage changed
+ */
+const setUsedInRuntime = (usedInRuntime, runtime, newValue, condition) => {
+	/** @type {UsageStateType | undefined} */
+	let oldValue = usedInRuntime.get(runtime);
+	if (oldValue === undefined) oldValue = UsageState.Unused;
+	if (newValue === oldValue) return false;
+	if (condition !== undefined && !condition(oldValue)) return false;
+	if (newValue === UsageState.Unused) {
+		usedInRuntime.delete(runtime);
+	} else {
+		usedInRuntime.set(runtime, newValue);
+	}
+	return true;
+};
+
+/**
+ * Creates a per-runtime usage map holding one usage state for every runtime.
+ * @param {Exclude<RuntimeSpec, undefined>} runtime the runtime
+ * @param {RuntimeUsageStateType} value usage state
+ * @returns {UsedInRuntime} usage per runtime
+ */
+const createUsedInRuntime = (runtime, value) => {
+	/** @type {UsedInRuntime} */
+	const usedInRuntime = new Map();
+	if (typeof runtime === "string") {
+		usedInRuntime.set(runtime, value);
+	} else {
+		for (const name of runtime) usedInRuntime.set(name, value);
+	}
+	return usedInRuntime;
+};
+
 // Shared empty visited-set for `findTarget`: `_findTarget` only reads
 // `alreadyVisited` (`.has`), never mutates it, so a fresh `new Set()` per call
 // is pure churn on the per-export reexport hot path. Must stay never-mutated.
 const EMPTY_VISITED = /** @type {Set<ExportInfo>} */ (new Set());
 
+// Shared while an exportsInfo owns no exports: 1035 of 2243 modules on a
+// production build of webpack itself, and a Map costs 184 bytes even empty.
+// The two `set` sites swap in a real Map. Must stay never-mutated.
+const NO_OWN_EXPORTS = /** @type {Exports} */ (new Map());
+
 const CIRCULAR = Symbol("circular target");
 
 // bit layout of ExportInfo._inlineFlags
@@ -142,29 +202,34 @@ class RestoreProvidedData {
 
 makeSerializable(
 	RestoreProvidedData,
-	"webpack/lib/ModuleGraph",
+	[
+		"webpack/lib/graph/ModuleGraph",
+		// TODO in the next major release: remove, it restores caches written
+		// before this moved into lib/graph/
+		"webpack/lib/ModuleGraph"
+	],
 	"RestoreProvidedData"
 );
 
 class ExportsInfo {
 	constructor() {
 		/** @type {Exports} */
-		this._exports = new Map();
-
-		// `_otherExportsInfo` is a fallback entry for unlisted exports. Two roles:
-		// 1. factory template — `getExportInfo` creates `new ExportInfo(name, this)`,
-		//    so created export info extends its properties.
-		// 2. flags whether the whole exportsInfo can be statically analyzed.
-		// Its `used` reachable values:
-		// 	- NoInfo: no use analysis yet (`optimization#usedExports` off), or used without info
-		// 	- Unused: analyzed, no unlisted export needed
-		// 	- Unknown: used in unknown way
-		// 	- Used/OnlyPropertiesUsed: never reached
-		// Its `provided` reachable values:
-		// 	- undefined: provision not determined yet
-		// 	- false: determined, no unlisted export is provided
-		// 	- null: only runtime knows (dynamic/unknown exports)
-		// 	- true: never reached
+		this._exports = NO_OWN_EXPORTS;
+
+		// WHY: a fallback entry for the unlisted exports, in two roles — the factory
+		// template `getExportInfo` extends with `new ExportInfo(name, this)`, and the
+		// flag for whether this exportsInfo can be statically analyzed at all.
+		// Its reachable `used` values:
+		// - NoInfo: no use analysis yet (`optimization#usedExports` off), or used
+		//   without info
+		// - Unused: analyzed, no unlisted export needed
+		// - Unknown: used in an unknown way
+		// - Used/OnlyPropertiesUsed: never reached
+		// Its reachable `provided` values:
+		// - undefined: provision not determined yet
+		// - false: determined, no unlisted export is provided
+		// - null: only runtime knows (dynamic or unknown exports)
+		// - true: never reached
 		/** @type {ExportInfo} */
 		this._otherExportsInfo = new ExportInfo(null);
 		/** @type {ExportInfo} */
@@ -363,7 +428,18 @@ class ExportsInfo {
 	getOwnExportInfo(name) {
 		const info = this._exports.get(name);
 		if (info !== undefined) return info;
+		return this._createOwnExportInfo(name);
+	}
+
+	/**
+	 * Adds an export info this exportsInfo owns, allocating its map for the first.
+	 * @param {ExportInfoName} name export name
+	 * @returns {ExportInfo} the new export info
+	 * @private
+	 */
+	_createOwnExportInfo(name) {
 		const newInfo = new ExportInfo(name, this._otherExportsInfo);
+		if (this._exports === NO_OWN_EXPORTS) this._exports = new Map();
 		this._exports.set(name, newInfo);
 		this._exportsAreOrdered = false;
 		return newInfo;
@@ -380,10 +456,7 @@ class ExportsInfo {
 		if (this._redirectTo !== undefined) {
 			return this._redirectTo.getExportInfo(name);
 		}
-		const newInfo = new ExportInfo(name, this._otherExportsInfo);
-		this._exports.set(name, newInfo);
-		this._exportsAreOrdered = false;
-		return newInfo;
+		return this._createOwnExportInfo(name);
 	}
 
 	/**
@@ -582,7 +655,7 @@ class ExportsInfo {
 	 */
 	setUsedForSideEffectsOnly(runtime) {
 		return this._sideEffectsOnlyInfo.setUsedConditionally(
-			(used) => used === UsageState.Unused,
+			isUnused,
 			UsageState.Used,
 			runtime
 		);
@@ -703,8 +776,9 @@ class ExportsInfo {
 			const inner = this._redirectTo.getProvidedExports();
 			if (inner === null) return null;
 			if (inner === true) return true;
+			const seen = new Set(array);
 			for (const item of inner) {
-				if (!array.includes(item)) {
+				if (!seen.has(item)) {
 					array.push(item);
 				}
 			}
@@ -858,7 +932,7 @@ class ExportsInfo {
 				const info = exportsInfo.getReadOnlyExportInfo(name[i]);
 				const x = info.getUsedName(name[i], runtime);
 				if (x === false) return false;
-				if (x instanceof InlinedUsedName) {
+				if (isInlinedUsedName(x)) {
 					// The inlined value replaces the prefix; trailing ids become its suffix
 					if (i === last) return x;
 					return new InlinedUsedName(x.value, [
@@ -920,7 +994,7 @@ class ExportsInfo {
 			if (hasInlined) {
 				const x = info.getUsedName(name[i], runtime);
 				if (x === false) return false;
-				if (x instanceof InlinedUsedName) return true;
+				if (isInlinedUsedName(x)) return true;
 				if (i === last) return false;
 			}
 			if (
@@ -1025,7 +1099,9 @@ class ExportsInfo {
 			}
 		}
 		return new RestoreProvidedData(
-			exports,
+			// A snapshot nothing appends to, so shed the slack a `push`-built
+			// store keeps: V8 sizes one for 17 and this holds a handful.
+			exports.length > 0 ? [...exports] : exports,
 			otherProvided,
 			otherCanMangleProvide,
 			otherTerminalBinding
@@ -1252,11 +1328,7 @@ class ExportInfo {
 	setUsedInUnknownWay(runtime) {
 		let changed = false;
 		if (
-			this.setUsedConditionally(
-				(used) => used < UsageState.Unknown,
-				UsageState.Unknown,
-				runtime
-			)
+			this.setUsedConditionally(isBelowUnknown, UsageState.Unknown, runtime)
 		) {
 			changed = true;
 		}
@@ -1383,33 +1455,21 @@ class ExportInfo {
 			}
 		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, (runtime) =>
-					/** @type {UsedInRuntime} */
-					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
-				);
+				this._usedInRuntime = createUsedInRuntime(runtime, newValue);
 				return true;
 			}
 		} else {
+			const usedInRuntime = this._usedInRuntime;
 			let changed = false;
-			forEachRuntime(runtime, (runtime_) => {
-				const runtime = /** @type {string} */ (runtime_);
-				const usedInRuntime =
-					/** @type {UsedInRuntime} */
-					(this._usedInRuntime);
-				let oldValue =
-					/** @type {UsageStateType} */
-					(usedInRuntime.get(runtime));
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue && condition(oldValue)) {
-					if (newValue === UsageState.Unused) {
-						usedInRuntime.delete(runtime);
-					} else {
-						usedInRuntime.set(runtime, newValue);
+			if (typeof runtime === "string") {
+				changed = setUsedInRuntime(usedInRuntime, runtime, newValue, condition);
+			} else {
+				for (const name of runtime) {
+					if (setUsedInRuntime(usedInRuntime, name, newValue, condition)) {
+						changed = true;
 					}
-					changed = true;
 				}
-			});
+			}
 			if (changed) {
 				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
 				return true;
@@ -1432,33 +1492,21 @@ class ExportInfo {
 			}
 		} else if (this._usedInRuntime === undefined) {
 			if (newValue !== UsageState.Unused) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, (runtime) =>
-					/** @type {UsedInRuntime} */
-					(this._usedInRuntime).set(/** @type {string} */ (runtime), newValue)
-				);
+				this._usedInRuntime = createUsedInRuntime(runtime, newValue);
 				return true;
 			}
 		} else {
+			const usedInRuntime = this._usedInRuntime;
 			let changed = false;
-			forEachRuntime(runtime, (_runtime) => {
-				const runtime = /** @type {string} */ (_runtime);
-				const usedInRuntime =
-					/** @type {UsedInRuntime} */
-					(this._usedInRuntime);
-				let oldValue =
-					/** @type {UsageStateType} */
-					(usedInRuntime.get(runtime));
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue) {
-					if (newValue === UsageState.Unused) {
-						usedInRuntime.delete(runtime);
-					} else {
-						usedInRuntime.set(runtime, newValue);
+			if (typeof runtime === "string") {
+				changed = setUsedInRuntime(usedInRuntime, runtime, newValue, undefined);
+			} else {
+				for (const name of runtime) {
+					if (setUsedInRuntime(usedInRuntime, name, newValue, undefined)) {
+						changed = true;
 					}
-					changed = true;
 				}
-			});
+			}
 			if (changed) {
 				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
 				return true;
@@ -1671,10 +1719,12 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target, undefined when there is no target, false when no target is valid.
+	 * Walks the reexport chain and returns the first target whose module passes
+	 * `validTargetModuleFilter`. Returns undefined when there is no target, false
+	 * when the chain ends without a valid module.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
-	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
+	 * @returns {FoundTargetItem | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	findTarget(moduleGraph, validTargetModuleFilter) {
 		return this._findTarget(
@@ -1689,7 +1739,7 @@ class ExportInfo {
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ValidTargetModuleFilter} validTargetModuleFilter a valid target module
 	 * @param {AlreadyVisitedExportInfo} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {TargetItemWithoutConnection | null | undefined | false} the target, undefined when there is no target, false when no target is valid
+	 * @returns {FoundTargetItem | null | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
 	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
 		if (!this._target || this._target.size === 0) return;
@@ -1697,16 +1747,16 @@ class ExportInfo {
 			/** @type {Target} */
 			(this._getMaxTarget()).values().next().value;
 		if (!rawTarget) return;
-		/** @type {TargetItemWithoutConnection} */
+		/** @type {FoundTargetItem} */
 		let target = {
 			module: rawTarget.connection.module,
+			connection: rawTarget.connection,
 			export: rawTarget.export,
 			deferred: Boolean(
 				rawTarget.connection.dependency &&
 				ImportPhaseUtils.isDefer(
-					/** @type {HarmonyImportDependency} */ (
-						rawTarget.connection.dependency
-					).phase
+					/** @type {ESMImportDependency} */ (rawTarget.connection.dependency)
+						.phase
 				)
 			)
 		};
@@ -1726,6 +1776,7 @@ class ExportInfo {
 			} else {
 				target = {
 					module: newTarget.module,
+					connection: newTarget.connection,
 					export: newTarget.export
 						? [...newTarget.export, ...target.export.slice(1)]
 						: target.export.slice(1),
@@ -1736,7 +1787,9 @@ class ExportInfo {
 	}
 
 	/**
-	 * Returns the target.
+	 * Resolves the reexport chain as far as `resolveTargetFilter` allows and
+	 * returns where it ends. Returns undefined when there is no target, the
+	 * targets disagree, or the chain is circular.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {ResolveTargetFilter} resolveTargetFilter filter function to further resolve target
 	 * @returns {TargetItemWithConnection | undefined} the target
@@ -1950,10 +2003,9 @@ class ExportInfo {
 	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
 	 */
 	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		const usedNameHash =
-			this._usedName instanceof InlinedUsedName
-				? `inlined:${this._usedName.render("")}`
-				: this._usedName || this.name;
+		const usedNameHash = isInlinedUsedName(this._usedName)
+			? `inlined:${this._usedName.render("")}`
+			: this._usedName || this.name;
 		hash.update(
 			`${usedNameHash}${this.getUsed(runtime)}${this.provided}${
 				this.terminalBinding

package/lib/{HotUpdateChunk.js → graph/HotUpdateChunk.js}

@@ -11,6 +11,14 @@ class HotUpdateChunk extends Chunk {
 	constructor() {
 		super();
 	}
+
+	/**
+	 * Returns whether this chunk carries a hot update rather than regular output.
+	 * @returns {boolean} true for a hot update chunk
+	 */
+	isHotUpdate() {
+		return true;
+	}
 }
 
 module.exports = HotUpdateChunk;