webpack 5.100.2 → 5.101.0

package/lib/ExternalModule.js

@@ -75,8 +75,11 @@ const { register } = require("./util/serialization");
  * @property {string} expression
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {ReadOnlyRuntimeRequirements=} runtimeRequirements
+ * @property {[string, string][]=} specifiers
  */
 
+/** @typedef {true | [string, string][]} Imported */
+
 const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
 const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
@@ -96,7 +99,9 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 	}
 
 	// needed for e.g. window["some"]["thing"]
-	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
+	const objectLookup = variableName
+		.map((r) => `[${JSON.stringify(r)}]`)
+		.join("");
 	return {
 		iife: type === "this",
 		expression: `${type}${objectLookup}`
@@ -107,7 +112,7 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
  * @param {string|string[]} moduleAndSpecifiers the module request
  * @returns {SourceData} the generated source
  */
-const getSourceForCommonJsExternal = moduleAndSpecifiers => {
+const getSourceForCommonJsExternal = (moduleAndSpecifiers) => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
 			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
@@ -123,21 +128,24 @@ const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 };
 
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {string} importMetaName import.meta name
- * @param {boolean} needPrefix need to use `node:` prefix for `module` import
+ * @param {string | string[]} moduleAndSpecifiers the module request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @returns {SourceData} the generated source
  */
 const getSourceForCommonJsExternalInNodeModule = (
 	moduleAndSpecifiers,
-	importMetaName,
-	needPrefix
+	runtimeTemplate
 ) => {
+	const importMetaName =
+		/** @type {string} */
+		(runtimeTemplate.outputOptions.importMetaName);
+
+	// 	/** @type {boolean} */
+	// 	(runtimeTemplate.supportNodePrefixForCoreModules())
+
 	const chunkInitFragments = [
 		new InitFragment(
-			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "${
-				needPrefix ? "node:" : ""
-			}module";\n`,
+			`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from ${runtimeTemplate.renderNodePrefixForCoreModule("module")};\n`,
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
 			"external module node-commonjs"
@@ -215,10 +223,9 @@ const getSourceForImportExternal = (
 };
 
 /**
- * @template {{ [key: string]: string }} T
- * @param {keyof T} key key
- * @param {T[keyof T]} value value
- * @returns {undefined | T[keyof T]} replaced value
+ * @param {string} key key
+ * @param {ImportAttributes | string | boolean | undefined} value value
+ * @returns {ImportAttributes | string | boolean | undefined} replaced value
  */
 const importAssertionReplacer = (key, value) => {
 	if (key === "_isLegacyAssert") {
@@ -229,17 +236,19 @@ const importAssertionReplacer = (key, value) => {
 };
 
 /**
- * @extends {InitFragment<ChunkRenderContext>}
+ * @extends {InitFragment<GenerateContext>}
  */
 class ModuleExternalInitFragment extends InitFragment {
 	/**
 	 * @param {string} request import source
+	 * @param {Imported} imported the imported specifiers
 	 * @param {string=} ident recomputed ident
 	 * @param {ImportDependencyMeta=} dependencyMeta the dependency meta
 	 * @param {HashFunction=} hashFunction the hash function to use
 	 */
 	constructor(
 		request,
+		imported,
 		ident,
 		dependencyMeta,
 		hashFunction = DEFAULTS.HASH_FUNCTION
@@ -253,28 +262,78 @@ class ModuleExternalInitFragment extends InitFragment {
 					.slice(0, 8)}`;
 			}
 		}
+
 		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
-			`import * as ${identifier} from ${JSON.stringify(request)}${
-				dependencyMeta && dependencyMeta.attributes
-					? dependencyMeta.attributes._isLegacyAssert
-						? ` assert ${JSON.stringify(
-								dependencyMeta.attributes,
-								importAssertionReplacer
-							)}`
-						: ` with ${JSON.stringify(dependencyMeta.attributes)}`
-					: ""
-			};\n`,
+			"",
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
-			`external module import ${ident}`
+			`external module import ${ident} ${imported === true ? imported : imported.join(" ")}`
 		);
 		this._ident = ident;
 		this._request = request;
-		this._dependencyMeta = request;
+		this._dependencyMeta = dependencyMeta;
+		this._imported = imported;
 		this._identifier = identifier;
 	}
 
+	/**
+	 * @returns {Imported} imported
+	 */
+	getImported() {
+		return this._imported;
+	}
+
+	/**
+	 * @param {Imported} imported imported
+	 */
+	setImported(imported) {
+		this._imported = imported;
+	}
+
+	/**
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		const {
+			_dependencyMeta: dependencyMeta,
+			_imported: imported,
+			_request: request,
+			_identifier: identifier
+		} = this;
+		const attributes =
+			dependencyMeta && dependencyMeta.attributes
+				? dependencyMeta.attributes._isLegacyAssert &&
+					dependencyMeta.attributes._isLegacyAssert
+					? ` assert ${JSON.stringify(
+							dependencyMeta.attributes,
+							importAssertionReplacer
+						)}`
+					: ` with ${JSON.stringify(dependencyMeta.attributes)}`
+				: "";
+		let content = "";
+		if (imported === true) {
+			// namespace
+			content = `import * as ${identifier} from ${JSON.stringify(request)}${
+				attributes
+			};\n`;
+		} else if (imported.length === 0) {
+			// just import, no use
+			content = `import ${JSON.stringify(request)}${attributes};\n`;
+		} else {
+			content = `import { ${imported
+				.map(([name, finalName]) => {
+					if (name !== finalName) {
+						return `${name} as ${finalName}`;
+					}
+					return name;
+				})
+				.join(", ")} } from ${JSON.stringify(request)}${attributes};\n`;
+		}
+		return content;
+	}
+
 	getNamespaceIdentifier() {
 		return this._identifier;
 	}
@@ -287,11 +346,12 @@ register(
 	{
 		serialize(obj, { write }) {
 			write(obj._request);
+			write(obj._imported);
 			write(obj._ident);
 			write(obj._dependencyMeta);
 		},
 		deserialize({ read }) {
-			return new ModuleExternalInitFragment(read(), read(), read());
+			return new ModuleExternalInitFragment(read(), read(), read(), read());
 		}
 	}
 );
@@ -343,6 +403,7 @@ const generateModuleRemapping = (
  * @param {RuntimeSpec} runtime the runtime
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {ImportDependencyMeta} dependencyMeta the dependency meta
+ * @param {ConcatenationScope=} concatenationScope concatenationScope
  * @returns {SourceData} the generated source
  */
 const getSourceForModuleExternal = (
@@ -350,28 +411,71 @@ const getSourceForModuleExternal = (
 	exportsInfo,
 	runtime,
 	runtimeTemplate,
-	dependencyMeta
+	dependencyMeta,
+	concatenationScope
 ) => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		moduleAndSpecifiers = [moduleAndSpecifiers];
 	}
+
+	/** @type {Imported} */
+	let imported = true;
+	if (concatenationScope) {
+		const usedExports = exportsInfo.getUsedExports(runtime);
+		switch (usedExports) {
+			case true:
+			case null:
+				// unknown exports
+				imported = true;
+				break;
+			case false:
+				// no used exports
+				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]);
+				}
+		}
+	}
+
 	const initFragment = new ModuleExternalInitFragment(
 		moduleAndSpecifiers[0],
+		imported,
 		undefined,
 		dependencyMeta,
 		runtimeTemplate.outputOptions.hashFunction
 	);
+	const specifiers = imported === true ? undefined : imported;
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
 	)}`;
-	const moduleRemapping = generateModuleRemapping(
-		baseAccess,
-		exportsInfo,
-		runtime,
-		runtimeTemplate
-	);
-	const expression = moduleRemapping || baseAccess;
+	let expression = baseAccess;
+
+	const useNamespace = imported === true;
+	let moduleRemapping;
+	if (useNamespace) {
+		moduleRemapping = generateModuleRemapping(
+			baseAccess,
+			exportsInfo,
+			runtime,
+			runtimeTemplate
+		);
+		expression = moduleRemapping || baseAccess;
+	}
 	return {
 		expression,
 		init: moduleRemapping
@@ -383,10 +487,13 @@ const getSourceForModuleExternal = (
 					"x"
 				)}`
 			: undefined,
+		specifiers,
 		runtimeRequirements: moduleRemapping
 			? RUNTIME_REQUIREMENTS_FOR_MODULE
 			: undefined,
-		chunkInitFragments: [initFragment]
+		chunkInitFragments: [
+			/** @type {InitFragment<EXPECTED_ANY>} */ (initFragment)
+		]
 	};
 };
 
@@ -733,6 +840,7 @@ class ExternalModule extends Module {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {DependencyMeta | undefined} dependencyMeta the dependency meta
+	 * @param {ConcatenationScope=} concatenationScope concatenationScope
 	 * @returns {SourceData} the source data
 	 */
 	_getSourceData(
@@ -742,7 +850,8 @@ class ExternalModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		dependencyMeta
+		dependencyMeta,
+		concatenationScope
 	) {
 		switch (externalType) {
 			case "this":
@@ -761,13 +870,7 @@ class ExternalModule extends Module {
 				return getSourceForCommonJsExternal(request);
 			case "node-commonjs":
 				return /** @type {BuildInfo} */ (this.buildInfo).javascriptModule
-					? getSourceForCommonJsExternalInNodeModule(
-							request,
-							/** @type {string} */
-							(runtimeTemplate.outputOptions.importMetaName),
-							/** @type {boolean} */
-							(runtimeTemplate.supportNodePrefixForCoreModules())
-						)
+					? getSourceForCommonJsExternalInNodeModule(request, runtimeTemplate)
 					: getSourceForCommonJsExternal(request);
 			case "amd":
 			case "amd-require":
@@ -818,7 +921,8 @@ class ExternalModule extends Module {
 					moduleGraph.getExportsInfo(this),
 					runtime,
 					runtimeTemplate,
-					/** @type {ImportDependencyMeta} */ (dependencyMeta)
+					/** @type {ImportDependencyMeta} */ (dependencyMeta),
+					concatenationScope
 				);
 			}
 			case "var":
@@ -898,14 +1002,24 @@ class ExternalModule extends Module {
 					moduleGraph,
 					chunkGraph,
 					runtime,
-					this.dependencyMeta
+					this.dependencyMeta,
+					concatenationScope
 				);
 
+				// sourceString can be empty str only when there is concatenationScope
 				let sourceString = sourceData.expression;
 				if (sourceData.iife) {
 					sourceString = `(function() { return ${sourceString}; }())`;
 				}
-				if (concatenationScope) {
+
+				const specifiers = sourceData.specifiers;
+				if (specifiers) {
+					sourceString = "";
+					const scope = /** @type {ConcatenationScope} */ (concatenationScope);
+					for (const [specifier, finalName] of specifiers) {
+						scope.registerRawExport(specifier, finalName);
+					}
+				} else if (concatenationScope) {
 					sourceString = `${
 						runtimeTemplate.supportsConst() ? "const" : "var"
 					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
@@ -1011,3 +1125,4 @@ class ExternalModule extends Module {
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;
+module.exports.ModuleExternalInitFragment = ModuleExternalInitFragment;

package/lib/ExternalModuleFactoryPlugin.js

@@ -264,7 +264,7 @@ class ExternalModuleFactoryPlugin {
 									request: dependency.request,
 									dependencyType,
 									contextInfo,
-									getResolve: options => (context, request, callback) => {
+									getResolve: (options) => (context, request, callback) => {
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,
@@ -307,7 +307,7 @@ 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

@@ -5,10 +5,13 @@
 
 "use strict";
 
+const { ModuleExternalInitFragment } = require("./ExternalModule");
 const ExternalModuleFactoryPlugin = require("./ExternalModuleFactoryPlugin");
+const ConcatenatedModule = require("./optimize/ConcatenatedModule");
 
 /** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
 
 const PLUGIN_NAME = "ExternalsPlugin";
 
@@ -33,6 +36,48 @@ class ExternalsPlugin {
 				normalModuleFactory
 			);
 		});
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			const { concatenatedModuleInfo } =
+				ConcatenatedModule.getCompilationHooks(compilation);
+			concatenatedModuleInfo.tap(PLUGIN_NAME, (updatedInfo, moduleInfo) => {
+				const rawExportMap =
+					/** @type {ConcatenatedModuleInfo} */ updatedInfo.rawExportMap;
+
+				if (!rawExportMap) {
+					return;
+				}
+
+				const chunkInitFragments =
+					/** @type {ConcatenatedModuleInfo} */ moduleInfo.chunkInitFragments;
+				const moduleExternalInitFragments = chunkInitFragments
+					? chunkInitFragments.filter(
+							(fragment) => fragment instanceof ModuleExternalInitFragment
+						)
+					: [];
+
+				let initFragmentChanged = false;
+
+				for (const fragment of moduleExternalInitFragments) {
+					const imported = fragment.getImported();
+
+					if (Array.isArray(imported)) {
+						const newImported = imported.map(([specifier, finalName]) => [
+							specifier,
+							rawExportMap.has(specifier)
+								? rawExportMap.get(specifier)
+								: finalName
+						]);
+						fragment.setImported(newImported);
+						initFragmentChanged = true;
+					}
+				}
+
+				if (initFragmentChanged) {
+					return true;
+				}
+			});
+		});
 	}
 }