webpack 5.107.2 → 5.108.0

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -11,6 +11,11 @@ const { UsageState } = require("../ExportsInfo");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const {
+	InlinedUsedName,
+	isExportInlined,
+	isInlineEnabled
+} = require("../optimize/InlineExports");
 const {
 	getMakeDeferredNamespaceModeFromExportsType
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
@@ -33,6 +38,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
+/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
 /** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
@@ -52,13 +58,17 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {[Ids, string | null, Set<string>, ReadonlyArray<HarmonyExportImportedSpecifierDependency> | null, ExportPresenceMode, HarmonyStarExportsList | null]} SerializedData */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<SerializedData>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<SerializedData>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[HarmonyExportImportedSpecifierDependency[]]>} StarListDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[HarmonyExportImportedSpecifierDependency[]]>} StarListSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
 /** @typedef {import("../dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 
 /** @typedef {"missing" | "unused" | "empty-star" | "reexport-dynamic-default" | "reexport-named-default" | "reexport-namespace-object" | "reexport-fake-namespace-object" | "reexport-undefined" | "normal-reexport" | "dynamic-reexport"} ExportModeType */
 
@@ -78,10 +88,15 @@ class NormalReexportItem {
 	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
 	 */
 	constructor(name, ids, exportInfo, checked, hidden) {
+		/** @type {string} */
 		this.name = name;
+		/** @type {Ids} */
 		this.ids = ids;
+		/** @type {ExportInfo} */
 		this.exportInfo = exportInfo;
+		/** @type {boolean} */
 		this.checked = checked;
+		/** @type {boolean} */
 		this.hidden = hidden;
 	}
 }
@@ -486,11 +501,16 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	) {
 		super(request, sourceOrder, phase, attributes);
 
+		/** @type {Ids} */
 		this.ids = ids;
+		/** @type {string | null} */
 		this.name = name;
+		/** @type {Set<string>} */
 		this.activeExports = activeExports;
 		this.otherStarExports = otherStarExports;
+		/** @type {ExportPresenceMode} */
 		this.exportPresenceMode = exportPresenceMode;
+		/** @type {HarmonyStarExportsList | null} */
 		this.allStarExports = allStarExports;
 	}
 
@@ -533,6 +553,32 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		return "harmony export imported specifier";
 	}
 
+	/**
+	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
+	 * @returns {string | true | null} export name, true for all exports, null for none
+	 */
+	getForwardId() {
+		return this.ids.length > 0 ? this.ids[0] : true;
+	}
+
+	/**
+	 * 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
+	 */
+	getLazyUntil() {
+		return this.name !== null
+			? Dependency.LAZY_UNTIL_ID
+			: Dependency.LAZY_UNTIL_FALLBACK;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return this.name;
+	}
+
 	/**
 	 * Returns the imported id.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -688,7 +734,24 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	getCondition(moduleGraph) {
 		return (connection, runtime) => {
 			const mode = this.getMode(moduleGraph, runtime);
-			return mode.type !== "unused" && mode.type !== "empty-star";
+			const active = mode.type !== "unused" && mode.type !== "empty-star";
+			if (!active) return active;
+
+			const module = connection.module;
+			if (!isInlineEnabled(module)) return true;
+			if (mode.type !== "normal-reexport") return true;
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+				return true;
+			}
+			for (const item of /** @type {NormalReexportItem[]} */ (mode.items)) {
+				// Hidden/checked items can't be statically inlined away
+				if (item.hidden || item.checked) return true;
+				if (!isExportInlined(moduleGraph, module, item.ids, runtime)) {
+					return true;
+				}
+			}
+			return false;
 		};
 	}
 
@@ -1086,15 +1149,14 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write, setCircularReference } = context;
-
-		setCircularReference(this);
-		write(this.ids);
-		write(this.name);
-		write(this.activeExports);
-		write(this.otherStarExports);
-		write(this.exportPresenceMode);
-		write(this.allStarExports);
+		context.setCircularReference(this);
+		context
+			.write(this.ids)
+			.write(this.name)
+			.write(this.activeExports)
+			.write(this.otherStarExports)
+			.write(this.exportPresenceMode)
+			.write(this.allStarExports);
 
 		super.serialize(context);
 	}
@@ -1104,17 +1166,20 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read, setCircularReference } = context;
-
-		setCircularReference(this);
-		this.ids = read();
-		this.name = read();
-		this.activeExports = read();
-		this.otherStarExports = read();
-		this.exportPresenceMode = read();
-		this.allStarExports = read();
-
-		super.deserialize(context);
+		context.setCircularReference(this);
+		this.ids = context.read();
+		const c1 = context.rest;
+		this.name = c1.read();
+		const c2 = c1.rest;
+		this.activeExports = c2.read();
+		const c3 = c2.rest;
+		this.otherStarExports = c3.read();
+		const c4 = c3.rest;
+		this.exportPresenceMode = c4.read();
+		const c5 = c4.rest;
+		this.allStarExports = c5.read();
+
+		super.deserialize(c5.rest);
 	}
 }
 
