@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -13,15 +13,18 @@ const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 const NullDependency = require("./NullDependency");
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
+// Required here rather than at the top: the deferred-namespace runtime imports
+// dependencies from here.
+const getDeferredCycleHelpers = memoize(() =>
+	require("../runtime/MakeDeferredNamespaceObjectRuntime")
 );
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import Dependency from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import { BuildMeta } from "../Module" */
+/** @import Module, { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
@@ -39,6 +42,39 @@ makeSerializable(
 	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
 );
 
+/**
+ * Key shared by the async modules of one strongly-connected component. The spec
+ * records one `[[EvaluationError]]` per component, so a member that already
+ * fulfilled still has to report the root's error afterwards.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} module the async module
+ * @returns {ModuleId | null} the group key, or null when it is not in an async cycle
+ */
+const getAsyncCycleGroupId = (moduleGraph, chunkGraph, module) => {
+	const { getDeferredCycleModules } = getDeferredCycleHelpers();
+	const peers = getDeferredCycleModules(moduleGraph, module);
+	if (peers === null) return null;
+	// The component's smallest async member id names the group, so every member
+	// emits the same key and none has to carry the whole peer list.
+	let groupId = null;
+	let asyncPeerCount = 0;
+	for (const peer of peers) {
+		if (!moduleGraph.isAsync(peer)) continue;
+		asyncPeerCount++;
+		const id = chunkGraph.getModuleId(peer);
+		if (id !== null && (groupId === null || `${id}` < `${groupId}`)) {
+			groupId = id;
+		}
+	}
+	if (asyncPeerCount === 0) return null;
+	const ownId = chunkGraph.getModuleId(module);
+	if (ownId !== null && (groupId === null || `${ownId}` < `${groupId}`)) {
+		groupId = ownId;
+	}
+	return groupId;
+};
+
 HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
 	NullDependency.Template
 ) {
@@ -56,10 +92,12 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			module,
 			runtimeTemplate,
 			moduleGraph,
+			chunkGraph,
 			initFragments,
 			runtimeRequirements,
 			runtime,
-			concatenationScope
+			concatenationScope,
+			getData
 		}
 	) {
 		// a wrapped module has a real exports object that still needs `__esModule`
@@ -73,20 +111,13 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				exportsArgument: module.exportsArgument,
 				runtimeRequirements
 			});
