webpack 5.108.4 → 5.109.0

package/lib/ExternalModule.js

@@ -21,6 +21,7 @@ const {
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
+const WebpackError = require("./WebpackError");
 const { DEFAULTS } = require("./config/defaults");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
@@ -67,8 +68,9 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined]>} ObjectSerializerContext */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalInterop */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[ExternalModuleRequest, ExternalsType, string, DependencyMeta | undefined, ExternalInterop | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
@@ -104,6 +106,16 @@ const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 const EMPTY_RUNTIME_REQUIREMENTS = new Set();
 
 const NODE_PREFIX = "node:";
+
+// externals of these types are wired by the library wrapper, which does its own per-key lookup on object externals
+const LIBRARY_WIRED_EXTERNAL_TYPES = new Set([
+	"amd",
+	"amd-require",
+	"umd",
+	"umd2",
+	"system",
+	"jsonp"
+]);
 // External types that emit a node.js-resolvable specifier (`require`/`import`).
 const NODE_RESOLVING_EXTERNAL_TYPES = new Set([
 	"commonjs",
@@ -685,6 +697,7 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 					"__webpack_error__.name = 'ScriptExternalLoadError';",
 					"__webpack_error__.type = errorType;",
 					"__webpack_error__.request = realSrc;",
+					"__webpack_error__.event = event;",
 					"reject(__webpack_error__);"
 				])}, ${JSON.stringify(globalName)});`
 			]
@@ -695,6 +708,41 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 	};
 };
 
+/**
+ * Gets source for amd-async external. Loads the module at runtime via the
+ * asynchronous AMD `require([...])` API and exposes it as an async module,
+ * so no AMD library wrapper around the chunk is needed.
+ * @param {string | string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForAmdAsyncExternal = (request, runtimeTemplate) => {
+	if (!Array.isArray(request)) {
+		request = [request];
+	}
+	const { library } = runtimeTemplate.outputOptions;
+	const amdRequire =
+		library && library.amdContainer
+			? `${library.amdContainer}.require`
+			: "require";
+	return {
+		expression: `new Promise(${runtimeTemplate.basicFunction(
+			"resolve, reject",
+			[
+				`if (typeof ${amdRequire} !== "function") return reject(new Error(${JSON.stringify(
+					`AMD 'require' is not available to load external module ${request[0]}`
+				)}));`,
+				`${amdRequire}(${JSON.stringify([
+					request[0]
+				])}, ${runtimeTemplate.basicFunction(
+					"module",
+					`resolve(module${propertyAccess(request, 1)});`
+				)}, reject);`
+			]
+		)})`
+	};
+};
+
 /**
  * Checks external variable.
  * @param {string} variableName the variable name to check
@@ -783,8 +831,9 @@ class ExternalModule extends Module {
 	 * @param {ExternalsType} type type
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
+	 * @param {ExternalInterop=} interop how the external's exports interoperate with ES module imports
 	 */
-	constructor(request, type, userRequest, dependencyMeta) {
+	constructor(request, type, userRequest, dependencyMeta, interop) {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Redeclared with the external module specific shape
@@ -800,6 +849,8 @@ class ExternalModule extends Module {
 		this.userRequest = userRequest;
 		/** @type {DependencyMeta=} */
 		this.dependencyMeta = dependencyMeta;
+		/** @type {ExternalInterop | undefined} interop shape of the external's exports (undefined = importer-driven default) */
+		this.interop = interop;
 	}
 
 	/**
@@ -871,6 +922,7 @@ class ExternalModule extends Module {
 				id += `|attributes=${JSON.stringify(meta.attributes)}`;
 			}
 		}
+		if (this.interop) id += `|interop=${this.interop}`;
 		return id;
 	}
 
@@ -913,6 +965,28 @@ class ExternalModule extends Module {
 			javascriptModule: compilation.outputOptions.module
 		};
 		const { request, externalType } = this._getRequestAndExternalType();
+		if (
+			request === undefined &&
+			typeof this.request === "object" &&
+			!Array.isArray(this.request) &&
+			!LIBRARY_WIRED_EXTERNAL_TYPES.has(this.externalType)
+		) {
+			this.addError(
+				new WebpackError(
+					`Missing external configuration for type "${
+						this.externalType
+					}" in external ${JSON.stringify(
+						this.request
+					)}. Add a ${JSON.stringify(
+						this.externalType
+					)} entry to it or set 'output.externalsType'/'output.library.type' to one of: ${Object.keys(
+						this.request
+					)
+						.map((key) => JSON.stringify(key))
+						.join(", ")}`
+				)
+			);
+		}
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
 		this.clearDependenciesAndBlocks();
@@ -961,6 +1035,14 @@ class ExternalModule extends Module {
 					"external promise"
 				);
 				break;
+			case "amd-async":
+				this.buildMeta.async = true;
+				EnvironmentNotSupportAsyncWarning.check(
+					this,
+					compilation.runtimeTemplate,
+					"external amd-async"
+				);
+				break;
 			case "import":
 				this.buildMeta.async = true;
 				EnvironmentNotSupportAsyncWarning.check(
@@ -974,6 +1056,20 @@ class ExternalModule extends Module {
 				}
 				break;
 		}
+		// Opt-in override for how the external's exports interoperate with ESM
+		// imports, independent of the importer's strictness (see Rollup's
+		// `output.interop`). Only meaningful for a single-request external.
+		if (this.interop && (!Array.isArray(request) || request.length === 1)) {
+			if (this.interop === "esModule") {
+				// external already is an ES module namespace: `default` unboxes to `.default`
+				this.buildMeta.exportsType = "namespace";
+			} else {
+				// "default": treat as CommonJS, `default` is the whole exports (Node.js semantics)
+				this.buildMeta.exportsType = "default";
+				this.buildMeta.defaultObject = "redirect";
+			}
+			canMangle = false;
+		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
 	}
@@ -1110,6 +1206,8 @@ class ExternalModule extends Module {
 					runtimeTemplate.isUniversalTarget()
 				);
 			}
+			case "amd-async":
+				return getSourceForAmdAsyncExternal(request, runtimeTemplate);
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -1349,6 +1447,7 @@ class ExternalModule extends Module {
 				hash.update(`|attributes=${JSON.stringify(meta.attributes)}`);
 			}
 		}
+		if (this.interop) hash.update(`|interop=${this.interop}`);
 		super.updateHash(hash, context);
 	}
 
@@ -1361,7 +1460,8 @@ class ExternalModule extends Module {
 			.write(this.request)
 			.write(this.externalType)
 			.write(this.userRequest)
-			.write(this.dependencyMeta);
+			.write(this.dependencyMeta)
+			.write(this.interop);
 
 		super.serialize(context);
 	}
@@ -1378,8 +1478,10 @@ class ExternalModule extends Module {
 		this.userRequest = c2.read();
 		const c3 = c2.rest;
 		this.dependencyMeta = c3.read();
+		const c4 = c3.rest;
+		this.interop = c4.read();
 
-		super.deserialize(c3.rest);
+		super.deserialize(c4.rest);
 	}
 }
 

package/lib/ExternalModuleFactoryPlugin.js

@@ -23,6 +23,7 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
 /** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemInterop} ExternalItemInterop */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
@@ -161,6 +162,23 @@ class ExternalModuleFactoryPlugin {
 					}
 					/** @type {ExternalValue} */
 					let externalConfig = value === true ? dependency.request : value;
+					// `interop` is a reserved key on the object form, not a target;
+					// pull it out so the rest stays a pure externalsType->request map.
+					/** @type {ExternalItemInterop | undefined} */
+					let interop;
+					if (
+						typeof externalConfig === "object" &&
+						externalConfig !== null &&
+						!Array.isArray(externalConfig) &&
+						Object.prototype.hasOwnProperty.call(externalConfig, "interop")
+					) {
+						const { interop: interopValue, ...rest } =
+							/** @type {Record<string, string | string[]> & { interop?: ExternalItemInterop }} */ (
+								externalConfig
+							);
+						interop = interopValue;
+						externalConfig = rest;
+					}
 					// When no explicit type is specified, extract it from the externalConfig
 					if (type === undefined) {
 						if (
@@ -239,7 +257,8 @@ class ExternalModuleFactoryPlugin {
 							externalConfig,
 							resolvedType,
 							dependency.request,
-							dependencyMeta
+							dependencyMeta,
+							interop
 						)
 					);
 				};