webpack 5.31.2 → 5.33.2

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -11,6 +11,7 @@ const HarmonyLinkingError = require("../HarmonyLinkingError");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { countIterable } = require("../util/IterableHelpers");
 const { first, combine } = require("../util/SetHelpers");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
@@ -92,6 +93,62 @@ class ExportMode {
 	}
 }
 
+const determineExportAssignments = (
+	moduleGraph,
+	dependencies,
+	additionalDependency
+) => {
+	const names = new Set();
+	const dependencyIndices = [];
+
+	if (additionalDependency) {
+		dependencies = dependencies.concat(additionalDependency);
+	}
+
+	for (const dep of dependencies) {
+		const i = dependencyIndices.length;
+		dependencyIndices[i] = names.size;
+		const otherImportedModule = moduleGraph.getModule(dep);
+		if (otherImportedModule) {
+			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
+			for (const exportInfo of exportsInfo.exports) {
+				if (
+					exportInfo.provided === true &&
+					exportInfo.name !== "default" &&
+					!names.has(exportInfo.name)
+				) {
+					names.add(exportInfo.name);
+					dependencyIndices[i] = names.size;
+				}
+			}
+		}
+	}
+	dependencyIndices.push(names.size);
+
+	return { names: Array.from(names), dependencyIndices };
+};
+
+const findDependencyForName = (
+	{ names, dependencyIndices },
+	name,
+	dependencies
+) => {
+	const dependenciesIt = dependencies[Symbol.iterator]();
+	const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
+	let dependenciesItResult = dependenciesIt.next();
+	let dependencyIndicesItResult = dependencyIndicesIt.next();
+	if (dependencyIndicesItResult.done) return;
+	for (let i = 0; i < names.length; i++) {
+		while (i >= dependencyIndicesItResult.value) {
+			dependenciesItResult = dependenciesIt.next();
+			dependencyIndicesItResult = dependencyIndicesIt.next();
+			if (dependencyIndicesItResult.done) return;
+		}
+		if (names[i] === name) return dependenciesItResult.value;
+	}
+	return undefined;
+};
+
 class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	/**
 	 * @param {string} request the request string
@@ -99,8 +156,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {string[]} ids the requested export name of the imported module
 	 * @param {string | null} name the export name of for this module
 	 * @param {Set<string>} activeExports other named exports in the module
-	 * @param {Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module
+	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
 	 * @param {boolean} strictExportPresence when true, missing exports in the imported module lead to errors instead of warnings
+	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
 	 */
 	constructor(
 		request,
@@ -109,7 +167,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		name,
 		activeExports,
 		otherStarExports,
-		strictExportPresence
+		strictExportPresence,
+		allStarExports
 	) {
 		super(request, sourceOrder);
 
@@ -118,6 +177,8 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		this.activeExports = activeExports;
 		this.otherStarExports = otherStarExports;
 		this.strictExportPresence = strictExportPresence;
+		this.allStarExports = allStarExports;
+		this._getMode = this._getMode.bind(this);
 	}
 
 	// TODO webpack 6 remove
@@ -162,6 +223,15 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {ExportMode} the export mode
 	 */
 	getMode(moduleGraph, runtime) {
+		return moduleGraph.cached(this._getMode, runtime);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ExportMode} the export mode
+	 */
+	_getMode(moduleGraph, runtime) {
 		const name = this.name;
 		const ids = this.getIds(moduleGraph);
 		const parentModule = moduleGraph.getParentModule(this);
@@ -300,10 +370,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					checked.has(exportName),
 					false
 				)
-		).concat(
-			Array.from(
-				hidden,
-				exportName =>
+		);
+		if (hidden !== undefined) {
+			for (const exportName of hidden) {
+				mode.items.push(
 					new NormalReexportItem(
 						exportName,
 						[exportName],
@@ -311,8 +381,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 						false,
 						true
 					)
-			)
-		);
+				);
+			}
+		}
 
 		return mode;
 	}
@@ -322,7 +393,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
 	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden: Set<string>}} information