@@ -1215,7 +1280,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 					importVar,
 					importedModule.getExportsType(
 						moduleGraph,
-						module.buildMeta && module.buildMeta.strictHarmonyModule
+						module.buildMeta &&
+							/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
+								.strictHarmonyModule
 					),
 					runtimeRequirements
 				)
@@ -1363,7 +1430,8 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 								moduleGraph
 									.getExportsInfo(importedModule)
 									.getUsedName(ids, runtime),
-								runtimeRequirements
+								runtimeRequirements,
+								ids
 							)
 						);
 					}
@@ -1430,6 +1498,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 	 * @param {string} name name
 	 * @param {UsedName | null} valueKey value key
 	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @param {string[]=} ids original ids on the imported side (for inline-rendering comment)
 	 * @returns {HarmonyExportInitFragment} harmony export init fragment
 	 */
 	getReexportFragment(
@@ -1438,9 +1507,10 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		key,
 		name,
 		valueKey,
-		runtimeRequirements
+		runtimeRequirements,
+		ids
 	) {
-		const returnValue = this.getReturnValue(name, valueKey);
+		const returnValue = this.getReturnValue(name, valueKey, ids);
 
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
@@ -1573,10 +1643,11 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 	/**
 	 * Returns value.
 	 * @param {string} name name
-	 * @param {null | false | string | string[]} valueKey value key
+	 * @param {null | false | string | string[] | import("../optimize/InlineExports").InlinedUsedName} valueKey value key
+	 * @param {string[]=} ids original imported ids (for inline-rendering comment)
 	 * @returns {string | undefined} value
 	 */
-	getReturnValue(name, valueKey) {
+	getReturnValue(name, valueKey, ids) {
 		if (valueKey === null) {
 			return `${name}_default.a`;
 		}
@@ -1589,6 +1660,13 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 			return "/* unused export */ undefined";
 		}
 
+		if (valueKey instanceof InlinedUsedName) {
+			// Re-export forwards the source export's inlined literal as its own runtime value
+			return valueKey.render(
+				Template.toNormalComment(`inlined export ${propertyAccess(ids || [])}`)
+			);
+		}
+
 		return `${name}${propertyAccess(valueKey)}`;
 	}
 };
