webpack 5.104.1 → 5.105.0

package/lib/library/ModuleLibraryPlugin.js

@@ -7,11 +7,13 @@
 
 const { ConcatSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
+const ExternalModule = require("../ExternalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const ConcatenatedModule = require("../optimize/ConcatenatedModule");
 const propertyAccess = require("../util/propertyAccess");
-const { getEntryRuntime } = require("../util/runtime");
+const { getEntryRuntime, getRuntimeKey } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -20,11 +22,14 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryExport} LibraryExport */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ModuleRenderContext} ModuleRenderContext */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 /**
  * @template T
@@ -76,17 +81,20 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					/** @type {BuildMeta} */
 					const buildMeta = module.buildMeta || (module.buildMeta = {});
 
+					/** @type {BuildMeta["exportsSourceByRuntime"]} */
 					const exportsSourceByRuntime =
 						buildMeta.exportsSourceByRuntime ||
 						(buildMeta.exportsSourceByRuntime = new Map());
 
+					/** @type {BuildMeta["exportsFinalNameByRuntime"]} */
 					const exportsFinalNameByRuntime =
 						buildMeta.exportsFinalNameByRuntime ||
 						(buildMeta.exportsFinalNameByRuntime = new Map());
 
 					for (const runtime of runtimes) {
-						exportsSourceByRuntime.set(runtime, source);
-						exportsFinalNameByRuntime.set(runtime, finalName);
+						const key = getRuntimeKey(runtime);
+						exportsSourceByRuntime.set(key, source);
+						exportsFinalNameByRuntime.set(key, finalName);
 					}
 
 					return true;
@@ -116,8 +124,13 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			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) {
+
+			if (
+				// If the entry module is commonjs, its exports cannot be mangled
+				(module.buildMeta && module.buildMeta.treatAsCommonJs) ||
+				// The entry module provides unknown exports
+				exportsInfo._otherExportsInfo.provided === null
+			) {
 				exportsInfo.setUsedInUnknownWay(runtime);
 			} else {
 				exportsInfo.setAllKnownExportsUsed(runtime);
@@ -128,7 +141,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 	/**
 	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @returns {T} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
 		const { name } = library;
@@ -144,6 +157,94 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		};
 	}
 
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {RuntimeSpec} runtime chunk runtime
+	 * @param {[string, string][]} exports exports
+	 * @param {Set<string>} alreadyRenderedExports already rendered exports
+	 * @returns {ConcatSource} source with null provided exports
+	 */
+	_analyzeUnknownProvidedExports(
+		source,
+		module,
+		moduleGraph,
+		runtime,
+		exports,
+		alreadyRenderedExports
+	) {
+		const result = new ConcatSource(source);
+		/** @type {Set<string>} */
+		const moduleRequests = new Set();
+		/** @type {Map<string, string>} */
+		const unknownProvidedExports = new Map();
+
+		/**
+		 * @param {Module} module the module
+		 * @param {boolean} isDynamicReexport if module is dynamic reexported
+		 */
+		const resolveDynamicStarReexport = (module, isDynamicReexport) => {
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const dep = connection.dependency;
+
+				// Only handle star-reexport statement
+				if (
+					dep instanceof HarmonyExportImportedSpecifierDependency &&
+					dep.name === null
+				) {
+					const importedModule = connection.resolvedModule;
+					const importedModuleExportsInfo =
+						moduleGraph.getExportsInfo(importedModule);
+
+					// The imported module provides unknown exports
+					// So keep the reexports rendered in the bundle
+					if (
+						dep.getMode(moduleGraph, runtime).type === "dynamic-reexport" &&
+						importedModuleExportsInfo._otherExportsInfo.provided === null
+					) {
+						// Handle export * from 'external'
+						if (importedModule instanceof ExternalModule) {
+							moduleRequests.add(importedModule.userRequest);
+						} else {
+							resolveDynamicStarReexport(importedModule, true);
+						}
+					}
+					// If importer modules existing `dynamic-reexport` dependency
+					// We should keep export statement rendered in the bundle
+					else if (isDynamicReexport) {
+						for (const exportInfo of importedModuleExportsInfo.orderedExports) {
+							if (!exportInfo.provided || exportInfo.name === "default") {
+								continue;
+							}
+							const originalName = exportInfo.name;
+							const usedName = exportInfo.getUsedName(originalName, runtime);
+
+							if (!alreadyRenderedExports.has(originalName) && usedName) {
+								unknownProvidedExports.set(originalName, usedName);
+							}
+						}
+					}
+				}
+			}
+		};
+
+		resolveDynamicStarReexport(module, false);
+
+		for (const request of moduleRequests) {
+			result.add(`export * from "${request}";\n`);
+		}
+
+		for (const [origin, used] of unknownProvidedExports) {
+			exports.push([
+				origin,
+				`${RuntimeGlobals.exports}${propertyAccess([used])}`
+			]);
+		}
+
+		return result;
+	}
+
 	/**
 	 * @param {Source} source source
 	 * @param {Module} module module
@@ -164,9 +265,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		},
 		{ options, compilation }
 	) {
-		const result = new ConcatSource(source);
-
-		const exportsInfo = options.export
+		let result = new ConcatSource(source);
+		const exportInfos = options.export
 			? [
 					moduleGraph.getExportInfo(
 						module,
@@ -178,7 +278,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const exportsFinalNameByRuntime =
 			(module.buildMeta &&
 				module.buildMeta.exportsFinalNameByRuntime &&
-				module.buildMeta.exportsFinalNameByRuntime.get(chunk.runtime)) ||
+				module.buildMeta.exportsFinalNameByRuntime.get(
+					getRuntimeKey(chunk.runtime)
+				)) ||
 			{};
 
 		const definitions =
@@ -188,6 +290,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const shortHandedExports = [];
 		/** @type {[string, string][]} */
 		const exports = [];
+		/** @type {Set<string>} */
+		const alreadyRenderedExports = new Set();
+
 		const isAsync = moduleGraph.isAsync(module);
 
 		const treatAsCommonJs =
@@ -200,7 +305,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			);
 		}
 
