webpack 5.97.1 → 5.104.1

package/lib/dependencies/HarmonyImportDependency.js

@@ -12,34 +12,33 @@ const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
+const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {0 | 1 | 2 | 3 | false} ExportPresenceMode */
+
 const ExportPresenceModes = {
-	NONE: /** @type {0} */ (0),
-	WARN: /** @type {1} */ (1),
-	AUTO: /** @type {2} */ (2),
-	ERROR: /** @type {3} */ (3),
+	NONE: /** @type {ExportPresenceMode} */ (0),
+	WARN: /** @type {ExportPresenceMode} */ (1),
+	AUTO: /** @type {ExportPresenceMode} */ (2),
+	ERROR: /** @type {ExportPresenceMode} */ (3),
 	/**
 	 * @param {string | false} str param
-	 * @returns {0 | 1 | 2 | 3} result
+	 * @returns {ExportPresenceMode} result
 	 */
 	fromUserOption(str) {
 		switch (str) {
@@ -57,27 +56,49 @@ const ExportPresenceModes = {
 	}
 };
 
+/** @typedef {string[]} Ids */
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request string
 	 * @param {number} sourceOrder source order
+	 * @param {ImportPhaseType=} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, sourceOrder, attributes) {
-		super(request);
-		this.sourceOrder = sourceOrder;
-		this.assertions = attributes;
+	constructor(
+		request,
+		sourceOrder,
+		phase = ImportPhase.Evaluation,
+		attributes = undefined
+	) {
+		super(request, sourceOrder);
+		this.phase = phase;
+		this.attributes = attributes;
 	}
 
 	get category() {
 		return "esm";
 	}
 
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = super.getResourceIdentifier();
+		if (ImportPhaseUtils.isDefer(this.phase)) {
+			str += "|defer";
+		}
+		if (this.attributes) {
+			str += `|importAttributes${JSON.stringify(this.attributes)}`;
+		}
+		return str;
+	}
+
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return Dependency.NO_EXPORTS_REFERENCED;
@@ -89,23 +110,48 @@ class HarmonyImportDependency extends ModuleDependency {
 	 */
 	getImportVar(moduleGraph) {
 		const module = /** @type {Module} */ (moduleGraph.getParentModule(this));
-		const meta = /** @type {TODO} */ (moduleGraph.getMeta(module));
-		let importVarMap = meta.importVarMap;
-		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
-		let importVar = importVarMap.get(
-			/** @type {Module} */ (moduleGraph.getModule(this))
-		);
+		const importedModule = /** @type {Module} */ (moduleGraph.getModule(this));
+		const meta = moduleGraph.getMeta(module);
+
+		const isDeferred =
+			ImportPhaseUtils.isDefer(this.phase) &&
+			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
+
+		const metaKey = isDeferred ? "deferredImportVarMap" : "importVarMap";
+		let importVarMap = meta[metaKey];
+		if (!importVarMap) {
+			meta[metaKey] = importVarMap =
+				/** @type {Map<Module, string>} */
+				(new Map());
+		}
+
+		let importVar = importVarMap.get(importedModule);
 		if (importVar) return importVar;
 		importVar = `${Template.toIdentifier(
 			`${this.userRequest}`
-		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
-		importVarMap.set(
-			/** @type {Module} */ (moduleGraph.getModule(this)),
-			importVar
-		);
+		)}__WEBPACK_${isDeferred ? "DEFERRED_" : ""}IMPORTED_MODULE_${importVarMap.size}__`;
+		importVarMap.set(importedModule, importVar);
 		return importVar;
 	}
 
+	/**
+	 * @param {DependencyTemplateContext} context the template context
+	 * @returns {string} the expression
+	 */
+	getModuleExports({
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtimeRequirements
+	}) {
+		return runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(this),
+			chunkGraph,
+			request: this.request,
+			runtimeRequirements
+		});
+	}
+
 	/**
 	 * @param {boolean} update create new variables or update existing one
 	 * @param {DependencyTemplateContext} templateContext the template context
@@ -118,17 +164,19 @@ class HarmonyImportDependency extends ModuleDependency {
 		return runtimeTemplate.importStatement({
 			update,
 			module: /** @type {Module} */ (moduleGraph.getModule(this)),