+	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
 	 */
 	getStarReexports(
 		moduleGraph,
@@ -338,10 +409,18 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
 		const ignoredExports = new Set(["default", ...this.activeExports]);
-		const hiddenExports = new Set(
-			this._discoverActiveExportsFromOtherStarExports(moduleGraph).keys()
+
+		let hiddenExports = undefined;
+		const otherStarExports = this._discoverActiveExportsFromOtherStarExports(
+			moduleGraph
 		);
-		for (const e of ignoredExports) hiddenExports.delete(e);
+		if (otherStarExports !== undefined) {
+			hiddenExports = new Set();
+			for (let i = 0; i < otherStarExports.namesSlice; i++) {
+				hiddenExports.add(otherStarExports.names[i]);
+			}
+			for (const e of ignoredExports) hiddenExports.delete(e);
+		}
 
 		if (!noExtraExports && !noExtraImports) {
 			return {
@@ -355,7 +434,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		/** @type {Set<string>} */
 		const checked = new Set();
 		/** @type {Set<string>} */
-		const hidden = new Set();
+		const hidden = hiddenExports !== undefined ? new Set() : undefined;
 
 		if (noExtraImports) {
 			for (const exportInfo of exportsInfo.orderedExports) {
@@ -366,7 +445,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					name
 				);
 				if (importedExportInfo.provided === false) continue;
-				if (hiddenExports.has(name)) {
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
 					hidden.add(name);
 					continue;
 				}
@@ -381,7 +460,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				if (importedExportInfo.provided === false) continue;
 				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
 				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				if (hiddenExports.has(name)) {
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
 					hidden.add(name);
 					continue;
 				}
@@ -481,28 +560,43 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {Map<string, HarmonyExportImportedSpecifierDependency>} exported names and their origin dependency
+	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
 	 */
 	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
-		if (!this.otherStarExports) {
-			return new Map();
-		}
+		if (!this.otherStarExports) return undefined;
+
+		const i =
+			"length" in this.otherStarExports
+				? this.otherStarExports.length
+				: countIterable(this.otherStarExports);
+		if (i === 0) return undefined;
+
+		if (this.allStarExports) {
+			const { names, dependencyIndices } = moduleGraph.cached(
+				determineExportAssignments,
+				this.allStarExports.dependencies
+			);
 
-		const result = new Map();
-		// try to learn impossible exports from other star exports with provided exports
-		for (const otherStarExport of this.otherStarExports) {
-			const otherImportedModule = moduleGraph.getModule(otherStarExport);
-			if (otherImportedModule) {
-				const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
-				for (const exportInfo of exportsInfo.exports) {
-					if (exportInfo.provided === true && !result.has(exportInfo.name)) {
-						result.set(exportInfo.name, otherStarExport);
-					}
-				}
-			}
+			return {
+				names,
+				namesSlice: dependencyIndices[i - 1],
+				dependencyIndices,
+				dependencyIndex: i
+			};
 		}
 
-		return result;
+		const { names, dependencyIndices } = moduleGraph.cached(
+			determineExportAssignments,
+			this.otherStarExports,
+			this
+		);
+
+		return {
+			names,
+			namesSlice: dependencyIndices[i - 1],
+			dependencyIndices,
+			dependencyIndex: i
+		};
 	}
 
 	/**
@@ -522,7 +616,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					exports: true,
 					from,
 					canMangle: false,
-					excludeExports: combine(mode.ignored, mode.hidden),
+					excludeExports: mode.hidden
+						? combine(mode.ignored, mode.hidden)
+						: mode.ignored,
 					hideExports: mode.hidden,
 					dependencies: [from.module]
 				};
@@ -670,7 +766,15 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			const potentialConflicts = this._discoverActiveExportsFromOtherStarExports(
 				moduleGraph
 			);
-			if (potentialConflicts.size > 0) {
+			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
+				const ownNames = new Set(
+					potentialConflicts.names.slice(
+						potentialConflicts.namesSlice,
+						potentialConflicts.dependencyIndices[
+							potentialConflicts.dependencyIndex
+						]
+					)
+				);
 				const importedModule = moduleGraph.getModule(this);
 				if (importedModule) {
 					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
@@ -679,8 +783,13 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 						if (exportInfo.provided !== true) continue;
 						if (exportInfo.name === "default") continue;
 						if (this.activeExports.has(exportInfo.name)) continue;
-						const conflictingDependency = potentialConflicts.get(
-							exportInfo.name
+						if (ownNames.has(exportInfo.name)) continue;
+						const conflictingDependency = findDependencyForName(
+							potentialConflicts,
+							exportInfo.name,
+							this.allStarExports
+								? this.allStarExports.dependencies
+								: [...this.otherStarExports, this]
 						);
 						if (!conflictingDependency) continue;
 						const target = exportInfo.getTerminalBinding(moduleGraph);
@@ -726,25 +835,29 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	serialize(context) {
-		const { write } = context;
+		const { write, setCircularReference } = context;
 
+		setCircularReference(this);
 		write(this.ids);
 		write(this.name);
 		write(this.activeExports);
 		write(this.otherStarExports);
 		write(this.strictExportPresence);
+		write(this.allStarExports);
 
 		super.serialize(context);
 	}
 
 	deserialize(context) {
-		const { read } = context;
+		const { read, setCircularReference } = context;
 
+		setCircularReference(this);
 		this.ids = read();
 		this.name = read();
 		this.activeExports = read();
 		this.otherStarExports = read();
 		this.strictExportPresence = read();
+		this.allStarExports = read();
 
 		super.deserialize(context);
 	}
@@ -948,7 +1061,9 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				break;
 
 			case "dynamic-reexport": {
-				const ignored = combine(mode.ignored, mode.hidden);
+				const ignored = mode.hidden
+					? combine(mode.ignored, mode.hidden)
+					: mode.ignored;
 				const modern =
 					runtimeTemplate.supportsConst() &&
 					runtimeTemplate.supportsArrowFunction();
@@ -1089,3 +1204,40 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		return `${name}${propertyAccess(valueKey)}`;
 	}
 };
+
+class HarmonyStarExportsList {
+	constructor() {
+		/** @type {HarmonyExportImportedSpecifierDependency[]} */
+		this.dependencies = [];
+	}
+
+	/**
+	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
+	 * @returns {void}
+	 */
+	push(dep) {
+		this.dependencies.push(dep);
+	}
+
+	slice() {
+		return this.dependencies.slice();
+	}
+
+	serialize({ write, setCircularReference }) {
+		setCircularReference(this);
+		write(this.dependencies);
+	}
+
+	deserialize({ read, setCircularReference }) {
+		setCircularReference(this);
+		this.dependencies = read();
+	}
+}
+
+makeSerializable(
+	HarmonyStarExportsList,
+	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency",
+	"HarmonyStarExportsList"
+);
+
+module.exports.HarmonyStarExportsList = HarmonyStarExportsList;

package/lib/dependencies/LoaderImportDependency.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const ModuleDependency = require("./ModuleDependency");
+
+class LoaderImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+		this.weak = true;
+	}
+
+	get type() {
+		return "loader import";
+	}
+
+	get category() {
+		return "loaderImport";
+	}
+}
+
+module.exports = LoaderImportDependency;

package/lib/dependencies/LoaderPlugin.js

@@ -8,18 +8,45 @@
 const NormalModule = require("../NormalModule");
 const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
+const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
 /**
  * @callback LoadModuleCallback
  * @param {Error=} err error object
- * @param {string=} source source code
+ * @param {string | Buffer=} source source code
  * @param {object=} map source map
  * @param {Module=} module loaded module if successful
  */
 
+/**
+ * @callback ImportModuleCallback
+ * @param {Error=} err error object
+ * @param {any=} exports exports of the evaluated module
+ */
+
+/**
+ * @typedef {Object} ImportModuleOptions
+ * @property {string=} layer the target layer
+ * @property {string=} publicPath the target public path
+ */
+
 class LoaderPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {boolean=} options.enableExecuteModule execute module enabled
+	 */
+	constructor(options = {}) {
+		this._enableExecuteModule = !!options.enableExecuteModule;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			"LoaderPlugin",
@@ -28,6 +55,10 @@ class LoaderPlugin {
 					LoaderDependency,
 					normalModuleFactory
 				);
+				compilation.dependencyFactories.set(
+					LoaderImportDependency,
+					normalModuleFactory
+				);
 			}
 		);
 
