webpack 5.97.1 → 5.104.1

package/lib/library/JsonpLibraryPlugin.js

@@ -13,10 +13,13 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} JsonpLibraryPluginOptions

package/lib/library/ModuleLibraryPlugin.js

@@ -6,21 +6,30 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const { UsageState } = require("../ExportsInfo");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const propertyAccess = require("../util/propertyAccess");
+const { getEntryRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryExport} LibraryExport */
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
+
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} ModuleLibraryPluginOptions
@@ -30,8 +39,11 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /**
  * @typedef {object} ModuleLibraryPluginParsed
  * @property {string} name
+ * @property {LibraryExport=} export
  */
 
+const PLUGIN_NAME = "ModuleLibraryPlugin";
+
 /**
  * @typedef {ModuleLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
@@ -47,6 +59,73 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		});
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		super.apply(compiler);
+
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			const { onDemandExportsGeneration } =
+				ConcatenatedModule.getCompilationHooks(compilation);
+			onDemandExportsGeneration.tap(
+				PLUGIN_NAME,
+				(module, runtimes, source, finalName) => {
+					/** @type {BuildMeta} */
+					const buildMeta = module.buildMeta || (module.buildMeta = {});
+
+					const exportsSourceByRuntime =
+						buildMeta.exportsSourceByRuntime ||
+						(buildMeta.exportsSourceByRuntime = new Map());
+
+					const exportsFinalNameByRuntime =
+						buildMeta.exportsFinalNameByRuntime ||
+						(buildMeta.exportsFinalNameByRuntime = new Map());
+
+					for (const runtime of runtimes) {
+						exportsSourceByRuntime.set(runtime, source);
+						exportsFinalNameByRuntime.set(runtime, finalName);
+					}
+
+					return true;
+				}
+			);
+		});
+	}
+
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			// If the entry module is commonjs, its exports cannot be mangled
+			if (module.buildMeta && module.buildMeta.treatAsCommonJs) {
+				exportsInfo.setUsedInUnknownWay(runtime);
+			} else {
+				exportsInfo.setAllKnownExportsUsed(runtime);
+			}
+		}
+		moduleGraph.addExtraReason(module, "used as library export");
+	}
+
 	/**
 	 * @param {LibraryOptions} library normalized library option
 	 * @returns {T | false} preprocess as needed by overriding
@@ -60,7 +139,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		}
 		const _name = /** @type {string} */ (name);
 		return {
-			name: _name
+			name: _name,
+			export: library.export
 		};
 	}
 