-		outer: for (const exportInfo of exportsInfo) {
+		outer: for (const exportInfo of exportInfos) {
 			if (!exportInfo.provided) continue;
 
 			const originalName = exportInfo.name;
@@ -273,6 +378,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						: `${finalName} as ${originalName}`
 				);
 			}
+
+			alreadyRenderedExports.add(originalName);
 		}
 
 		if (treatAsCommonJs) {
@@ -283,6 +390,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			result.add(`export { ${shortHandedExports.join(", ")} };\n`);
 		}
 
+		result = this._analyzeUnknownProvidedExports(
+			result,
+			module,
+			moduleGraph,
+			chunk.runtime,
+			exports,
+			alreadyRenderedExports
+		);
+
 		for (const [exportName, final] of exports) {
 			result.add(
 				`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
@@ -308,9 +424,10 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const exportsSource =
 			module.buildMeta &&
 			module.buildMeta.exportsSourceByRuntime &&
-			module.buildMeta.exportsSourceByRuntime.get(chunk.runtime);
+			module.buildMeta.exportsSourceByRuntime.get(getRuntimeKey(chunk.runtime));
 
-		// Re-add the module's exports source when rendered in factory or as an inlined startup module wrapped in an IIFE
+		// 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);
 		}

package/lib/library/SystemLibraryPlugin.js

@@ -17,6 +17,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 /**
@@ -51,7 +52,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 
 	/**
 	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @returns {T} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
 		const { name } = library;
@@ -128,7 +129,9 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 									const otherUnused =
 										exportsInfo.otherExportsInfo.getUsed(chunk.runtime) ===
 										UsageState.Unused;
+									/** @type {string[]} */
 									const instructions = [];
+									/** @type {ExportInfoName[]} */
 									const handledNames = [];
 									for (const exportInfo of exportsInfo.orderedExports) {
 										const used = exportInfo.getUsedName(

package/lib/library/UmdLibraryPlugin.js

@@ -83,12 +83,13 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			type: options.type
 		});
 
+		/** @type {UmdLibraryPluginOptions["optionalAmdExternalAsGlobal"]} */
 		this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
 	}
 
 	/**
 	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @returns {T} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
 		/** @type {LibraryName | undefined} */
@@ -207,7 +208,6 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 			replaceKeys(
 				externals
 					.map((m) => {
-						let expr;
 						let request = m.request;
 						if (typeof request === "object") {
 							request =
@@ -219,7 +219,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 								`Missing external configuration for type:${type}`
 							);
 						}
-						expr = Array.isArray(request)
+						let expr = Array.isArray(request)
 							? `require(${JSON.stringify(
 									request[0]
 								)})${accessorToObjectAccess(request.slice(1))}`
@@ -258,6 +258,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 				)
 			);
 
+		/** @type {string} */
 		let amdFactory;
 		if (optionalExternals.length > 0) {
 			const wrapperArguments = externalsArguments(requiredExternals);

package/lib/logging/createConsoleLogger.js

@@ -99,6 +99,9 @@ module.exports = ({ level = "info", debug = false, console }) => {
 	 * @returns {void}
 	 */
 	const logger = (name, type, args) => {
+		/**
+		 * @returns {[string?, ...EXPECTED_ANY]} labeled args
+		 */
 		const labeledArgs = () => {
 			if (Array.isArray(args)) {
 				if (args.length > 0 && typeof args[0] === "string") {

package/lib/logging/truncateArgs.js

@@ -16,7 +16,7 @@ const arraySum = (array) => {
 };
 
 /**
- * @param {EXPECTED_ANY[]} args items to be truncated
+ * @param {string[]} args items to be truncated
  * @param {number} maxLength maximum length of args including spaces between
  * @returns {string[]} truncated args
  */

package/lib/node/CommonJsChunkLoadingPlugin.js

@@ -57,6 +57,7 @@ class CommonJsChunkLoadingPlugin {
 						: globalChunkLoading;
 				return chunkLoading === chunkLoadingValue;
 			};
+			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
 			 * @param {Chunk} chunk chunk

package/lib/node/NodeTargetPlugin.js

@@ -77,6 +77,7 @@ class NodeTargetPlugin {
 	 * @param {ExternalsType} type default external type
 	 */
 	constructor(type = "node-commonjs") {
+		/** @type {ExternalsType} */
 		this.type = type;
 	}
 

package/lib/node/NodeWatchFileSystem.js

@@ -8,6 +8,7 @@
 const util = require("util");
 const Watchpack = require("watchpack");
 
+/** @typedef {import("watchpack").TimeInfoEntries} TimeInfoEntries */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/fs").WatchMethod} WatchMethod */
 /** @typedef {import("../util/fs").Changes} Changes */
@@ -65,7 +66,9 @@ class NodeWatchFileSystem {
 		}
 
 		const fetchTimeInfo = () => {
+			/** @type {TimeInfoEntries} */
 			const fileTimeInfoEntries = new Map();
+			/** @type {TimeInfoEntries} */
 			const contextTimeInfoEntries = new Map();
 			if (this.watcher) {
 				this.watcher.collectTimeInfoEntries(

package/lib/node/nodeConsole.js

@@ -67,10 +67,11 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	};
 
 	/**
+	 * @template T
 	 * @param {string} prefix prefix
 	 * @param {string} colorPrefix color prefix
 	 * @param {string} colorSuffix color suffix
-	 * @returns {(...args: EXPECTED_ANY[]) => void} function to write with colors
+	 * @returns {(...args: T[]) => void} function to write with colors
 	 */
 	const writeColored =
 		(prefix, colorPrefix, colorSuffix) =>
@@ -87,12 +88,14 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			writeStatusMessage();
 		};
 
+	/** @type {<T extends unknown[]>(...args: T) => void} */
 	const writeGroupMessage = writeColored(
 		"<-> ",
 		"\u001B[1m\u001B[36m",
 		"\u001B[39m\u001B[22m"
 	);
 
+	/** @type {<T extends unknown[]>(...args: T) => void} */
 	const writeGroupCollapsedMessage = writeColored(
 		"<+> ",
 		"\u001B[1m\u001B[36m",
@@ -100,17 +103,25 @@ module.exports = ({ colors, appendOnly, stream }) => {
 	);
 
 	return {
+		/** @type {LoggerConsole["log"]} */
 		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		/** @type {LoggerConsole["debug"]} */
 		debug: writeColored("    ", "", ""),
+		/** @type {LoggerConsole["trace"]} */
 		trace: writeColored("    ", "", ""),
+		/** @type {LoggerConsole["info"]} */
 		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["warn"]} */
 		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["error"]} */
 		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		/** @type {LoggerConsole["logTime"]} */
 		logTime: writeColored(
 			"<t> ",
 			"\u001B[1m\u001B[35m",
 			"\u001B[39m\u001B[22m"
 		),
+		/** @type {LoggerConsole["group"]} */
 		group: (...args) => {
 			writeGroupMessage(...args);
 			if (currentCollapsed > 0) {
@@ -119,10 +130,12 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				currentIndent += "  ";
 			}
 		},
+		/** @type {LoggerConsole["groupCollapsed"]} */
 		groupCollapsed: (...args) => {
 			writeGroupCollapsedMessage(...args);
 			currentCollapsed++;
 		},
+		/** @type {LoggerConsole["groupEnd"]} */
 		groupEnd: () => {
 			if (currentCollapsed > 0) {
 				currentCollapsed--;
@@ -130,8 +143,11 @@ module.exports = ({ colors, appendOnly, stream }) => {
 				currentIndent = currentIndent.slice(0, -2);
 			}
 		},
+		/** @type {LoggerConsole["profile"]} */
 		profile: console.profile && ((name) => console.profile(name)),
+		/** @type {LoggerConsole["profileEnd"]} */
 		profileEnd: console.profileEnd && ((name) => console.profileEnd(name)),
+		/** @type {LoggerConsole["clear"]} */
 		clear:
 			/** @type {() => void} */
 			(
@@ -143,6 +159,7 @@ module.exports = ({ colors, appendOnly, stream }) => {
 						writeStatusMessage();
 					})
 			),
+		/** @type {LoggerConsole["status"]} */
 		status: appendOnly
 			? writeColored("<s> ", "", "")
 			: (name, ...args) => {

package/lib/optimize/AggressiveMergingPlugin.js

@@ -30,6 +30,7 @@ class AggressiveMergingPlugin {
 				"Argument should be an options object. To use defaults, pass in nothing.\nFor more info on options, see https://webpack.js.org/plugins/"
 			);
 		}
+		/** @type {AggressiveMergingPluginOptions} */
 		this.options = options || {};
 	}
 
@@ -50,7 +51,7 @@ class AggressiveMergingPlugin {
 				},
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
-					/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
+					/** @type {{ a: Chunk, b: Chunk, improvement: number }[]} */
 					const combinations = [];
 					for (const a of chunks) {
 						if (a.canBeInitial()) continue;

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -50,7 +50,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => (module) => {
 const isNotAEntryModule = (chunkGraph, chunk) => (module) =>
 	!chunkGraph.isEntryModuleInChunk(module, chunk);
 
-/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: Module[], size: number }} SplitData */
+/** @typedef {{ id?: NonNullable<Chunk["id"]>, hash?: NonNullable<Chunk["hash"]>, modules: string[], size: number }} SplitData */
 
 /** @type {WeakSet<Chunk>} */
 const recordedChunks = new WeakSet();
@@ -114,7 +114,9 @@ class AggressiveSplittingPlugin {
 				(chunks) => {
 					const chunkGraph = compilation.chunkGraph;
 					// Precompute stuff
+					/** @type {Map<string, Module>} */
 					const nameToModuleMap = new Map();
+					/** @type {Map<Module, string>} */
 					const moduleToNameMap = new Map();
 					const makePathsRelative =
 						identifierUtils.makePathsRelative.bindContextCache(
@@ -128,10 +130,10 @@ class AggressiveSplittingPlugin {
 					}
 
 					// Check used chunk ids
-					/** @typedef {Set<ChunkId>} */
+					/** @type {Set<ChunkId>} */
 					const usedIds = new Set();
 					for (const chunk of chunks) {
-						usedIds.add(chunk.id);
+						usedIds.add(/** @type {ChunkId} */ (chunk.id));
 					}
 
 					const recordedSplits =
@@ -154,8 +156,8 @@ class AggressiveSplittingPlugin {
 						}
 
 						// Get module objects from names
-						const selectedModules = splitData.modules.map((name) =>
-							nameToModuleMap.get(name)
+						const selectedModules = splitData.modules.map(
+							(name) => /** @type {Module} */ (nameToModuleMap.get(name))
 						);
 
 						// Does the modules exist at all?
@@ -240,6 +242,7 @@ class AggressiveSplittingPlugin {
 							const modules = chunkGraph
 								.getOrderedChunkModules(chunk, compareModulesByIdentifier)
 								.filter(isNotAEntryModule(chunkGraph, chunk));
+							/** @type {Module[]} */
 							const selectedModules = [];
 							let selectedModulesSize = 0;
 							for (let k = 0; k < modules.length; k++) {
@@ -255,7 +258,7 @@ class AggressiveSplittingPlugin {
 							/** @type {SplitData} */
 							const splitData = {
 								modules: selectedModules
-									.map((m) => moduleToNameMap.get(m))
+									.map((m) => /** @type {string} */ (moduleToNameMap.get(m)))
 									.sort(),
 								size: selectedModulesSize
 							};
@@ -271,6 +274,7 @@ class AggressiveSplittingPlugin {
 			);
 			compilation.hooks.recordHash.tap(PLUGIN_NAME, (records) => {
 				// 4. save made splittings to records
+				/** @type {Set<SplitData>} */
 				const allSplits = new Set();
 				/** @type {Set<SplitData>} */
 				const invalidSplits = new Set();