@@ -47,7 +78,7 @@ class LoaderPlugin {
 							name: request
 						};
 						const factory = compilation.dependencyFactories.get(
-							dep.constructor
+							/** @type {DepConstructor} */ (dep.constructor)
 						);
 						if (factory === undefined) {
 							return callback(
@@ -123,6 +154,107 @@ class LoaderPlugin {
 							}
 						);
 					};
+
+					if (this._enableExecuteModule) {
+						/**
+						 * @param {string} request the request string to load the module from
+						 * @param {ImportModuleOptions=} options options
+						 * @param {ImportModuleCallback=} callback callback returning the exports
+						 * @returns {void}
+						 */
+						const importModule = (request, options, callback) => {
+							const dep = new LoaderImportDependency(request);
+							dep.loc = {
+								name: request
+							};
+							const factory = compilation.dependencyFactories.get(
+								/** @type {DepConstructor} */ (dep.constructor)
+							);
+							if (factory === undefined) {
+								return callback(
+									new Error(
+										`No module factory available for dependency type: ${dep.constructor.name}`
+									)
+								);
+							}
+							compilation.buildQueue.increaseParallelism();
+							compilation.handleModuleCreation(
+								{
+									factory,
+									dependencies: [dep],
+									originModule: loaderContext._module,
+									contextInfo: {
+										issuerLayer: options.layer
+									},
+									context: loaderContext.context,
+									connectOrigin: false
+								},
+								err => {
+									compilation.buildQueue.decreaseParallelism();
+									if (err) {
+										return callback(err);
+									}
+									const referencedModule = moduleGraph.getModule(dep);
+									if (!referencedModule) {
+										return callback(new Error("Cannot load the module"));
+									}
+									compilation.executeModule(
+										referencedModule,
+										{
+											entryOptions: {
+												publicPath: options.publicPath
+											}
+										},
+										(err, result) => {
+											if (err) return callback(err);
+											for (const d of result.fileDependencies) {
+												loaderContext.addDependency(d);
+											}
+											for (const d of result.contextDependencies) {
+												loaderContext.addContextDependency(d);
+											}
+											for (const d of result.missingDependencies) {
+												loaderContext.addMissingDependency(d);
+											}
+											for (const d of result.buildDependencies) {
+												loaderContext.addBuildDependency(d);
+											}
+											if (result.cacheable === false)
+												loaderContext.cacheable(false);
+											for (const [name, { source, info }] of result.assets) {
+												const { buildInfo } = loaderContext._module;
+												if (!buildInfo.assets) {
+													buildInfo.assets = Object.create(null);
+													buildInfo.assetsInfo = new Map();
+												}
+												buildInfo.assets[name] = source;
+												buildInfo.assetsInfo.set(name, info);
+											}
+											callback(null, result.exports);
+										}
+									);
+								}
+							);
+						};
+
+						/**
+						 * @param {string} request the request string to load the module from
+						 * @param {ImportModuleOptions} options options
+						 * @param {ImportModuleCallback=} callback callback returning the exports
+						 * @returns {Promise<any> | void} exports
+						 */
+						loaderContext.importModule = (request, options, callback) => {
+							if (!callback) {
+								return new Promise((resolve, reject) => {
+									importModule(request, options || {}, (err, result) => {
+										if (err) reject(err);
+										else resolve(result);
+									});
+								});
+							}
+							return importModule(request, options || {}, callback);
+						};
+					}
 				}
 			);
 		});

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -29,9 +29,9 @@ class ArrayPushCallbackChunkFormatPlugin {
 			compilation => {
 				compilation.hooks.additionalChunkRuntimeRequirements.tap(
 					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, set) => {
+					(chunk, set, { chunkGraph }) => {
 						if (chunk.hasRuntime()) return;
-						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 							set.add(RuntimeGlobals.onChunksLoaded);
 							set.add(RuntimeGlobals.require);
 						}

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -31,9 +31,9 @@ class CommonJsChunkFormatPlugin {
 			compilation => {
 				compilation.hooks.additionalChunkRuntimeRequirements.tap(
 					"CommonJsChunkLoadingPlugin",
-					(chunk, set) => {
+					(chunk, set, { chunkGraph }) => {
 						if (chunk.hasRuntime()) return;
-						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 							set.add(RuntimeGlobals.require);
 							set.add(RuntimeGlobals.startupEntrypoint);
 							set.add(RuntimeGlobals.externalInstallChunk);