webpack 5.97.1 → 5.104.1

package/lib/ExternalModuleFactoryPlugin.js

@@ -12,25 +12,46 @@ const CssImportDependency = require("./dependencies/CssImportDependency");
 const CssUrlDependency = require("./dependencies/CssUrlDependency");
 const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const ImportDependency = require("./dependencies/ImportDependency");
-const { resolveByProperty, cachedSetProperty } = require("./util/cleverMerge");
+const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
-/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Compilation").DepConstructor} DepConstructor */
 /** @typedef {import("./ExternalModule").DependencyMeta} DependencyMeta */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").IssuerLayer} IssuerLayer */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
+/** @typedef {((context: string, request: string, callback: (err?: Error | null, result?: string | false, resolveRequest?: import("enhanced-resolve").ResolveRequest) => void) => void)} ExternalItemFunctionDataGetResolveCallbackResult */
+/** @typedef {((context: string, request: string) => Promise<string>)} ExternalItemFunctionDataGetResolveResult */
+/** @typedef {(options?: ResolveOptions) => ExternalItemFunctionDataGetResolveCallbackResult | ExternalItemFunctionDataGetResolveResult} ExternalItemFunctionDataGetResolve */
+
+/**
+ * @typedef {object} ExternalItemFunctionData
+ * @property {string} context the directory in which the request is placed
+ * @property {ModuleFactoryCreateDataContextInfo} contextInfo contextual information
+ * @property {string} dependencyType the category of the referencing dependency
+ * @property {ExternalItemFunctionDataGetResolve} getResolve get a resolve function with the current resolver options
+ * @property {string} request the request as written by the user in the require/import expression/statement
+ */
+
+/** @typedef {((data: ExternalItemFunctionData, callback: (err?: (Error | null), result?: ExternalItemValue) => void) => void)} ExternalItemFunctionCallback */
+/** @typedef {((data: import("../lib/ExternalModuleFactoryPlugin").ExternalItemFunctionData) => Promise<ExternalItemValue>)} ExternalItemFunctionPromise */
+
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
 const EMPTY_RESOLVE_OPTIONS = {};
 
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
 	/**
-	 * @param {TODO} externalsFunction externals function
+	 * @param {EXPECTED_FUNCTION} externalsFunction externals function
 	 * @param {string} context context
 	 * @param {string} request request
-	 * @param {(err: Error | null | undefined, value: ExternalValue | undefined, ty: ExternalType | undefined) => void} cb cb
+	 * @param {(err: Error | null | undefined, value: ExternalValue | undefined, ty: ExternalsType | undefined) => void} cb cb
 	 */
 	(externalsFunction, context, request, cb) => {
 		// eslint-disable-next-line no-useless-call
@@ -40,19 +61,26 @@ const callDeprecatedExternals = util.deprecate(
 	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
 );
 
+/** @typedef {ExternalItemObjectKnown & ExternalItemObjectUnknown} ExternalItemObject */
+
+/**
+ * @template {ExternalItemObject} T
+ * @typedef {WeakMap<T, Map<IssuerLayer, Omit<T, "byLayer">>>} ExternalWeakCache
+ */
+
+/** @type {ExternalWeakCache<ExternalItemObject>} */
 const cache = new WeakMap();
 
 /**
- * @template {object} T
- * @param {T} obj obj
- * @param {TODO} layer layer
- * @returns {Omit<T, "byLayer">} result
+ * @param {ExternalItemObject} obj obj
+ * @param {IssuerLayer} layer layer
+ * @returns {Omit<ExternalItemObject, "byLayer">} result
  */
 const resolveLayer = (obj, layer) => {
-	let map = cache.get(/** @type {object} */ (obj));
+	let map = cache.get(obj);
 	if (map === undefined) {
 		map = new Map();
-		cache.set(/** @type {object} */ (obj), map);
+		cache.set(obj, map);
 	} else {
 		const cacheEntry = map.get(layer);
 		if (cacheEntry !== undefined) return cacheEntry;
@@ -63,11 +91,12 @@ const resolveLayer = (obj, layer) => {
 };
 
 /** @typedef {string | string[] | boolean | Record<string, string | string[]>} ExternalValue */
-/** @typedef {string | undefined} ExternalType */
+
+const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
 class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {string | undefined} type default external type
+	 * @param {ExternalsType} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
@@ -82,17 +111,19 @@ class ExternalModuleFactoryPlugin {
 	apply(normalModuleFactory) {
 		const globalType = this.type;
 		normalModuleFactory.hooks.factorize.tapAsync(
-			"ExternalModuleFactoryPlugin",
+			PLUGIN_NAME,
 			(data, callback) => {
 				const context = data.context;
 				const contextInfo = data.contextInfo;
 				const dependency = data.dependencies[0];
 				const dependencyType = data.dependencyType;
 
+				/** @typedef {(err?: Error | null, externalModule?: ExternalModule) => void} HandleExternalCallback */
+
 				/**
 				 * @param {ExternalValue} value the external config
-				 * @param {ExternalType | undefined} type type of external
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @param {ExternalsType | undefined} type type of external
+				 * @param {HandleExternalCallback} callback callback
 				 * @returns {void}
 				 */
 				const handleExternal = (value, type, callback) => {
@@ -100,7 +131,7 @@ class ExternalModuleFactoryPlugin {
 						// Not externals, fallback to original factory
 						return callback();
 					}
-					/** @type {string | string[] | Record<string, string|string[]>} */
+					/** @type {ExternalValue} */
 					let externalConfig = value === true ? dependency.request : value;
 					// When no explicit type is specified, extract it from the externalConfig
 					if (type === undefined) {
@@ -109,7 +140,9 @@ class ExternalModuleFactoryPlugin {
 							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)
 						) {
 							const idx = externalConfig.indexOf(" ");
-							type = externalConfig.slice(0, idx);
+							type =
+								/** @type {ExternalsType} */
+								(externalConfig.slice(0, idx));
 							externalConfig = externalConfig.slice(idx + 1);
 						} else if (
 							Array.isArray(externalConfig) &&
@@ -118,7 +151,7 @@ class ExternalModuleFactoryPlugin {
 						) {
 							const firstItem = externalConfig[0];
 							const idx = firstItem.indexOf(" ");
-							type = firstItem.slice(0, idx);
+							type = /** @type {ExternalsType} */ (firstItem.slice(0, idx));
 							externalConfig = [
 								firstItem.slice(idx + 1),
 								...externalConfig.slice(1)
@@ -126,7 +159,7 @@ class ExternalModuleFactoryPlugin {
 						}
 					}
 
-					const resolvedType = /** @type {string} */ (type || globalType);
+					const resolvedType = type || globalType;
 
 					// TODO make it pluggable/add hooks to `ExternalModule` to allow output modules own externals?
 					/** @type {DependencyMeta | undefined} */
@@ -145,7 +178,7 @@ class ExternalModuleFactoryPlugin {
 									: undefined;
 
 						dependencyMeta = {
-							attributes: dependency.assertions,
+							attributes: dependency.attributes,
 							externalType
 						};
 					} else if (dependency instanceof CssImportDependency) {
@@ -176,7 +209,7 @@ class ExternalModuleFactoryPlugin {
 
 				/**
 				 * @param {Externals} externals externals config
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @param {HandleExternalCallback} callback callback
 				 * @returns {void}
 				 */
 				const handleExternals = (externals, callback) => {
@@ -224,7 +257,7 @@ class ExternalModuleFactoryPlugin {
 						/**
 						 * @param {Error | null | undefined} err err
 						 * @param {ExternalValue=} value value
-						 * @param {ExternalType=} type type
+						 * @param {ExternalsType=} type type
 						 * @returns {void}
 						 */
 						const cb = (err, value, type) => {
@@ -250,7 +283,8 @@ class ExternalModuleFactoryPlugin {
 									request: dependency.request,
 									dependencyType,
 									contextInfo,
-									getResolve: options => (context, request, callback) => {
+									getResolve: (options) => (context, request, callback) => {
+										/** @type {ResolveContext} */
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,
@@ -273,8 +307,7 @@ class ExternalModuleFactoryPlugin {
 												context,
 												request,
 												resolveContext,
-												/** @type {TODO} */
-												(callback)
+												callback
 											);
 										} else {
 											return new Promise((resolve, reject) => {
@@ -294,13 +327,16 @@ class ExternalModuleFactoryPlugin {
 								},
 								cb
 							);
-							if (promise && promise.then) promise.then(r => cb(null, r), cb);
+							if (promise && promise.then) {
+								promise.then((r) => cb(null, r), cb);
+							}
 						}
 						return;
 					} else if (typeof externals === "object") {
 						const resolvedExternals = resolveLayer(
 							externals,
-							contextInfo.issuerLayer
+							/** @type {IssuerLayer} */
+							(contextInfo.issuerLayer)
 						);
 						if (
 							Object.prototype.hasOwnProperty.call(
@@ -323,4 +359,5 @@ class ExternalModuleFactoryPlugin {
 		);
 	}
 }
+
 module.exports = ExternalModuleFactoryPlugin;

package/lib/ExternalsPlugin.js

@@ -5,14 +5,20 @@
 
 "use strict";
 
+const { ModuleExternalInitFragment } = require("./ExternalModule");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
+const ConcatenatedModule = require("./optimize/ConcatenatedModule");
 
+/** @typedef {import("../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ExternalModule").Imported} Imported */
+
+const PLUGIN_NAME = "ExternalsPlugin";
 
 class ExternalsPlugin {
 	/**
-	 * @param {string | undefined} type default external type
+	 * @param {ExternalsType} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
@@ -26,11 +32,60 @@ class ExternalsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
+		compiler.hooks.compile.tap(PLUGIN_NAME, ({ normalModuleFactory }) => {
 			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
 				normalModuleFactory
 			);
 		});
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			const { concatenatedModuleInfo } =
+				ConcatenatedModule.getCompilationHooks(compilation);
+			concatenatedModuleInfo.tap(PLUGIN_NAME, (updatedInfo, moduleInfo) => {
+				const rawExportMap = updatedInfo.rawExportMap;
+
+				if (!rawExportMap) {
+					return;
+				}
+
+				const chunkInitFragments = moduleInfo.chunkInitFragments;
+				const moduleExternalInitFragments =
+					/** @type {ModuleExternalInitFragment[]} */
+					(
+						chunkInitFragments
+							? /** @type {unknown[]} */
+								(chunkInitFragments).filter(
+									(fragment) => fragment instanceof ModuleExternalInitFragment
+								)
+							: []
+					);
+
+				let initFragmentChanged = false;
+
+				for (const fragment of moduleExternalInitFragments) {
+					const imported = fragment.getImported();
+
+					if (Array.isArray(imported)) {
+						const newImported =
+							/** @type {Imported} */
+							(
+								imported.map(([specifier, finalName]) => [
+									specifier,
+									rawExportMap.has(specifier)
+										? rawExportMap.get(specifier)
+										: finalName
+								])
+							);
+						fragment.setImported(newImported);
+						initFragmentChanged = true;
+					}
+				}
+
+				if (initFragmentChanged) {
+					return true;
+				}
+			});
+		});
 	}
 }