webpack 5.92.1 → 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

@@ -58,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
 		};
 	}
 

package/lib/library/SystemLibraryPlugin.js

@@ -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
 		};
 	}
 

package/lib/library/UmdLibraryPlugin.js

@@ -30,9 +30,8 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * @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
@@ -157,18 +156,17 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		 * @param {string} str the string to replace
 		 * @returns {string} the replaced keys
 		 */
-		const replaceKeys = str => {
-			return compilation.getPath(str, {
+		const replaceKeys = str =>
+			compilation.getPath(str, {
 				chunk
 			});
-		};
 
 		/**
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
-		const externalsDepsArray = modules => {
-			return `[${replaceKeys(
+		const externalsDepsArray = modules =>
+			`[${replaceKeys(
 				modules
 					.map(m =>
 						JSON.stringify(
@@ -180,14 +178,13 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 					)
 					.join(", ")
 			)}]`;
-		};
 
 		/**
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} result
 		 */
-		const externalsRootArray = modules => {
-			return replaceKeys(
+		const externalsRootArray = modules =>
+			replaceKeys(
 				modules
 					.map(m => {
 						let request = m.request;
@@ -199,14 +196,13 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 					})
 					.join(", ")
 			);
-		};
 
 		/**
 		 * @param {string} type the type
 		 * @returns {string} external require array
 		 */
-		const externalsRequireArray = type => {
-			return replaceKeys(
+		const externalsRequireArray = type =>
+			replaceKeys(
 				externals
 					.map(m => {
 						let expr;
@@ -218,16 +214,14 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						}
 						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) {} }())`;
 						}
@@ -235,14 +229,13 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 					})
 					.join(", ")
 			);
-		};
 
 		/**
 		 * @param {ExternalModule[]} modules external modules
 		 * @returns {string} arguments
 		 */
-		const externalsArguments = modules => {
-			return modules
+		const externalsArguments = modules =>
+			modules
 				.map(
 					m =>
 						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
@@ -250,26 +243,24 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 						)}__`
 				)
 				.join(", ");
-		};
 
 		/**
 		 * @param {string| string[]} library library name
 		 * @returns {string} stringified library name
 		 */
-		const libraryName = library => {
-			return JSON.stringify(
+		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` +
@@ -288,72 +279,55 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 		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 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)})`

package/lib/logging/Logger.js

@@ -27,7 +27,7 @@ const LogType = Object.freeze({
 	status: /** @type {"status"} */ ("status") // message, arguments
 });
 
-exports.LogType = LogType;
+module.exports.LogType = LogType;
 
 /** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
 
@@ -45,26 +45,45 @@ class WebpackLogger {
 		this.getChildLogger = getChildLogger;
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	error(...args) {
 		this[LOG_SYMBOL](LogType.error, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	warn(...args) {
 		this[LOG_SYMBOL](LogType.warn, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	info(...args) {
 		this[LOG_SYMBOL](LogType.info, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	log(...args) {
 		this[LOG_SYMBOL](LogType.log, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	debug(...args) {
 		this[LOG_SYMBOL](LogType.debug, args);
 	}
 
+	/**
+	 * @param {any} assertion assertion
+	 * @param {...any} args args
+	 */
 	assert(assertion, ...args) {
 		if (!assertion) {
 			this[LOG_SYMBOL](LogType.error, args);
@@ -79,20 +98,29 @@ class WebpackLogger {
 		this[LOG_SYMBOL](LogType.clear);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	status(...args) {
 		this[LOG_SYMBOL](LogType.status, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	group(...args) {
 		this[LOG_SYMBOL](LogType.group, args);
 	}
 
+	/**
+	 * @param {...any} args args
+	 */
 	groupCollapsed(...args) {
 		this[LOG_SYMBOL](LogType.groupCollapsed, args);
 	}
 
-	groupEnd(...args) {
-		this[LOG_SYMBOL](LogType.groupEnd, args);
+	groupEnd() {
+		this[LOG_SYMBOL](LogType.groupEnd);
 	}
 
 	/**
@@ -185,4 +213,4 @@ class WebpackLogger {
 	}
 }
 
-exports.Logger = WebpackLogger;
+module.exports.Logger = WebpackLogger;

package/lib/logging/createConsoleLogger.js

@@ -12,7 +12,7 @@ const { LogType } = require("./Logger");
 /** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
 
 /** @typedef {function(string): boolean} FilterFunction */
-/** @typedef {function(string, LogTypeEnum, any[]): void} LoggingFunction */
+/** @typedef {function(string, LogTypeEnum, any[]=): void} LoggingFunction */
 
 /**
  * @typedef {object} LoggerConsole
@@ -95,7 +95,7 @@ module.exports = ({ level = "info", debug = false, console }) => {
 	/**
 	 * @param {string} name name of the logger
 	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {any[]} args arguments of the log entry
+	 * @param {any[]=} args arguments of the log entry
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {
@@ -103,12 +103,10 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			if (Array.isArray(args)) {
 				if (args.length > 0 && typeof args[0] === "string") {
 					return [`[${name}] ${args[0]}`, ...args.slice(1)];
-				} else {
-					return [`[${name}]`, ...args];
 				}
-			} else {
-				return [];
+				return [`[${name}]`, ...args];
 			}
+			return [];
 		};
 		const debug = debugFilters.some(f => f(name));
 		switch (type) {
@@ -167,8 +165,11 @@ module.exports = ({ level = "info", debug = false, console }) => {
 				break;
 			case LogType.time: {
 				if (!debug && loglevel > LogLevel.log) return;
-				const ms = args[1] * 1000 + args[2] / 1000000;
-				const msg = `[${name}] ${args[0]}: ${ms} ms`;
+				const [label, start, end] =
+					/** @type {[string, number, number]} */
+					(args);
+				const ms = start * 1000 + end / 1000000;
+				const msg = `[${name}] ${label}: ${ms} ms`;
 				if (typeof console.logTime === "function") {
 					console.logTime(msg);
 				} else {
@@ -195,15 +196,13 @@ module.exports = ({ level = "info", debug = false, console }) => {
 			case LogType.status:
 				if (!debug && loglevel > LogLevel.info) return;
 				if (typeof console.status === "function") {
-					if (args.length === 0) {
+					if (!args || args.length === 0) {
 						console.status();
 					} else {
 						console.status(...labeledArgs());
 					}
-				} else {
-					if (args.length !== 0) {
-						console.info(...labeledArgs());
-					}
+				} else if (args && args.length !== 0) {
+					console.info(...labeledArgs());
 				}
 				break;
 			default:

package/lib/logging/runtime.js

@@ -10,7 +10,7 @@ const { Logger } = require("./Logger");
 const createConsoleLogger = require("./createConsoleLogger");
 
 /** @type {createConsoleLogger.LoggerOptions} */
-let currentDefaultLoggerOptions = {
+const currentDefaultLoggerOptions = {
 	level: "info",
 	debug: false,
 	console
@@ -21,26 +21,25 @@ let currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
  * @param {string} name name of the logger
  * @returns {Logger} a logger
  */
-exports.getLogger = name => {
-	return new Logger(
+module.exports.getLogger = name =>
+	new Logger(
 		(type, args) => {
-			if (exports.hooks.log.call(name, type, args) === undefined) {
+			if (module.exports.hooks.log.call(name, type, args) === undefined) {
 				currentDefaultLogger(name, type, args);
 			}
 		},
-		childName => exports.getLogger(`${name}/${childName}`)
+		childName => module.exports.getLogger(`${name}/${childName}`)
 	);
-};
 
 /**
  * @param {createConsoleLogger.LoggerOptions} options new options, merge with old options
  * @returns {void}
  */
-exports.configureDefaultLogger = options => {
+module.exports.configureDefaultLogger = options => {
 	Object.assign(currentDefaultLoggerOptions, options);
 	currentDefaultLogger = createConsoleLogger(currentDefaultLoggerOptions);
 };
 
-exports.hooks = {
+module.exports.hooks = {
 	log: new SyncBailHook(["origin", "type", "args"])
 };

package/lib/logging/truncateArgs.js

@@ -28,17 +28,15 @@ const truncateArgs = (args, maxLength) => {
 		if (availableLength >= args[0].length) {
 			return args;
 		} else if (availableLength > 3) {
-			return ["..." + args[0].slice(-availableLength + 3)];
-		} else {
-			return [args[0].slice(-availableLength)];
+			return [`...${args[0].slice(-availableLength + 3)}`];
 		}
+		return [args[0].slice(-availableLength)];
 	}
 
 	// Check if there is space for at least 4 chars per arg
 	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
 		// remove args
-		if (args.length > 1)
-			return truncateArgs(args.slice(0, args.length - 1), maxLength);
+		if (args.length > 1) return truncateArgs(args.slice(0, -1), maxLength);
 		return [];
 	}
 
@@ -74,12 +72,11 @@ const truncateArgs = (args, maxLength) => {
 		if (str.length === length) {
 			return str;
 		} else if (length > 5) {
-			return "..." + str.slice(-length + 3);
+			return `...${str.slice(-length + 3)}`;
 		} else if (length > 0) {
 			return str.slice(-length);
-		} else {
-			return "";
 		}
+		return "";
 	});
 };