webpack 5.111.0 → 5.112.0

package/lib/dependencies/{HarmonyExportInitFragment.js → esm/ESMExportInitFragment.js}

@@ -5,14 +5,14 @@
 
 "use strict";
 
-const InitFragment = require("../InitFragment");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const { first } = require("../util/SetHelpers");
-const { propertyName } = require("../util/property");
+const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
+const InitFragment = require("../../template/InitFragment");
+const { first } = require("../../util/SetHelpers");
+const { propertyName } = require("../../util/property");
 
 /** @import { Source } from "webpack-sources" */
-/** @import { GenerateContext } from "../Generator" */
-/** @import { UsedName } from "../ExportsInfo" */
+/** @import { GenerateContext } from "../../module/Generator" */
+/** @import { UsedName } from "../../graph/ExportsInfo" */
 
 /**
  * Join iterable with comma.
@@ -40,14 +40,14 @@ const ExportBindingType = Object.freeze({
 	Value: 0b01
 });
 
-/** @typedef {Map<UsedName, { value: string, type: typeof ExportBindingType.Getter | typeof ExportBindingType.Value }>} ExportMap */
-/** @typedef {Set<string>} UnusedExports */
-
 /**
- * Lets a consumer take over the rendered `d()` call at its required position.
- * End-position value bindings cannot move before the module body.
- * @typedef {(source: string, placeAtEnd: boolean) => boolean} OnDemandGeneration
+ * @typedef {object} ExportMapEntry
+ * @property {string} value the expression the definition reads, comment included
+ * @property {typeof ExportBindingType.Getter | typeof ExportBindingType.Value} type how the export is defined
+ * @property {string=} finalName the binding of the module's own body the export reads, exported natively where the definition is left out on demand
  */
+/** @typedef {Map<UsedName, ExportMapEntry>} ExportMap */
+/** @typedef {Set<string>} UnusedExports */
 
 /** @type {ExportMap} */
 const EMPTY_MAP = new Map();
@@ -55,31 +55,36 @@ const EMPTY_MAP = new Map();
 const EMPTY_SET = new Set();
 
 /**
- * Represents HarmonyExportInitFragment.
+ * Represents ESMExportInitFragment.
  * @extends {InitFragment<GenerateContext>} Context
  */