+			moduleGraph,
 			chunkGraph,
 			importVar: this.getImportVar(moduleGraph),
 			request: this.request,
 			originModule: module,
-			runtimeRequirements
+			runtimeRequirements,
+			dependency: this
 		});
 	}
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {string[]} ids imported ids
+	 * @param {Ids} ids imported ids
 	 * @param {string} additionalMessage extra info included in the error message
 	 * @returns {WebpackError[] | undefined} errors
 	 */
@@ -175,7 +223,7 @@ class HarmonyImportDependency extends ModuleDependency {
 							new HarmonyLinkingError(
 								`export ${ids
 									.slice(0, pos)
-									.map(id => `'${id}'`)
+									.map((id) => `'${id}'`)
 									.join(".")} ${additionalMessage} was not found in '${
 									this.userRequest
 								}'${moreInfo}`
@@ -191,7 +239,7 @@ class HarmonyImportDependency extends ModuleDependency {
 				return [
 					new HarmonyLinkingError(
 						`export ${ids
-							.map(id => `'${id}'`)
+							.map((id) => `'${id}'`)
 							.join(".")} ${additionalMessage} was not found in '${
 							this.userRequest
 						}'`
@@ -207,7 +255,7 @@ class HarmonyImportDependency extends ModuleDependency {
 					return [
 						new HarmonyLinkingError(
 							`Can't import the named export ${ids
-								.map(id => `'${id}'`)
+								.map((id) => `'${id}'`)
 								.join(
 									"."
 								)} ${additionalMessage} from default-exporting module (only default export is available)`
@@ -228,7 +276,7 @@ class HarmonyImportDependency extends ModuleDependency {
 					return [
 						new HarmonyLinkingError(
 							`Should not import the named export ${ids
-								.map(id => `'${id}'`)
+								.map((id) => `'${id}'`)
 								.join(
 									"."
 								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
@@ -244,8 +292,8 @@ class HarmonyImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.sourceOrder);
-		write(this.assertions);
+		write(this.attributes);
+		write(this.phase);
 		super.serialize(context);
 	}
 
@@ -254,8 +302,8 @@ class HarmonyImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
-		this.sourceOrder = read();
-		this.assertions = read();
+		this.attributes = read();
+		this.phase = read();
 		super.deserialize(context);
 	}
 }
@@ -297,12 +345,12 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		const moduleKey = referencedModule
 			? referencedModule.identifier()
 			: dep.request;
-		const key = `harmony import ${moduleKey}`;
+		const key = `${ImportPhaseUtils.isDefer(dep.phase) ? "deferred " : ""}harmony import ${moduleKey}`;
 
 		const runtimeCondition = dep.weak
 			? false
 			: connection
-				? filterRuntime(runtime, r => connection.isTargetActive(r))
+				? filterRuntime(runtime, (r) => connection.isTargetActive(r))
 				: true;
 
 		if (module && referencedModule) {
@@ -335,21 +383,20 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				new ConditionalInitFragment(
 					importStatement[0],
 					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
+					/** @type {number} */ (dep.sourceOrder),
 					key,
 					runtimeCondition
 				)
 			);
+			const importVar = dep.getImportVar(templateContext.moduleGraph);
 			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(
-					new Set([dep.getImportVar(templateContext.moduleGraph)])
-				)
+				new AwaitDependenciesInitFragment(new Map([[importVar, importVar]]))
 			);
 			templateContext.initFragments.push(
 				new ConditionalInitFragment(
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
-					dep.sourceOrder,
+					/** @type {number} */ (dep.sourceOrder),
 					`${key} compat`,
 					runtimeCondition
 				)
@@ -359,7 +406,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 				new ConditionalInitFragment(
 					importStatement[0] + importStatement[1],
 					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
+					/** @type {number} */ (dep.sourceOrder),
 					key,
 					runtimeCondition
 				)