webpack 5.59.0 → 5.94.0

package/lib/library/ModernModuleLibraryPlugin.js

@@ -0,0 +1,144 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { ConcatSource } = require("webpack-sources");
+const ConcatenatedModule = require("../optimize/ConcatenatedModule");
+const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @typedef {object} ModernModuleLibraryPluginOptions
+ * @property {LibraryType} type
+ */
+
+/**
+ * @typedef {object} ModernModuleLibraryPluginParsed
+ * @property {string} name
+ */
+
+/**
+ * @typedef {ModernModuleLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ModernModuleLibraryPluginParsed>}
+ */
+class ModernModuleLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		super.apply(compiler);
+
+		compiler.hooks.compilation.tap("ModernModuleLibraryPlugin", compilation => {
+			const { exportsDefinitions } =
+				ConcatenatedModule.getCompilationHooks(compilation);
+			exportsDefinitions.tap("ModernModuleLibraryPlugin", () => true);
+		});
+	}
+
+	/**
+	 * @param {ModernModuleLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "ModernModuleLibraryPlugin",
+			type: options.type
+		});
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name) {
+			throw new Error(
+				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		const _name = /** @type {string} */ (name);
+		return {
+			name: _name
+		};
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const result = new ConcatSource(source);
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const definitions =
+			/** @type {BuildMeta} */
+			(module.buildMeta).exportsFinalName;
+		const exports = [];
+
+		for (const exportInfo of exportsInfo.orderedExports) {
+			let shouldContinue = false;
+			const reexport = exportInfo.findTarget(moduleGraph, _m => true);
+
+			if (reexport) {
+				const exp = moduleGraph.getExportsInfo(reexport.module);
+
+				for (const reexportInfo of exp.orderedExports) {
+					if (
+						!reexportInfo.provided &&
+						reexportInfo.name === /** @type {string[]} */ (reexport.export)[0]
+					) {
+						shouldContinue = true;
+					}
+				}
+			}
+
+			if (shouldContinue) continue;
+
+			const webpackExportsProperty = exportInfo.getUsedName(
+				exportInfo.name,
+				chunk.runtime
+			);
+			const finalName =
+				definitions[
+					/** @type {string} */
+					(webpackExportsProperty)
+				];
+			exports.push(
+				finalName === exportInfo.name
+					? finalName
+					: `${finalName} as ${exportInfo.name}`
+			);
+		}
+
+		if (exports.length > 0) {
+			result.add(`export { ${exports.join(", ")} };\n`);
+		}
+
+		return result;
+	}
+}
+
+module.exports = ModernModuleLibraryPlugin;

package/lib/library/ModuleLibraryPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const propertyAccess = require("../util/propertyAccess");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
@@ -22,12 +23,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} ModuleLibraryPluginOptions
+ * @typedef {object} ModuleLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
- * @typedef {Object} ModuleLibraryPluginParsed
+ * @typedef {object} ModuleLibraryPluginParsed
  * @property {string} name
  */
 
@@ -57,8 +58,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 			);
 		}
+		const _name = /** @type {string} */ (name);
 		return {
-			name: /** @type {string} */ (name)
+			name: _name
 		};
 	}
 
@@ -80,16 +82,19 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const exports = [];
 		const isAsync = moduleGraph.isAsync(module);
 		if (isAsync) {
-			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
+			result.add(
+				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
+			);
 		}
 		for (const exportInfo of exportsInfo.orderedExports) {
 			if (!exportInfo.provided) continue;
-			const varName = `__webpack_exports__${Template.toIdentifier(
+			const varName = `${RuntimeGlobals.exports}${Template.toIdentifier(
 				exportInfo.name
 			)}`;
 			result.add(
-				`var ${varName} = __webpack_exports__${propertyAccess([
-					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+				`var ${varName} = ${RuntimeGlobals.exports}${propertyAccess([
+					/** @type {string} */
+					(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
 				])};\n`
 			);
 			exports.push(`${varName} as ${exportInfo.name}`);

package/lib/library/SystemLibraryPlugin.js

@@ -23,12 +23,12 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} SystemLibraryPluginOptions
+ * @typedef {object} SystemLibraryPluginOptions
  * @property {LibraryType} type
  */
 
 /**
- * @typedef {Object} SystemLibraryPluginParsed
+ * @typedef {object} SystemLibraryPluginParsed
  * @property {string} name
  */
 
@@ -58,8 +58,9 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
 			);
 		}
+		const _name = /** @type {string} */ (name);
 		return {
-			name: /** @type {string=} */ (name)
+			name: _name
 		};
 	}
 
@@ -106,6 +107,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 			.join("\n");
 
 		// Define __esModule flag on all internal variables and helpers
+		/** @type {string[]} */
 		const externalVarInitialization = [];
 
 		// The system.register format requires an array of setter functions for externals.
@@ -186,7 +188,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 								.join(",\n")
 						),
 						"],"