@@ -74,36 +154,168 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	renderStartup(
 		source,
 		module,
-		{ moduleGraph, chunk },
+		{
+			moduleGraph,
+			chunk,
+			codeGenerationResults,
+			inlined,
+			inlinedInIIFE,
+			runtimeTemplate
+		},
 		{ options, compilation }
 	) {
 		const result = new ConcatSource(source);
-		const exportsInfo = moduleGraph.getExportsInfo(module);
+
+		const exportsInfo = options.export
+			? [
+					moduleGraph.getExportInfo(
+						module,
+						Array.isArray(options.export) ? options.export[0] : options.export
+					)
+				]
+			: moduleGraph.getExportsInfo(module).orderedExports;
+
+		const exportsFinalNameByRuntime =
+			(module.buildMeta &&
+				module.buildMeta.exportsFinalNameByRuntime &&
+				module.buildMeta.exportsFinalNameByRuntime.get(chunk.runtime)) ||
+			{};
+
+		const definitions =
+			inlined && !inlinedInIIFE ? exportsFinalNameByRuntime : {};
+
+		/** @type {string[]} */
+		const shortHandedExports = [];
+		/** @type {[string, string][]} */
 		const exports = [];
 		const isAsync = moduleGraph.isAsync(module);
+
+		const treatAsCommonJs =
+			module.buildMeta && module.buildMeta.treatAsCommonJs;
+		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
+
 		if (isAsync) {
 			result.add(
 				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
 			);
 		}
-		for (const exportInfo of exportsInfo.orderedExports) {
+
+		outer: for (const exportInfo of exportsInfo) {
 			if (!exportInfo.provided) continue;
-			const varName = `${RuntimeGlobals.exports}${Template.toIdentifier(
-				exportInfo.name
-			)}`;
+
+			const originalName = exportInfo.name;
+
+			if (skipRenderDefaultExport && originalName === "default") continue;
+
+			const target = exportInfo.findTarget(moduleGraph, (_m) => true);
+			if (target) {
+				const reexportsInfo = moduleGraph.getExportsInfo(target.module);
+
+				for (const reexportInfo of reexportsInfo.orderedExports) {
+					if (
+						reexportInfo.provided === false &&
+						reexportInfo.name !== "default" &&
+						reexportInfo.name === /** @type {string[]} */ (target.export)[0]
+					) {
+						continue outer;
+					}
+				}
+			}
+
+			const usedName =
+				/** @type {string} */
+				(exportInfo.getUsedName(originalName, chunk.runtime));
+			/** @type {string | undefined} */
+			const definition = definitions[usedName];
+
+			/** @type {string | undefined} */
+			let finalName;
+
+			if (definition) {
+				finalName = definition;
+			} else {
+				finalName = `${RuntimeGlobals.exports}${Template.toIdentifier(originalName)}`;
+				result.add(
+					`${runtimeTemplate.renderConst()} ${finalName} = ${RuntimeGlobals.exports}${propertyAccess(
+						[usedName]
+					)};\n`
+				);
+			}
+
+			if (
+				finalName &&
+				(finalName.includes(".") ||
+					finalName.includes("[") ||
+					finalName.includes("("))
+			) {
+				if (exportInfo.isReexport()) {
+					const { data } = codeGenerationResults.get(module, chunk.runtime);
+					const topLevelDeclarations =
+						(data && data.get("topLevelDeclarations")) ||
+						(module.buildInfo && module.buildInfo.topLevelDeclarations);
+
+					if (topLevelDeclarations && topLevelDeclarations.has(originalName)) {
+						const name = `${RuntimeGlobals.exports}${Template.toIdentifier(originalName)}`;
+						result.add(
+							`${runtimeTemplate.renderConst()} ${name} = ${finalName};\n`
+						);
+						shortHandedExports.push(`${name} as ${originalName}`);
+					} else {
+						exports.push([originalName, finalName]);
+					}
+				} else {
+					exports.push([originalName, finalName]);
+				}
+			} else {
+				shortHandedExports.push(
+					definition && finalName === originalName
+						? finalName
+						: `${finalName} as ${originalName}`
+				);
+			}
+		}
+
+		if (treatAsCommonJs) {
+			shortHandedExports.push(`${RuntimeGlobals.exports} as default`);
+		}
+
+		if (shortHandedExports.length > 0) {
+			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
+		}
+
+		for (const [exportName, final] of exports) {
 			result.add(
-				`var ${varName} = ${RuntimeGlobals.exports}${propertyAccess([
-					/** @type {string} */
-					(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
-				])};\n`
+				`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
 			);
-			exports.push(`${varName} as ${exportInfo.name}`);
-		}
-		if (exports.length > 0) {
-			result.add(`export { ${exports.join(", ")} };\n`);
 		}
+
 		return result;
 	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleRenderContext} renderContext render context
+	 * @param {Omit<LibraryContext<T>, "options">} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderModuleContent(
+		source,
+		module,
+		{ factory, inlinedInIIFE, chunk },
+		libraryContext
+	) {
+		const exportsSource =
+			module.buildMeta &&
+			module.buildMeta.exportsSourceByRuntime &&
+			module.buildMeta.exportsSourceByRuntime.get(chunk.runtime);
+
+		// Re-add the module's exports source when rendered in factory or as an inlined startup module wrapped in an IIFE
+		if ((inlinedInIIFE || factory) && exportsSource) {
+			return new ConcatSource(exportsSource, source);
+		}
+		return source;
+	}
 }
 
 module.exports = ModuleLibraryPlugin;

package/lib/library/SystemLibraryPlugin.js

@@ -17,10 +17,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
+ */
 
 /**
  * @typedef {object} SystemLibraryPluginOptions
@@ -73,7 +75,9 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule && m.externalType === "system");
+			.filter(
+				(m) => m instanceof ExternalModule && m.externalType === "system"
+			);
 		const externals = /** @type {ExternalModule[]} */ (modules);
 
 		// The name this bundle should be registered as with System
@@ -83,7 +87,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 
 		// The array of dependencies that are external to webpack and will be provided by System
 		const systemDependencies = JSON.stringify(
-			externals.map(m =>
+			externals.map((m) =>
 				typeof m.request === "object" && !Array.isArray(m.request)
 					? m.request.amd
 					: m.request
@@ -95,7 +99,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 
 		// An array of the internal variable names for the webpack externals
 		const externalWebpackNames = externals.map(
-			m =>
+			(m) =>
 				`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
 					`${chunkGraph.getModuleId(m)}`
 				)}__`
@@ -103,7 +107,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 
 		// Declaring variables for the internal variable names for the webpack externals
 		const externalVarDeclarations = externalWebpackNames
-			.map(name => `var ${name} = {};`)
+			.map((name) => `var ${name} = {};`)
 			.join("\n");
 
 		// Define __esModule flag on all internal variables and helpers
@@ -133,11 +137,21 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 										);
 										if (used) {
 											if (otherUnused || used !== exportInfo.name) {
-												instructions.push(
-													`${external}${propertyAccess([
-														used
-													])} = module${propertyAccess([exportInfo.name])};`
-												);
+												if (exportInfo.name === "default") {
+													// Ideally we should use `module && module.__esModule ? module['default'] : module`
+													// But we need to keep compatibility with SystemJS format libraries (they are using `default`) and bundled SystemJS libraries from commonjs format
+													instructions.push(
+														`${external}${propertyAccess([
+															used
+														])} = module["default"] || module;`
+													);
+												} else {
+													instructions.push(
+														`${external}${propertyAccess([
+															used
+														])} = module${propertyAccess([exportInfo.name])};`
+													);
+												}
 												handledNames.push(exportInfo.name);
 											}
 										} else {
@@ -153,6 +167,10 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 												`Object.defineProperty(${external}, "__esModule", { value: true });`
 											);
 										}
+										// See comment above
+										instructions.push(
+											`${external}["default"] = module["default"] || module;`
+										);
 										if (handledNames.length > 0) {
 											const name = `${external}handledNames`;
 											externalVarInitialization.push(

package/lib/library/UmdLibraryPlugin.js

@@ -16,26 +16,26 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../ExternalModule").RequestRecord} RequestRecord */
-/** @typedef {import("../util/Hash")} Hash */
+
 /**
  * @template T
- * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>}
- * LibraryContext<T>
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T>
  */
 
 /**
  * @param {string[]} accessor the accessor to convert to path
  * @returns {string} the path
  */
-const accessorToObjectAccess = accessor =>
-	accessor.map(a => `[${JSON.stringify(a)}]`).join("");
+const accessorToObjectAccess = (accessor) =>
+	accessor.map((a) => `[${JSON.stringify(a)}]`).join("");
+
+/** @typedef {string | string[]} Accessor */
 
 /**
- * @param {string|undefined} base the path prefix
- * @param {string|string[]} accessor the accessor
+ * @param {string | undefined} base the path prefix
+ * @param {Accessor} accessor the accessor
  * @param {string=} joinWith the element separator
  * @returns {string} the path
  */
@@ -47,15 +47,14 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 				? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
 				: accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
 			if (idx === accessors.length - 1) return a;
-			if (idx === 0 && base === undefined)
+			if (idx === 0 && base === undefined) {
 				return `${a} = typeof ${a} === "object" ? ${a} : {}`;
+			}
 			return `${a} = ${a} || {}`;
 		})
 		.join(joinWith);
 };
 
-/** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
-
 /**
  * @typedef {object} UmdLibraryPluginOptions
  * @property {LibraryType} type
@@ -130,7 +129,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
 			.filter(
-				m =>
+				(m) =>
 					m instanceof ExternalModule &&
 					(m.externalType === "umd" || m.externalType === "umd2")
 			);
@@ -147,7 +146,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 					requiredExternals.push(m);
 				}
 			}
-			externals = requiredExternals.concat(optionalExternals);
+			externals = [...requiredExternals, ...optionalExternals];
 		} else {
 			requiredExternals = externals;
 		}
@@ -156,7 +155,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {string} str the string to replace
 		 * @returns {string} the replaced keys
 		 */
-		const replaceKeys = str =>
+		const replaceKeys = (str) =>
 			compilation.getPath(str, {
 				chunk
 			});
@@ -165,10 +164,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
-		const externalsDepsArray = modules =>
+		const externalsDepsArray = (modules) =>
 			`[${replaceKeys(
 				modules
-					.map(m =>
+					.map((m) =>
 						JSON.stringify(
 							typeof m.request === "object"
 								? /** @type {RequestRecord} */
@@ -183,16 +182,19 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
-		const externalsRootArray = modules =>
+		const externalsRootArray = (modules) =>
 			replaceKeys(
 				modules
-					.map(m => {
+					.map((m) => {
 						let request = m.request;
-						if (typeof request === "object")
+						if (typeof request === "object") {
 							request =
 								/** @type {RequestRecord} */
 								(request).root;
-						return `root${accessorToObjectAccess(/** @type {string[]} */ ([]).concat(request))}`;
+						}
+						return `root${accessorToObjectAccess([
+							...(Array.isArray(request) ? request : [request])
+						])}`;
 					})
 					.join(", ")
 			);
@@ -201,10 +203,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {string} type the type
 		 * @returns {string} external require array
 		 */
-		const externalsRequireArray = type =>
+		const externalsRequireArray = (type) =>
 			replaceKeys(
 				externals
-					.map(m => {
+					.map((m) => {
 						let expr;
 						let request = m.request;
 						if (typeof request === "object") {
@@ -234,10 +236,10 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} arguments
 		 */
-		const externalsArguments = modules =>
+		const externalsArguments = (modules) =>
 			modules
 				.map(
-					m =>
+					(m) =>
 						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
 							`${chunkGraph.getModuleId(m)}`
 						)}__`
@@ -245,14 +247,14 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 				.join(", ");
 
 		/**
-		 * @param {string| string[]} library library name
+		 * @param {Accessor} library library name
 		 * @returns {string} stringified library name
 		 */
-		const libraryName = library =>
+		const libraryName = (library) =>
 			JSON.stringify(
 				replaceKeys(
 					/** @type {string} */
-					(/** @type {string[]} */ ([]).concat(library).pop())
+					([...(Array.isArray(library) ? library : [library])].pop())
 				)
 			);
 
@@ -279,10 +281,11 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {keyof LibraryCustomUmdCommentObject} type type
 		 * @returns {string} comment
 		 */
-		const getAuxiliaryComment = type => {
+		const getAuxiliaryComment = (type) => {
 			if (auxiliaryComment) {
-				if (typeof auxiliaryComment === "string")
+				if (typeof auxiliaryComment === "string") {
 					return `\t//${auxiliaryComment}\n`;
+				}
 				if (auxiliaryComment[type]) return `\t//${auxiliaryComment[type]}\n`;
 			}
 			return "";
@@ -315,7 +318,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 									"commonjs"
 								)}	else if(typeof exports === 'object')\n` +
 								`		exports[${libraryName(
-									/** @type {string | string[]} */
+									/** @type {Accessor} */
 									(names.commonjs || names.root)
 								)}] = factory(${externalsRequireArray(
 									"commonjs"
@@ -323,7 +326,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 								`		${replaceKeys(
 									accessorAccess(
 										"root",
-										/** @type {string | string[]} */
+										/** @type {Accessor} */
 										(names.root || names.commonjs)
 									)
 								)} = factory(${externalsRootArray(externals)});\n`
@@ -335,7 +338,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 										: "		var a = factory();\n"
 								}		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n` +
 								"	}\n"
-					}})(${runtimeTemplate.outputOptions.globalObject}, ${
+					}})(${runtimeTemplate.globalObject}, ${
 						runtimeTemplate.supportsArrowFunction()
 							? `(${externalsArguments(externals)}) =>`
 							: `function(${externalsArguments(externals)})`