-			// A library exporting the same bindings natively never reads the marker back
-			// off the exports object, so it takes the call over and emits it where wrapped.
-			const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-				runtimeTemplate.compilation
-			);
-			const takenOver =
-				hooks.onDemandExportsGeneration.isUsed() &&
-				hooks.onDemandExportsGeneration.call(
-					module,
-					runtime,
-					content,
-					false
-				) === true;
-			if (!takenOver) {
+
+			const meta = moduleGraph.getMetaIfExisting(module);
+			if (!concatenationScope && meta && meta.onDemandExports && getData) {
+				const data = getData();
+				const before = data.get("exportsSource");
+				data.set("exportsSource", before ? `${before}${content}` : content);
+			} else {
 				initFragments.push(
 					new InitFragment(
 						content,
@@ -99,9 +130,23 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		}
 		if (moduleGraph.isAsync(module)) {
 			runtimeRequirements.add(RuntimeGlobals.module);
-			const hasAwait = /** @type {BuildMeta} */ (module.buildMeta).async
-				? ", 1"
-				: "";
+			// Only `strictModuleErrorHandling` keeps a recorded error for later
+			// requires, so the component's peers are worth naming only then.
+			const cycleGroupId = runtimeTemplate.outputOptions
+				.strictModuleErrorHandling
+				? getAsyncCycleGroupId(moduleGraph, chunkGraph, module)
+				: null;
+			// The group is keyed by module id, so the runtime needs `module.id`.
+			if (cycleGroupId !== null) {
+				runtimeRequirements.add(RuntimeGlobals.moduleId);
+			}
+			const isAsyncBody = /** @type {BuildMeta} */ (module.buildMeta).async;
+			const hasAwait =
+				cycleGroupId === null
+					? isAsyncBody
+						? ", 1"
+						: ""
+					: `, ${isAsyncBody ? 1 : 0}, ${JSON.stringify(cycleGroupId)}`;
 			// A module-scope `await using` is disposed when its scope ends, so the body
 			// needs a block that closes before the module reports completion —
 			// otherwise dependents run before disposal is awaited.

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -109,10 +109,9 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		// Using `import.meta` only parses as a module, so it marks the module ESM.
-		// Non-bailing; staged before the bailing DefinePlugin and ImportMetaPlugin
-		// replacement taps so it observes every access; unknown members go
-		// through `unhandledExpressionMemberChain`.
+		// `import.meta` parses only as a module, so it marks this one ESM. Staged
+		// before the bailing DefinePlugin and ImportMetaPlugin taps, so it observes
+		// every access without ending the chain.
 		const onImportMeta = () => {
 			enableHarmony(false);
 		};

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -150,10 +150,16 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 				break;
 			}
 			case "namespace": {
-				value =
-					ids[0] === "__esModule"
-						? ids.length === 1 || undefined
-						: exportsInfo.isExportProvided(ids);
+				// Empty ids are an `export * as ns` hop skipped as side-effect free,
+				// leaving the target's own namespace, which always exists.
+				if (ids.length === 0) {
+					value = true;
+				} else {
+					value =
+						ids[0] === "__esModule"
+							? ids.length === 1 || undefined
+							: exportsInfo.isExportProvided(ids);
+				}
 				break;
 			}
 			case "dynamic": {

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -112,10 +112,8 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			return true;
 		});
 		// `export default <namespace binding>` is the same export as
-		// `export { ns as default }`, so it is claimed here and rewritten into the
-		// same re-export. Stage -10 runs before the inner-graph tap, which would
-		// otherwise wrap the identifier in a pure-expression guard whose insertions
-		// outlive the statement this removes.
+		// `export { ns as default }`, so it becomes the same re-export. Stage -10
+		// beats the inner-graph tap, whose guard would outlive the removed statement.
 		parser.hooks.statement.tap(
 			{ name: PLUGIN_NAME, stage: -10 },
 			(statement) => {
@@ -130,6 +128,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					/** @type {HarmonySettings | undefined} */
 					(parser.getTagData(name, harmonySpecifierTag));
 				if (!settings || settings.ids.length !== 0) return;
+				settings.used = true;
 				if (ImportPhaseUtils.isDefer(settings.phase)) return;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
@@ -217,14 +216,19 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						: undefined,
 				constValue
 			);
+			const isAnonymousClass =
+				(node.type === "ClassDeclaration" || node.type === "ClassExpression") &&
+				!node.id;
 			dep.isAnonymousDefault =
 				this.options.anonymousDefaultExportName !== false &&
 				(node.type === "ArrowFunctionExpression" ||
+					isAnonymousClass ||
 					((node.type === "FunctionDeclaration" ||
-						node.type === "FunctionExpression" ||
-						node.type === "ClassDeclaration" ||
-						node.type === "ClassExpression") &&
+						node.type === "FunctionExpression") &&
 						!node.id));
+			// A class observes its own name from a static initializer, which runs
+			// before the name could be patched afterwards, so it is named in place.
+			dep.isAnonymousDefaultClass = dep.isAnonymousDefault && isAnonymousClass;
 			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.current.addDependency(dep);
 			getInnerGraphUtils(parser.state.compilation).addVariableUsage(
@@ -255,6 +259,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const settings =
 					/** @type {HarmonySettings} */
 					(parser.getTagData(id, harmonySpecifierTag));
+				if (settings) settings.used = true;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -12,8 +12,11 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const ExportBindingInitFragment = require("./ExportBindingInitFragment");
+
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
+
+const { ExportBindingType } = HarmonyExportInitFragment;
+
 const NullDependency = require("./NullDependency");
 
 const DEFAULT_EXPORT_NAME = "default";
@@ -26,8 +29,8 @@ const DEFAULT_EXPORT_NAME = "default";
 /** @import { InlinedValue } from "../optimize/InlineExports" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }} DeclarationId */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean, boolean]>} ObjectSerializerContext */
 /** @import { ExportMap } from "./HarmonyExportInitFragment" */
 /**
  * @import {
@@ -54,6 +57,8 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		this.constValue = constValue;
 		/** @type {boolean} */
 		this.isAnonymousDefault = false;
+		/** @type {boolean} */
+		this.isAnonymousDefaultClass = false;
 	}
 
 	get type() {
@@ -126,6 +131,7 @@ class HarmonyExportExpressionDependency extends NullDependency {
 			.write(this.prefix)
 			.write(this.declarationId)
 			.write(this.isAnonymousDefault)
+			.write(this.isAnonymousDefaultClass)
 			.write(this.constValue);
 		super.serialize(context);
 	}
@@ -145,8 +151,10 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		const c4 = c3.rest;
 		this.isAnonymousDefault = c4.read();
 		const c5 = c4.rest;
-		this.constValue = c5.read();
-		super.deserialize(c5.rest);
+		this.isAnonymousDefaultClass = c5.read();
+		const c6 = c5.rest;
+		this.constValue = c6.read();
+		super.deserialize(c6.rest);
 	}
 }
 
