webpack 5.101.3 → 5.102.0

package/lib/ExternalModule.js

@@ -29,22 +29,23 @@ const { register } = require("./util/serialization");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").ModuleId} ModuleId */
 /** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").LibIdent} LibIdent */
 /** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -53,7 +54,6 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -88,7 +88,7 @@ const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
 
 /**
- * @param {string|string[]} variableName the variable name or path
+ * @param {string | string[]} variableName the variable name or path
  * @param {string} type the module system
  * @returns {SourceData} the generated source
  */
@@ -108,8 +108,10 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 	};
 };
 
+/** @typedef {string | string[]} ModuleAndSpecifiers */
+
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
@@ -128,7 +130,24 @@ const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 };
 
 /**
- * @param {string | string[]} moduleAndSpecifiers the module request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {InitFragment<ChunkRenderContext>} code
+ */
+const getExternalModuleNodeCommonjsInitFragment = (runtimeTemplate) => {
+	const importMetaName = runtimeTemplate.outputOptions.importMetaName;
+
+	return new InitFragment(
+		`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule(
+			"module"
+		)};\n${runtimeTemplate.renderConst()} __WEBPACK_EXTERNAL_createRequire_require = __WEBPACK_EXTERNAL_createRequire(${importMetaName}.url);\n`,
+		InitFragment.STAGE_HARMONY_IMPORTS,
+		0,
+		"external module node-commonjs"
+	);
+};
+
+/**
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -136,25 +155,13 @@ const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
 	runtimeTemplate
 ) => {
-	const importMetaName =
-		/** @type {string} */
-		(runtimeTemplate.outputOptions.importMetaName);
-
-	// 	/** @type {boolean} */
-	// 	(runtimeTemplate.supportNodePrefixForCoreModules())
-
 	const chunkInitFragments = [
-		new InitFragment(
-			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule("module")};\n`,
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			"external module node-commonjs"
-		)
+		getExternalModuleNodeCommonjsInitFragment(runtimeTemplate)
 	];
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
 			chunkInitFragments,
-			expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(
+			expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify(
 				moduleAndSpecifiers
 			)})`
 		};
@@ -162,14 +169,14 @@ const getSourceForCommonJsExternalInNodeModule = (
 	const moduleName = moduleAndSpecifiers[0];
 	return {
 		chunkInitFragments,
-		expression: `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)(${JSON.stringify(
+		expression: `__WEBPACK_EXTERNAL_createRequire_require(${JSON.stringify(
 			moduleName
 		)})${propertyAccess(moduleAndSpecifiers, 1)}`
 	};
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
  * @returns {SourceData} the generated source
@@ -263,7 +270,6 @@ class ModuleExternalInitFragment extends InitFragment {
 			}
 		}
 
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
 			"",
 			InitFragment.STAGE_HARMONY_IMPORTS,
@@ -273,8 +279,8 @@ class ModuleExternalInitFragment extends InitFragment {
 		this._ident = ident;
 		this._request = request;
 		this._dependencyMeta = dependencyMeta;
-		this._imported = imported;
-		this._identifier = identifier;
+		this._identifier = this.buildIdentifier(ident);
+		this._imported = this.buildImported(imported);
 	}
 
 	/**
@@ -337,6 +343,28 @@ class ModuleExternalInitFragment extends InitFragment {
 	getNamespaceIdentifier() {
 		return this._identifier;
 	}
+
+	/**
+	 * @param {string} ident ident
+	 * @returns {string} identifier
+	 */
+	buildIdentifier(ident) {
+		return `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+	}
+
+	/**
+	 * @param {Imported} imported imported
+	 * @returns {Imported} normalized imported
+	 */
+	buildImported(imported) {
+		if (Array.isArray(imported)) {
+			return imported.map(([name]) => {
+				const ident = `${this._ident}_${name}`;
+				return [name, this.buildIdentifier(ident)];
+			});
+		}
+		return imported;
+	}
 }
 
 register(
@@ -398,7 +426,7 @@ const generateModuleRemapping = (
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ModuleAndSpecifiers} moduleAndSpecifiers the module request
  * @param {ExportsInfo} exportsInfo exports info of this module
  * @param {RuntimeSpec} runtime the runtime
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -433,21 +461,7 @@ const getSourceForModuleExternal = (
 				imported = [];
 				break;
 			default:
-				imported = [];
-				if (exportsInfo.isUsed(runtime) === false) {
-					// no used, only
-				}
-				for (const [name] of usedExports.entries()) {
-					let counter = 0;
-					let finalName = name;
-
-					if (concatenationScope) {
-						while (!concatenationScope.registerUsedName(finalName)) {
-							finalName = `${name}_${counter++}`;
-						}
-					}
-					imported.push([name, finalName]);
-				}
+				imported = [...usedExports.entries()];
 		}
 	}
 
@@ -458,7 +472,24 @@ const getSourceForModuleExternal = (
 		dependencyMeta,
 		runtimeTemplate.outputOptions.hashFunction
 	);