@@ -1614,7 +1692,7 @@ class HarmonyStarExportsList {
 
 	/**
 	 * Serializes this instance into the provided serializer context.
-	 * @param {ObjectSerializerContext} context context
+	 * @param {StarListSerializerContext} context context
 	 */
 	serialize({ write, setCircularReference }) {
 		setCircularReference(this);
@@ -1623,7 +1701,7 @@ class HarmonyStarExportsList {
 
 	/**
 	 * Restores this instance from the provided deserializer context.
-	 * @param {ObjectDeserializerContext} context context
+	 * @param {StarListDeserializerContext} context context
 	 */
 	deserialize({ read, setCircularReference }) {
 		setCircularReference(this);

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -169,25 +169,28 @@ class HarmonyExportInitFragment extends InitFragment {
 				: this.unusedExports.size > 0
 					? `/* unused harmony export ${first(this.unusedExports)} */\n`
 					: "";
-		/** @type {string[]} */
-		const definitions = [];
-		const orderedExportMap = [...this.exportMap].sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
-		for (const [key, value] of orderedExportMap) {
-			definitions.push(
-				`\n/* harmony export */   ${propertyName(
-					/** @type {string} */ (key)
-				)}: ${runtimeTemplate.returningFunction(value)}`
-			);
-		}
 		let definePart = "";
 		if (this.exportMap.size > 0) {
+			/** @type {string[]} */
+			const definitions = [];
+			const orderedExportMap =
+				this.exportMap.size > 1
+					? [...this.exportMap].sort(([a], [b]) => (a < b ? -1 : 1))
+					: this.exportMap;
+			for (const [key, value] of orderedExportMap) {
+				definitions.push(
+					`\n/* harmony export */   ${propertyName(
+						/** @type {string} */ (key)
+					)}: ${runtimeTemplate.returningFunction(value)}`
+				);
+			}
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			definePart = `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
-				this.exportsArgument
-			}, {${definitions.join(",")}\n/* harmony export */ });\n`;
+			definePart = `/* harmony export */ ${
+				RuntimeGlobals.definePropertyGetters
+			}(${this.exportsArgument}, {${definitions.join(
+				","
+			)}\n/* harmony export */ });\n`;
 		}
 		return `${definePart}${unusedPart}`;
 	}

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -5,45 +5,84 @@
 
 "use strict";
 
+const Dependency = require("../Dependency");
+const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
+const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../optimize/InlineExports").InlinedValue} InlinedValue */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, InlinedValue | null | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, InlinedValue | null | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./HarmonyExportInitFragment").UnusedExports} UnusedExports */
 /** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
 
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
 	 * Creates an instance of HarmonyExportSpecifierDependency.
 	 * @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
 	 */
-	constructor(id, name) {
+	constructor(id, name, constValue) {
 		super();
+		/** @type {string} */
 		this.id = id;
+		/** @type {string} */
 		this.name = name;
+		/** @type {InlinedValue | null | undefined} */
+		this.constValue = constValue;
 	}
 
 	get type() {
 		return "harmony export specifier";
 	}
 
+	/**
+	 * 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
+	 */
+	getLazyUntil() {
+		return Dependency.LAZY_UNTIL_LOCAL;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return this.name;
+	}
+
 	/**
 	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
+		const module = moduleGraph.getParentModule(this);
+		const pureFunctions =
+			module &&
+			module.buildInfo &&
+			/** @type {JavascriptModuleBuildInfo} */ (module.buildInfo).pureFunctions;
+		const isPure = Boolean(pureFunctions && pureFunctions.has(this.id));
+
 		return {
-			exports: [this.name],
+			exports: [
+				{
+					name: this.name,
+					isPure: isPure || undefined,
+					inlined: this.constValue || undefined
+				}
+			],
 			priority: 1,
 			terminalBinding: true,
 			dependencies: undefined
@@ -64,9 +103,7 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.id);
-		write(this.name);
+		context.write(this.id).write(this.name).write(this.constValue);
 		super.serialize(context);
 	}
 
@@ -75,10 +112,12 @@ class HarmonyExportSpecifierDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.id = read();
-		this.name = read();
-		super.deserialize(context);
+		this.id = context.read();
+		const c1 = context.rest;
+		this.name = c1.read();
+		const c2 = c1.rest;
+		this.constValue = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 
@@ -120,12 +159,38 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
-		/** @type {ExportMap} */
-		const map = new Map();
-		map.set(used, `/* binding */ ${dep.id}`);
-		initFragments.push(
-			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
-		);
+		if (used instanceof InlinedUsedName) {
+			// Inlined: importing side substitutes the literal directly, skip export init
+			return;
+		}
+
+		const canUseValueBinding =
+			dep.constValue !== undefined &&
+			/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
+				.isCircular === false;
+
+		if (canUseValueBinding) {
+			initFragments.push(
+				new ExportBindingInitFragment(
+					module.exportsArgument,
+					[
+						{
+							name: used,
+							value: `/* binding */ ${dep.id}`,
+							bindingType: "value"
+						}
+					],
+					true
+				)
+			);
+		} else {
+			/** @type {ExportMap} */
+			const map = new Map();
+			map.set(used, `/* binding */ ${dep.id}`);
+			initFragments.push(
+				new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
+			);
+		}
 	}
 };
 

package/lib/dependencies/HarmonyExports.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 /** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
@@ -25,7 +26,9 @@ module.exports.enable = (parserState, isStrictHarmony) => {
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
 	if (value !== true) {
-		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		const buildMeta =
+			/** @type {JavascriptModuleBuildMeta} */
+			(parserState.module.buildMeta);
 		buildMeta.exportsType = "namespace";
 		const buildInfo = /** @type {BuildInfo} */ (parserState.module.buildInfo);
 		buildInfo.strict = true;

package/lib/dependencies/HarmonyImportDependency.js

@@ -104,14 +104,34 @@ class HarmonyImportDependency extends ModuleDependency {
 		attributes = undefined
 	) {
 		super(request, sourceOrder);
+		/** @type {ImportPhaseType} */
 		this.phase = phase;
+		/** @type {ImportAttributes | undefined} */
 		this.attributes = attributes;
+		/** @type {boolean} */
+		this._lazyMake = false;
 	}
 
 	get category() {
 		return "esm";
 	}
 
+	/**
+	 * Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).
+	 * @returns {boolean} true while deferred, so it must not be processed or rendered
+	 */
+	isLazy() {
+		return this._lazyMake;
+	}
+
+	/**
+	 * Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).
+	 * @param {boolean} value true to defer, false to create it now
+	 */
+	setLazy(value) {
+		this._lazyMake = value;
+	}
+
 	/**
 	 * Returns true if this dependency can be concatenated
 	 * @returns {boolean} true if this dependency can be concatenated
@@ -381,6 +401,10 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
 
 		const connection = moduleGraph.getConnection(dep);
+		// deferred by lazy barrel: never resolved, must not render a missing module
+		if (connection === undefined && dep.isLazy()) {
+			return;
+		}
 		if (connection && !connection.isTargetActive(runtime)) return;
 
 		const referencedModule = connection && connection.module;