@@ -208,7 +216,10 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			} else if (used) {
 				/** @type {ExportMap} */
 				const map = new Map();
-				map.set(used, `/* export default binding */ ${name}`);
+				map.set(used, {
+					value: `/* export default binding */ ${name}`,
+					type: ExportBindingType.Getter
+				});
 				initFragments.push(new HarmonyExportInitFragment(exportsName, map));
 			}
 
@@ -253,31 +264,19 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 						defaultIsUsed = true;
 						runtimeRequirements.add(RuntimeGlobals.exports);
 						// `export default <expr>` binds an immutable const declaration
-						const canUseValueBinding =
+						const valueFormat =
 							/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
 								.isCircular === false;
-						if (canUseValueBinding) {
-							initFragments.push(
-								new ExportBindingInitFragment(
-									exportsName,
-									[
-										{
-											name: used,
-											value: `/* export default binding */ ${name}`,
-											bindingType: "value"
-										}
-									],
-									true
-								)
-							);
-						} else {
-							/** @type {ExportMap} */
-							const map = new Map();
-							map.set(used, name);
-							initFragments.push(
-								new HarmonyExportInitFragment(exportsName, map)
-							);
-						}
+
+						/** @type {ExportMap} */
+						const map = new Map();
+						map.set(used, {
+							value: name,
+							type: valueFormat
+								? ExportBindingType.Value
+								: ExportBindingType.Getter
+						});
+						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
 					} else {
 						content = `/* unused harmony default export */ var ${name} = `;
 					}
@@ -294,10 +293,9 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 				} else if (used) {
 					defaultIsUsed = true;
 					runtimeRequirements.add(RuntimeGlobals.exports);
-					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					// No local `__WEBPACK_DEFAULT_EXPORT__` binding is created in this path,
-					// so the anonymous-default `.name` fix-up below must reference the actual
-					// assignment target instead. See issue #20793.
+					// The TDZ is not reproduced here, `const` being unavailable. No local
+					// binding is created either, so the anonymous-default `.name` fix-up
+					// below names the assignment target instead. See issue #20793.
 					name = `${exportsName}${propertyAccess(
 						typeof used === "string" ? [used] : used
 					)}`;
@@ -308,6 +306,22 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			}
 
 			if (dep.range) {
+				// `export default class {}` names the class "default", and a static
+				// initializer reads that name before any later fix-up could run, so
+				// the class is created as a property of that name instead.
+				if (dep.isAnonymousDefaultClass) {
+					source.replace(
+						dep.rangeStatement[0],
+						dep.range[0] - 1,
+						`${content}{ ${DEFAULT_EXPORT_NAME}: (${dep.prefix}`
+					);
+					source.replace(
+						dep.range[1],
+						dep.rangeStatement[1] - 0.5,
+						`) }.${DEFAULT_EXPORT_NAME};`
+					);
+					return;
+				}
 				source.replace(
 					dep.rangeStatement[0],
 					dep.range[0] - 1,