-	const specifiers = imported === true ? undefined : imported;
+	const normalizedImported = initFragment.getImported();
+	const specifiers =
+		normalizedImported === true
+			? undefined
+			: /** @type {[string, string][]} */ (
+					normalizedImported.map(([name, rawFinalName]) => {
+						let finalName = rawFinalName;
+						let counter = 0;
+
+						if (concatenationScope) {
+							while (!concatenationScope.registerUsedName(finalName)) {
+								finalName = `${finalName}_${counter++}`;
+							}
+						}
+						return [name, finalName];
+					})
+				);
+
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
@@ -498,7 +529,7 @@ const getSourceForModuleExternal = (
 };
 
 /**
- * @param {string|string[]} urlAndGlobal the script request
+ * @param {string | string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -546,9 +577,9 @@ const checkExternalVariable = (variableName, request, runtimeTemplate) =>
 	)} }\n`;
 
 /**
- * @param {string|number} id the module id
+ * @param {ModuleId | string} id the module id
  * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
+ * @param {string | string[]} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -575,7 +606,7 @@ const getSourceForAmdOrUmdExternal = (
 
 /**
  * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
+ * @param {string | string[]} request the request path
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
@@ -596,10 +627,11 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 };
 
 /** @typedef {Record<string, string | string[]>} RequestRecord */
+/** @typedef {string | string[] | RequestRecord} ExternalModuleRequest */
 
 class ExternalModule extends Module {
 	/**
-	 * @param {string | string[] | RequestRecord} request request
+	 * @param {ExternalModuleRequest} request request
 	 * @param {string} type type
 	 * @param {string} userRequest user request
 	 * @param {DependencyMeta=} dependencyMeta dependency meta
@@ -608,7 +640,7 @@ class ExternalModule extends Module {
 		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 
 		// Info from Factory
-		/** @type {string | string[] | Record<string, string | string[]>} */
+		/** @type {ExternalModuleRequest} */
 		this.request = request;
 		/** @type {string} */
 		this.externalType = type;
@@ -638,7 +670,7 @@ class ExternalModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return this.userRequest;
@@ -1020,9 +1052,7 @@ class ExternalModule extends Module {
 						scope.registerRawExport(specifier, finalName);
 					}
 				} else if (concatenationScope) {
-					sourceString = `${
-						runtimeTemplate.supportsConst() ? "const" : "var"
-					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+					sourceString = `${runtimeTemplate.renderConst()} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
 					concatenationScope.registerNamespaceExport(
 						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 					);
@@ -1126,3 +1156,5 @@ makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;
 module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment;
+module.exports.getExternalModuleNodeCommonjsInitFragment =
+	getExternalModuleNodeCommonjsInitFragment;

package/lib/ExternalModuleFactoryPlugin.js

@@ -14,16 +14,33 @@ const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency"
 const ImportDependency = require("./dependencies/ImportDependency");
 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").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 = {};
 
@@ -79,7 +96,7 @@ const PLUGIN_NAME = "ExternalModuleFactoryPlugin";
 
 class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {string | undefined} type default external type
+	 * @param {string} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
@@ -140,7 +157,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} */
@@ -159,7 +176,7 @@ class ExternalModuleFactoryPlugin {
 									: undefined;
 
 						dependencyMeta = {
-							attributes: dependency.assertions,
+							attributes: dependency.attributes,
 							externalType
 						};
 					} else if (dependency instanceof CssImportDependency) {
@@ -265,6 +282,7 @@ class ExternalModuleFactoryPlugin {
 									dependencyType,
 									contextInfo,
 									getResolve: (options) => (context, request, callback) => {
+										/** @type {ResolveContext} */
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,
@@ -307,7 +325,9 @@ 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") {

package/lib/ExternalsPlugin.js

@@ -11,13 +11,13 @@ const ConcatenatedModule = require("./optimize/ConcatenatedModule");
 
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
+/** @typedef {import("./ExternalModule").Imported} Imported */
 
 const PLUGIN_NAME = "ExternalsPlugin";
 
 class ExternalsPlugin {
 	/**
-	 * @param {string | undefined} type default external type
+	 * @param {string} type default external type
 	 * @param {Externals} externals externals config
 	 */
 	constructor(type, externals) {
@@ -41,20 +41,23 @@ class ExternalsPlugin {
 			const { concatenatedModuleInfo } =
 				ConcatenatedModule.getCompilationHooks(compilation);
 			concatenatedModuleInfo.tap(PLUGIN_NAME, (updatedInfo, moduleInfo) => {
-				const rawExportMap =
-					/** @type {ConcatenatedModuleInfo} */ updatedInfo.rawExportMap;
+				const rawExportMap = updatedInfo.rawExportMap;
 
 				if (!rawExportMap) {
 					return;
 				}
 
-				const chunkInitFragments =
-					/** @type {ConcatenatedModuleInfo} */ moduleInfo.chunkInitFragments;
-				const moduleExternalInitFragments = chunkInitFragments
-					? chunkInitFragments.filter(
-							(fragment) => fragment instanceof ModuleExternalInitFragment
-						)
-					: [];
+				const chunkInitFragments = moduleInfo.chunkInitFragments;
+				const moduleExternalInitFragments =
+					/** @type {ModuleExternalInitFragment[]} */
+					(
+						chunkInitFragments
+							? /** @type {unknown[]} */
+								(chunkInitFragments).filter(
+									(fragment) => fragment instanceof ModuleExternalInitFragment
+								)
+							: []
+					);
 
 				let initFragmentChanged = false;
 
@@ -62,12 +65,16 @@ class ExternalsPlugin {
 					const imported = fragment.getImported();
 
 					if (Array.isArray(imported)) {
-						const newImported = imported.map(([specifier, finalName]) => [
-							specifier,
-							rawExportMap.has(specifier)
-								? rawExportMap.get(specifier)
-								: finalName
-						]);
+						const newImported =
+							/** @type {Imported} */
+							(
+								imported.map(([specifier, finalName]) => [
+									specifier,
+									rawExportMap.has(specifier)
+										? rawExportMap.get(specifier)
+										: finalName
+								])
+							);
 						fragment.setImported(newImported);
 						initFragmentChanged = true;
 					}