-				  ]);
+					]);
 
 		return new ConcatSource(
 			Template.asString([

package/lib/library/UmdLibraryPlugin.js

@@ -18,16 +18,20 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @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> */
+/**
+ * @template T
+ * @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>}
+ * LibraryContext<T>
+ */
 
 /**
  * @param {string[]} accessor the accessor to convert to path
  * @returns {string} the path
  */
-const accessorToObjectAccess = accessor => {
-	return accessor.map(a => `[${JSON.stringify(a)}]`).join("");
-};
+const accessorToObjectAccess = accessor =>
+	accessor.map(a => `[${JSON.stringify(a)}]`).join("");
 
 /**
  * @param {string|undefined} base the path prefix
@@ -53,13 +57,13 @@ const accessorAccess = (base, accessor, joinWith = ", ") => {
 /** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
 
 /**
- * @typedef {Object} UmdLibraryPluginOptions
+ * @typedef {object} UmdLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean=} optionalAmdExternalAsGlobal
  */
 
 /**
- * @typedef {Object} UmdLibraryPluginParsed
+ * @typedef {object} UmdLibraryPluginParsed
  * @property {string | string[]} name
  * @property {LibraryCustomUmdObject} names
  * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
@@ -148,57 +152,76 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			requiredExternals = externals;
 		}
 
-		const replaceKeys = str => {
-			return compilation.getPath(str, {
+		/**
+		 * @param {string} str the string to replace
+		 * @returns {string} the replaced keys
+		 */
+		const replaceKeys = str =>
+			compilation.getPath(str, {
 				chunk
 			});
-		};
 
-		const externalsDepsArray = modules => {
-			return `[${replaceKeys(
+		/**
+		 * @param {ExternalModule[]} modules external modules
+		 * @returns {string} result
+		 */
+		const externalsDepsArray = modules =>
+			`[${replaceKeys(
 				modules
 					.map(m =>
 						JSON.stringify(
-							typeof m.request === "object" ? m.request.amd : m.request
+							typeof m.request === "object"
+								? /** @type {RequestRecord} */
+									(m.request).amd
+								: m.request
 						)
 					)
 					.join(", ")
 			)}]`;
-		};
 
-		const externalsRootArray = modules => {
-			return replaceKeys(
+		/**
+		 * @param {ExternalModule[]} modules external modules
+		 * @returns {string} result
+		 */
+		const externalsRootArray = modules =>
+			replaceKeys(
 				modules
 					.map(m => {
 						let request = m.request;
-						if (typeof request === "object") request = request.root;
+						if (typeof request === "object")
+							request =
+								/** @type {RequestRecord} */
+								(request).root;
 						return `root${accessorToObjectAccess([].concat(request))}`;
 					})
 					.join(", ")
 			);
-		};
 
-		const externalsRequireArray = type => {
-			return replaceKeys(
+		/**
+		 * @param {string} type the type
+		 * @returns {string} external require array
+		 */
+		const externalsRequireArray = type =>
+			replaceKeys(
 				externals
 					.map(m => {
 						let expr;
 						let request = m.request;
 						if (typeof request === "object") {
-							request = request[type];
+							request =
+								/** @type {RequestRecord} */
+								(request)[type];
 						}
 						if (request === undefined) {
 							throw new Error(
-								"Missing external configuration for type:" + type
+								`Missing external configuration for type:${type}`
 							);
 						}
-						if (Array.isArray(request)) {
-							expr = `require(${JSON.stringify(
-								request[0]
-							)})${accessorToObjectAccess(request.slice(1))}`;
-						} else {
-							expr = `require(${JSON.stringify(request)})`;
-						}
+						expr = Array.isArray(request)
+							? `require(${JSON.stringify(
+									request[0]
+								)})${accessorToObjectAccess(request.slice(1))}`
+							: `require(${JSON.stringify(request)})`;
 						if (m.isOptional(moduleGraph)) {
 							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
 						}
@@ -206,10 +229,13 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 					})
 					.join(", ")
 			);
-		};
 
-		const externalsArguments = modules => {
-			return modules
+		/**
+		 * @param {ExternalModule[]} modules external modules
+		 * @returns {string} arguments
+		 */
+		const externalsArguments = modules =>
+			modules
 				.map(
 					m =>
 						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
@@ -217,20 +243,24 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						)}__`
 				)
 				.join(", ");
-		};
 
-		const libraryName = library => {
-			return JSON.stringify(replaceKeys([].concat(library).pop()));
-		};
+		/**
+		 * @param {string| string[]} library library name
+		 * @returns {string} stringified library name
+		 */
+		const libraryName = library =>
+			JSON.stringify(
+				replaceKeys(/** @type {string[]} */ ([]).concat(library).pop())
+			);
 
 		let amdFactory;
 		if (optionalExternals.length > 0) {
 			const wrapperArguments = externalsArguments(requiredExternals);
 			const factoryArguments =
 				requiredExternals.length > 0
-					? externalsArguments(requiredExternals) +
-					  ", " +
-					  externalsRootArray(optionalExternals)
+					? `${externalsArguments(requiredExternals)}, ${externalsRootArray(
+							optionalExternals
+						)}`
 					: externalsRootArray(optionalExternals);
 			amdFactory =
 				`function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
@@ -242,77 +272,66 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 
 		const { auxiliaryComment, namedDefine, names } = options;
 
+		/**
+		 * @param {keyof LibraryCustomUmdCommentObject} type type
+		 * @returns {string} comment
+		 */
 		const getAuxiliaryComment = type => {
 			if (auxiliaryComment) {
 				if (typeof auxiliaryComment === "string")
-					return "\t//" + auxiliaryComment + "\n";
-				if (auxiliaryComment[type])
-					return "\t//" + auxiliaryComment[type] + "\n";
+					return `\t//${auxiliaryComment}\n`;
+				if (auxiliaryComment[type]) return `\t//${auxiliaryComment[type]}\n`;
 			}
 			return "";
 		};
 
 		return new ConcatSource(
 			new OriginalSource(
-				"(function webpackUniversalModuleDefinition(root, factory) {\n" +
-					getAuxiliaryComment("commonjs2") +
-					"	if(typeof exports === 'object' && typeof module === 'object')\n" +
-					"		module.exports = factory(" +
-					externalsRequireArray("commonjs2") +
-					");\n" +
-					getAuxiliaryComment("amd") +
-					"	else if(typeof define === 'function' && define.amd)\n" +
-					(requiredExternals.length > 0
-						? names.amd && namedDefine === true
-							? "		define(" +
-							  libraryName(names.amd) +
-							  ", " +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-							: "		define(" +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-						: names.amd && namedDefine === true
-						? "		define(" +
-						  libraryName(names.amd) +
-						  ", [], " +
-						  amdFactory +
-						  ");\n"
-						: "		define([], " + amdFactory + ");\n") +
-					(names.root || names.commonjs
-						? getAuxiliaryComment("commonjs") +
-						  "	else if(typeof exports === 'object')\n" +
-						  "		exports[" +
-						  libraryName(names.commonjs || names.root) +
-						  "] = factory(" +
-						  externalsRequireArray("commonjs") +
-						  ");\n" +
-						  getAuxiliaryComment("root") +
-						  "	else\n" +
-						  "		" +
-						  replaceKeys(
-								accessorAccess("root", names.root || names.commonjs)
-						  ) +
-						  " = factory(" +
-						  externalsRootArray(externals) +
-						  ");\n"
-						: "	else {\n" +
-						  (externals.length > 0
-								? "		var a = typeof exports === 'object' ? factory(" +
-								  externalsRequireArray("commonjs") +
-								  ") : factory(" +
-								  externalsRootArray(externals) +
-								  ");\n"
-								: "		var a = factory();\n") +
-						  "		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
-						  "	}\n") +
-					`})(${
-						runtimeTemplate.outputOptions.globalObject
-					}, function(${externalsArguments(externals)}) {\nreturn `,
+				`(function webpackUniversalModuleDefinition(root, factory) {\n${getAuxiliaryComment(
+					"commonjs2"
+				)}	if(typeof exports === 'object' && typeof module === 'object')\n` +
+					`		module.exports = factory(${externalsRequireArray(
+						"commonjs2"
+					)});\n${getAuxiliaryComment(
+						"amd"
+					)}	else if(typeof define === 'function' && define.amd)\n${
+						requiredExternals.length > 0
+							? names.amd && namedDefine === true
+								? `		define(${libraryName(names.amd)}, ${externalsDepsArray(
+										requiredExternals
+									)}, ${amdFactory});\n`
+								: `		define(${externalsDepsArray(requiredExternals)}, ${
+										amdFactory
+									});\n`
+							: names.amd && namedDefine === true
+								? `		define(${libraryName(names.amd)}, [], ${amdFactory});\n`
+								: `		define([], ${amdFactory});\n`
+					}${
+						names.root || names.commonjs
+							? `${getAuxiliaryComment(
+									"commonjs"
+								)}	else if(typeof exports === 'object')\n` +
+								`		exports[${libraryName(
+									names.commonjs || names.root
+								)}] = factory(${externalsRequireArray(
+									"commonjs"
+								)});\n${getAuxiliaryComment("root")}	else\n` +
+								`		${replaceKeys(
+									accessorAccess("root", names.root || names.commonjs)
+								)} = factory(${externalsRootArray(externals)});\n`
+							: `	else {\n${
+									externals.length > 0
+										? `		var a = typeof exports === 'object' ? factory(${externalsRequireArray(
+												"commonjs"
+											)}) : factory(${externalsRootArray(externals)});\n`
+										: "		var a = factory();\n"
+								}		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n` +
+								"	}\n"
+					}})(${runtimeTemplate.outputOptions.globalObject}, ${
+						runtimeTemplate.supportsArrowFunction()
+							? `(${externalsArguments(externals)}) =>`
+							: `function(${externalsArguments(externals)})`
+					} {\nreturn `,
 				"webpack/universalModuleDefinition"
 			),
 			source,