-class HarmonyExportInitFragment extends InitFragment {
+class ESMExportInitFragment extends InitFragment {
 	/**
-	 * Creates an instance of HarmonyExportInitFragment.
+	 * Creates an instance of ESMExportInitFragment.
 	 * @param {string} exportsArgument the exports identifier
 	 * @param {ExportMap} exportMap mapping from used name to exposed variable name
 	 * @param {UnusedExports} unusedExports list of unused export names
-	 * @param {OnDemandGeneration=} onDemand offered the call instead of emitting it
+	 * @param {boolean} onDemand leave the call out of the source and hand it over in the code generation data, with the binding each export reads (see `KnownMeta.onDemandExports`)
 	 */
 	constructor(
 		exportsArgument,
 		exportMap = EMPTY_MAP,
 		unusedExports = EMPTY_SET,
-		onDemand = undefined
+		onDemand = false
 	) {
-		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
+		super(
+			undefined,
+			InitFragment.STAGE_ESM_EXPORTS,
+			1,
+			onDemand ? "harmony-exports-on-demand" : "harmony-exports"
+		);
 		/** @type {string} */
 		this.exportsArgument = exportsArgument;
 		/** @type {ExportMap} */
 		this.exportMap = exportMap;
 		/** @type {UnusedExports} */
 		this.unusedExports = unusedExports;
-		/** @type {OnDemandGeneration | undefined} */
+		/** @type {boolean} */
 		this.onDemand = onDemand;
 
 		this._generated = false;
@@ -128,8 +133,8 @@ class HarmonyExportInitFragment extends InitFragment {
 
 	/**
 	 * Merges the provided values into a single result.
-	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
-	 * @returns {HarmonyExportInitFragment} merged fragment
+	 * @param {ESMExportInitFragment[]} fragments all fragments to merge
+	 * @returns {ESMExportInitFragment} merged fragment
 	 */
 	mergeAll(fragments) {
 		/** @type {undefined | ExportMap} */
@@ -138,15 +143,12 @@ class HarmonyExportInitFragment extends InitFragment {
 		/** @type {undefined | UnusedExports} */
 		let unusedExports;
 		let unusedExportsOwned = false;
-		/** @type {OnDemandGeneration=} */
-		let onDemand;
 
 		for (const fragment of fragments) {
 			if (fragment.exportMap.size !== 0) {
 				if (exportMap === undefined) {
 					exportMap = fragment.exportMap;
 					exportMapOwned = false;
-					onDemand = fragment.onDemand;
 				} else {
 					if (!exportMapOwned) {
 						exportMap = new Map(exportMap);
@@ -154,7 +156,6 @@ class HarmonyExportInitFragment extends InitFragment {
 					}
 					for (const [key, value] of fragment.exportMap) {
 						if (!exportMap.has(key)) exportMap.set(key, value);
-						onDemand = onDemand || fragment.onDemand;
 					}
 				}
 			}
@@ -173,18 +174,18 @@ class HarmonyExportInitFragment extends InitFragment {
 				}
 			}
 		}
-		return new HarmonyExportInitFragment(
+		return new ESMExportInitFragment(
 			this.exportsArgument,
 			exportMap,
 			unusedExports,
-			onDemand
+			this.onDemand
 		);
 	}
 
 	/**
 	 * Returns merged result.
-	 * @param {HarmonyExportInitFragment} other other
-	 * @returns {HarmonyExportInitFragment} merged result
+	 * @param {ESMExportInitFragment} other other
+	 * @returns {ESMExportInitFragment} merged result
 	 */
 	merge(other) {
 		/** @type {ExportMap} */
@@ -211,11 +212,11 @@ class HarmonyExportInitFragment extends InitFragment {
 				unusedExports.add(value);
 			}
 		}
-		return new HarmonyExportInitFragment(
+		return new ESMExportInitFragment(
 			this.exportsArgument,
 			exportMap,
 			unusedExports,
-			this.onDemand || other.onDemand
+			this.onDemand
 		);
 	}
 
@@ -227,7 +228,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	getContent(context) {
 		this._generate(context);
 
-		const { runtimeRequirements } = context;
+		const { runtimeRequirements, getData } = context;
 		const unusedPart =
 			this.unusedExports.size > 1
 				? `/* unused harmony exports ${joinIterableWithComma(
@@ -248,7 +249,24 @@ class HarmonyExportInitFragment extends InitFragment {
 			}(${this.exportsArgument}, {${this._defsGetter.join(
 				","
 			)}\n/* harmony export */ });\n`;
-			if (this.onDemand !== undefined && this.onDemand(definePart, false)) {
+		}
+
+		if (this.onDemand && getData !== undefined) {
+			const data = getData();
+			/** @type {Record<string, string>} */
+			const finalNames = {};
+			for (const [key, { finalName }] of this.exportMap) {
+				if (finalName !== undefined) {
+					finalNames[/** @type {string} */ (key)] = finalName;
+				}
+			}
+			data.set("exportsFinalName", finalNames);
+			if (definePart) {
+				const before = data.get("exportsSource");
+				data.set(
+					"exportsSource",
+					before ? `${before}${definePart}` : definePart
+				);
 				definePart = "";
 			}
 		}
@@ -261,7 +279,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @param {GenerateContext} context context
 	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
-	getEndContent({ runtimeRequirements }) {
+	getEndContent({ runtimeRequirements, getData }) {
 		let definePart = "";
 
 		if (this._defsValue && this._defsValue.length) {
@@ -269,23 +287,30 @@ class HarmonyExportInitFragment extends InitFragment {
 			// emit it, and by then the requirement set is closed.
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			// Only this fragment emits the array form, so the runtime helper drops the
-			// branch reading it unless this asks for it.
+			// The runtime helper drops the branch reading the array form unless an
+			// emitter of it asks, so every emitter has to.
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGettersFromArray);
-			const definition = `/* harmony export */ ${
+			definePart = `/* harmony export */ ${
 				RuntimeGlobals.definePropertyGetters
 			}(${this.exportsArgument}, [${this._defsValue.join(",")}\n/* harmony export */ ]);\n`;
 
-			definePart =
-				this.onDemand !== undefined && this.onDemand(definition, true)
-					? definePart
-					: `\n${definition}`;
+			if (this.onDemand && getData !== undefined) {
+				const data = getData();
+				const before = data.get("exportsBindingSource");
+				data.set(
+					"exportsBindingSource",
+					before ? `${before}${definePart}` : definePart
+				);
+				definePart = "";
+			} else {
+				definePart = `\n${definePart}`;
+			}
 		}
 
 		return definePart;
 	}
 }
 
-module.exports = HarmonyExportInitFragment;
+module.exports = ESMExportInitFragment;
 
-HarmonyExportInitFragment.ExportBindingType = ExportBindingType;
+ESMExportInitFragment.ExportBindingType = ExportBindingType;

package/lib/dependencies/{HarmonyExportSpecifierDependency.js → esm/ESMExportSpecifierDependency.js}

@@ -5,39 +5,34 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const { InlinedUsedName } = require("../optimize/InlineExports");
-const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
-const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+const Dependency = require("../../graph/Dependency");
+const { isInlinedUsedName } = require("../../optimize/InlineExports");
+const makeSerializable = require("../../util/makeSerializable");
+const NullDependency = require("../core/NullDependency");
+const ESMExportInitFragment = require("./ESMExportInitFragment");
 
-const { ExportBindingType } = HarmonyExportInitFragment;
-
-const NullDependency = require("./NullDependency");
+const { ExportBindingType } = ESMExportInitFragment;
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { ExportsSpec, LazyUntil } from "../Dependency" */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { ConnectionState } from "../ModuleGraphConnection" */
-/** @import { InlinedValue } from "../optimize/InlineExports" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, InlinedValue | null | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, InlinedValue | null | undefined]>} ObjectSerializerContext */
-/** @import { UnusedExports, ExportMap } from "./HarmonyExportInitFragment" */
+/** @import { ExportsSpec, LazyRole, UpdateHashContext } from "../../graph/Dependency" */
+/** @import Module, { BuildInfo } from "../../module/Module" */
+/** @import Hash from "../../util/Hash" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import { ConnectionState } from "../../graph/ModuleGraphConnection" */
+/** @import { InlinedValue } from "../../optimize/InlineExports" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, InlinedValue | null | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, InlinedValue | null | undefined]>} ObjectSerializerContext */
+/** @import { UnusedExports, ExportMap } from "./ESMExportInitFragment" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
- * } from "../javascript/JavascriptModule"
+ * } from "../../javascript/JavascriptModule"
  */
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
-);
-
-class HarmonyExportSpecifierDependency extends NullDependency {
+class ESMExportSpecifierDependency extends NullDependency {
 	/**
-	 * Creates an instance of HarmonyExportSpecifierDependency.
+	 * Creates an instance of ESMExportSpecifierDependency.
 	 * @param {string} id the id
 	 * @param {string} name the name
 	 * @param {InlinedValue | null=} constValue undefined = not const, null = const but not inline-eligible, InlinedValue = const and inline-eligible
@@ -58,17 +53,17 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 
 	/**
 	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
-	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 * @returns {LazyRole | null} lazy classification, null when it must be processed eagerly
 	 */
-	getLazyUntil() {
-		return Dependency.LAZY_UNTIL_LOCAL;
+	get lazyRole() {
+		return Dependency.LAZY_LOCAL_EXPORT;
 	}
 
 	/**
-	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * Returns the export name for a `LAZY_LOCAL_EXPORT`/`LAZY_NAMED_REEXPORT` classification (lazy barrel optimization).
 	 * @returns {string | null} export name, null when not applicable
 	 */
-	getLazyName() {
+	get lazyName() {
 		return this.name;
 	}
 
@@ -108,6 +103,25 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 		return false;
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// the module's cycles, known only after it is built, pick value or getter
+		if (this.constValue === undefined) return;
+		const module = /** @type {Module} */ (
+			context.chunkGraph.moduleGraph.getParentModule(this)
+		);
+		hash.update(
+			/** @type {BuildInfo} */ (module.buildInfo).isCircular === false
+				? "value"
+				: "getter"
+		);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -131,12 +145,14 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	}
 }
 
-makeSerializable(
-	HarmonyExportSpecifierDependency,
+makeSerializable(ESMExportSpecifierDependency, [
+	"webpack/lib/dependencies/esm/ESMExportSpecifierDependency",
+	// TODO in the next major release: remove, it restores the packs written
+	// under the name the file had before the ESM rename
 	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
-);
+]);
 
-HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (
+ESMExportSpecifierDependency.Template = class ESMExportSpecifierDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -149,16 +165,9 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	apply(
 		dependency,
 		source,
-		{
-			module,
-			moduleGraph,
-			initFragments,
-			runtime,
-			runtimeTemplate,
-			concatenationScope
-		}
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
 	) {
-		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
+		const dep = /** @type {ESMExportSpecifierDependency} */ (dependency);
 		// a wrapped module's bindings stay inside the wrapper, not in the shared scope
 		if (concatenationScope && !concatenationScope.isWrapped()) {
 			concatenationScope.registerExport(dep.name, dep.id);
@@ -172,44 +181,38 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			const set = new Set();
 			set.add(dep.name || "namespace");
 			initFragments.push(
-				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
+				new ESMExportInitFragment(module.exportsArgument, undefined, set)
 			);
 			return;
 		}
 
-		if (used instanceof InlinedUsedName) {
+		if (isInlinedUsedName(used)) {
 			// Inlined: importing side substitutes the literal directly, skip export init
 			return;
 		}
 
+		const buildInfo =
+			/** @type {import("../../module/Module").BuildInfo} */
+			(module.buildInfo);
 		const valueFormat =
-			dep.constValue !== undefined &&
-			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
-				.isCircular === false;
-
-		// A library exporting the same bindings natively reads none of them back off the
-		// exports object, so it takes the call over and emits it only where wrapped.
-		const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-			runtimeTemplate.compilation
-		);
-		const onDemand = hooks.onDemandExportsGeneration.isUsed()
-			? (/** @type {string} */ definition, /** @type {boolean} */ placeAtEnd) =>
-					hooks.onDemandExportsGeneration.call(
-						module,
-						runtime,
-						definition,
-						placeAtEnd
-					) === true
-			: undefined;
+			dep.constValue !== undefined && buildInfo.isCircular === false;
+
+		const meta = moduleGraph.getMetaIfExisting(module);
+
+		const onDemand =
+			!concatenationScope &&
+			meta !== undefined &&
+			meta.onDemandExports === true;
 
 		/** @type {ExportMap} */
 		const map = new Map();
 		map.set(used, {
 			value: `/* binding */ ${dep.id}`,
-			type: valueFormat ? ExportBindingType.Value : ExportBindingType.Getter
+			type: valueFormat ? ExportBindingType.Value : ExportBindingType.Getter,
+			finalName: dep.id
 		});
 		initFragments.push(
-			new HarmonyExportInitFragment(
+			new ESMExportInitFragment(
 				module.exportsArgument,
 				map,
 				undefined,
@@ -219,4 +222,4 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	}
 };
 
-module.exports = HarmonyExportSpecifierDependency;
+module.exports = ESMExportSpecifierDependency;

package/lib/dependencies/{HarmonyExports.js → esm/ESMExports.js}

@@ -5,15 +5,15 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
 
-/** @import { BuildInfo } from "../Module" */
+/** @import { BuildInfo } from "../../module/Module" */
 /**
  * @import {
  * 	JavascriptModuleBuildMeta
- * } from "../javascript/JavascriptModule"
+ * } from "../../javascript/JavascriptModule"
  */
-/** @import { JavascriptParserState } from "../javascript/JavascriptParser" */
+/** @import { JavascriptParserState } from "../../javascript/JavascriptParser" */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();

package/lib/dependencies/{HarmonyImportBareSideEffectDependency.js → esm/ESMImportBareSideEffectDependency.js}

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const { ASSET_TYPE } = require("../ModuleSourceTypeConstants");
-const makeSerializable = require("../util/makeSerializable");
-const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
+const { ASSET_TYPE } = require("../../module/ModuleSourceTypeConstants");
+const makeSerializable = require("../../util/makeSerializable");
+const ESMImportSideEffectDependency = require("./ESMImportSideEffectDependency");
 
-/** @import Module from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { GetConditionFn } from "../Dependency" */
+/** @import Module from "../../module/Module" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import { GetConditionFn, DependencyKinds } from "../../graph/Dependency" */
 
 /**
  * Whether a module is emitted as a file of its own, asked of the module so a
@@ -28,7 +28,7 @@ const emitsOwnFile = (module) => module.getSourceTypes().has(ASSET_TYPE);
  * than a flag so it costs nothing per instance, and the bound form — much the
  * more common one — keeps the base class and its inline caches untouched.
  */
-class HarmonyImportBareSideEffectDependency extends HarmonyImportSideEffectDependency {
+class ESMImportBareSideEffectDependency extends ESMImportSideEffectDependency {
 	/**
 	 * Returns function to determine if the connection is active.
 	 * @param {ModuleGraph} moduleGraph module graph
@@ -48,12 +48,20 @@ class HarmonyImportBareSideEffectDependency extends HarmonyImportSideEffectDepen
 	}
 }
 
-makeSerializable(
-	HarmonyImportBareSideEffectDependency,
+makeSerializable(ESMImportBareSideEffectDependency, [
+	"webpack/lib/dependencies/esm/ESMImportBareSideEffectDependency",
+	// TODO in the next major release: remove, it restores the packs written
+	// under the name the file had before the ESM rename
 	"webpack/lib/dependencies/HarmonyImportBareSideEffectDependency"
-);
+]);
 
-HarmonyImportBareSideEffectDependency.Template =
-	HarmonyImportSideEffectDependency.Template;
+ESMImportBareSideEffectDependency.Template =
+	ESMImportSideEffectDependency.Template;
 
-module.exports = HarmonyImportBareSideEffectDependency;
+/** @type {Set<keyof DependencyKinds>} */
+ESMImportBareSideEffectDependency.KINDS = new Set([
+	...ESMImportSideEffectDependency.KINDS,
+	"esm-bare-side-effect-import"
+]);
+
+module.exports = ESMImportBareSideEffectDependency;