webpack 5.92.1 → 5.93.0

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -30,6 +30,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * @typedef {object} ExportPropertyLibraryPluginOptions
  * @property {LibraryType} type
  * @property {boolean} nsObjectUsed the namespace object is used
+ * @property {boolean} runtimeExportsUsed runtime exports are used
  */
 /**
  * @typedef {ExportPropertyLibraryPluginParsed} T
@@ -39,12 +40,13 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	/**
 	 * @param {ExportPropertyLibraryPluginOptions} options options
 	 */
-	constructor({ type, nsObjectUsed }) {
+	constructor({ type, nsObjectUsed, runtimeExportsUsed }) {
 		super({
 			pluginName: "ExportPropertyLibraryPlugin",
 			type
 		});
 		this.nsObjectUsed = nsObjectUsed;
+		this.runtimeExportsUsed = runtimeExportsUsed;
 	}
 
 	/**
@@ -93,7 +95,11 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
-	runtimeRequirements(chunk, set, libraryContext) {}
+	runtimeRequirements(chunk, set, libraryContext) {
+		if (this.runtimeExportsUsed) {
+			set.add(RuntimeGlobals.exports);
+		}
+	}
 
 	/**
 	 * @param {Source} source source

package/lib/library/ModernModuleLibraryPlugin.js

@@ -0,0 +1,142 @@
+/*
+	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("../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", () => {
+				return 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}`
+			);
+		}
+		return {
+			name: /** @type {string} */ (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 = 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 === 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/optimize/ConcatenatedModule.js

@@ -7,6 +7,7 @@
 
 const eslintScope = require("eslint-scope");
 const Referencer = require("eslint-scope/lib/referencer");
+const { SyncBailHook } = require("tapable");
 const {
 	CachedSource,
 	ConcatSource,
@@ -628,11 +629,20 @@ const addScopeSymbols = (s, nameSet, scopeSet1, scopeSet2) => {
 
 const TYPES = new Set(["javascript"]);
 
+/**
+ * @typedef {object} ConcatenateModuleHooks
+ * @property {SyncBailHook<[Record<string, string>]>} exportsDefinitions
+ */
+
+/** @type {WeakMap<Compilation, ConcatenateModuleHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class ConcatenatedModule extends Module {
 	/**
 	 * @param {Module} rootModule the root module of the concatenation
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Compilation} compilation the compilation
 	 * @param {object=} associatedObjectForCache object for caching
 	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
@@ -641,6 +651,7 @@ class ConcatenatedModule extends Module {
 		rootModule,
 		modules,
 		runtime,
+		compilation,
 		associatedObjectForCache,
 		hashFunction = "md4"
 	) {
@@ -654,18 +665,35 @@ class ConcatenatedModule extends Module {
 			identifier,
 			rootModule,
 			modules,
-			runtime
+			runtime,
+			compilation
 		});
 	}
 
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ConcatenateModuleHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				exportsDefinitions: new SyncBailHook(["definitions"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * @param {object} options options
 	 * @param {string} options.identifier the identifier of the module
 	 * @param {Module=} options.rootModule the root module of the concatenation
 	 * @param {RuntimeSpec} options.runtime the selected runtime
 	 * @param {Set<Module>=} options.modules all concatenated modules
+	 * @param {Compilation} options.compilation the compilation
 	 */
-	constructor({ identifier, rootModule, modules, runtime }) {
+	constructor({ identifier, rootModule, modules, runtime, compilation }) {
 		super(JAVASCRIPT_MODULE_TYPE_ESM, null, rootModule && rootModule.layer);
 
 		// Info from Factory
@@ -677,6 +705,8 @@ class ConcatenatedModule extends Module {
 		this._modules = modules;
 		this._runtime = runtime;
 		this.factoryMeta = rootModule && rootModule.factoryMeta;
+		/** @type {Compilation | undefined} */
+		this.compilation = compilation;
 	}
 
 	/**
@@ -1427,6 +1457,8 @@ class ConcatenatedModule extends Module {
 			/** @type {BuildMeta} */
 			(rootInfo.module.buildMeta).strictHarmonyModule;
 		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
+		/** @type {Record<string, string>} */
+		const exportsFinalName = {};
 		for (const exportInfo of exportsInfo.orderedExports) {
 			const name = exportInfo.name;
 			if (exportInfo.provided === false) continue;
@@ -1451,6 +1483,7 @@ class ConcatenatedModule extends Module {
 						strictHarmonyModule,
 						true
 					);
+					exportsFinalName[used] = finalName;
 					return `/* ${
 						exportInfo.isReexport() ? "reexport" : "binding"
 					} */ ${finalName}`;
@@ -1466,23 +1499,20 @@ class ConcatenatedModule extends Module {
 		const result = new ConcatSource();
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
+		let shouldAddHarmonyFlag = false;
 		if (
 			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
 			UsageState.Unused
 		) {
-			result.add(`// ESM COMPAT FLAG\n`);
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument,
-					runtimeRequirements
-				})
-			);
+			shouldAddHarmonyFlag = true;
 		}
 
 		// define exports
 		if (exportsMap.size > 0) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			const { exportsDefinitions } = ConcatenatedModule.getCompilationHooks(
+				this.compilation
+			);
+
 			const definitions = [];
 			for (const [key, value] of exportsMap) {
 				definitions.push(
@@ -1491,12 +1521,32 @@ class ConcatenatedModule extends Module {
 					)}`
 				);
 			}
-			result.add(`\n// EXPORTS\n`);
-			result.add(
-				`${RuntimeGlobals.definePropertyGetters}(${
-					this.exportsArgument
-				}, {${definitions.join(",")}\n});\n`
-			);
+			const shouldSkipRenderDefinitions =
+				exportsDefinitions.call(exportsFinalName);
+
+			if (!shouldSkipRenderDefinitions) {
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+
+				if (shouldAddHarmonyFlag) {
+					result.add(`// ESM COMPAT FLAG\n`);
+					result.add(
+						runtimeTemplate.defineEsModuleFlagStatement({
+							exportsArgument: this.exportsArgument,
+							runtimeRequirements
+						})
+					);
+				}
+
+				result.add(`\n// EXPORTS\n`);
+				result.add(
+					`${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+					}, {${definitions.join(",")}\n});\n`
+				);
+			} else {
+				this.buildMeta.exportsFinalName = exportsFinalName;
+			}
 		}
 
 		// list unused exports
@@ -1913,7 +1963,8 @@ ${defineGetters}`
 			identifier: undefined,
 			rootModule: undefined,
 			modules: undefined,
-			runtime: undefined
+			runtime: undefined,
+			compilation: undefined
 		});
 		obj.deserialize(context);
 		return obj;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -398,10 +398,12 @@ class ModuleConcatenationPlugin {
 							}
 
 							// Create a new ConcatenatedModule
+							ConcatenatedModule.getCompilationHooks(compilation);
 							let newModule = ConcatenatedModule.create(
 								rootModule,
 								modules,
 								concatConfiguration.runtime,
+								compilation,
 								compiler.root,
 								compilation.outputOptions.hashFunction
 							);

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -35,6 +35,7 @@ class ChunkPrefetchPreloadPlugin {
 						if (startupChildChunks) {
 							set.add(RuntimeGlobals.prefetchChunk);
 							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.exports);
 							compilation.addRuntimeModule(
 								chunk,
 								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)

package/lib/sharing/ConsumeSharedModule.js

@@ -207,26 +207,31 @@ class ConsumeSharedModule extends Module {
 				});
 			}
 		}
-		let fn = "load";
-		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
+
+		const args = [
+			JSON.stringify(shareScope),
+			JSON.stringify(shareKey),
+			JSON.stringify(eager)
+		];
 		if (requiredVersion) {
-			if (strictVersion) {
-				fn += "Strict";
-			}
-			if (singleton) {
-				fn += "Singleton";
-			}
 			args.push(stringifyHoley(requiredVersion));
-			fn += "VersionCheck";
-		} else {
-			if (singleton) {
-				fn += "Singleton";
-			}
 		}
 		if (fallbackCode) {
-			fn += "Fallback";
 			args.push(fallbackCode);
 		}
+
+		let fn;
+
+		if (requiredVersion) {
+			if (strictVersion) {
+				fn = singleton ? "loadStrictSingletonVersion" : "loadStrictVersion";
+			} else {
+				fn = singleton ? "loadSingletonVersion" : "loadVersion";
+			}
+		} else {
+			fn = singleton ? "loadSingleton" : "load";
+		}
+
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));