webpack 5.101.0 → 5.101.2

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -8,13 +8,16 @@
 const { ConcatSource } = require("webpack-sources");
 const { HotUpdateChunk, RuntimeGlobals } = require("..");
 const Template = require("../Template");
+const {
+	createChunkHashHandler,
+	getChunkInfo
+} = require("../javascript/ChunkFormatHelpers");
 const { getAllChunks } = require("../javascript/ChunkHelpers");
 const {
 	chunkHasJs,
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("../javascript/JavascriptModulesPlugin");
-const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -27,28 +30,6 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
-/**
- * Gets information about a chunk including its entries and runtime chunk
- * @param {Chunk} chunk The chunk to get information for
- * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
- * @returns {{entries: Array<[Module, Entrypoint | undefined]>, runtimeChunk: Chunk|null}} Object containing chunk entries and runtime chunk
- */
-function getChunkInfo(chunk, chunkGraph) {
-	const entries = [
-		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-	];
-	const runtimeChunk =
-		entries.length > 0
-			? /** @type {Entrypoint[][]} */
-				(entries)[0][1].getRuntimeChunk()
-			: null;
-
-	return {
-		entries,
-		runtimeChunk
-	};
-}
-
 /**
  * @param {Compilation} compilation the compilation instance
  * @param {Chunk} chunk the chunk
@@ -97,7 +78,7 @@ const getRelativePath = (compilation, chunk, runtimeChunk) => {
  * @returns {string} the import source
  */
 function renderChunkImport(compilation, chunk, namedImport, runtimeChunk) {
-	return `import ${namedImport ? `* as ${namedImport}` : RuntimeGlobals.require} from ${JSON.stringify(
+	return `import ${namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`} from ${JSON.stringify(
 		getRelativePath(compilation, chunk, runtimeChunk || chunk)
 	)};\n`;
 }
@@ -168,27 +149,30 @@ class ModuleChunkFormatPlugin {
 				PLUGIN_NAME,
 				(modules, _lastModule, renderContext) => {
 					const { chunk, chunkGraph } = renderContext;
-					if (!chunk.hasRuntime()) {
-						return modules;
-					}
-					const entryDependentChunks =
-						chunkGraph.getChunkEntryDependentChunksIterable(chunk);
-					const sourceWithDependentChunks = withDependentChunks(
-						/** @type {Set<Chunk>} */ (entryDependentChunks),
-						chunkGraph,
-						chunk
-					);
-					if (!sourceWithDependentChunks) {
-						return modules;
-					}
-					if (modules.size() === 0) {
-						return sourceWithDependentChunks;
+					if (
+						chunkGraph.getNumberOfEntryModules(chunk) > 0 &&
+						chunk.hasRuntime()
+					) {
+						const entryDependentChunks =
+							chunkGraph.getChunkEntryDependentChunksIterable(chunk);
+						const sourceWithDependentChunks = withDependentChunks(
+							/** @type {Set<Chunk>} */ (entryDependentChunks),
+							chunkGraph,
+							chunk
+						);
+						if (!sourceWithDependentChunks) {
+							return modules;
+						}
+						if (modules.size() === 0) {
+							return sourceWithDependentChunks;
+						}
+						const source = new ConcatSource();
+						source.add(sourceWithDependentChunks);
+						source.add("\n");
+						source.add(modules);
+						return source;
 					}
-					const source = new ConcatSource();
-					source.add(sourceWithDependentChunks);
-					source.add("\n");
-					source.add(modules);
-					return source;
+					return modules;
 				}
 			);
 			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
@@ -238,9 +222,6 @@ class ModuleChunkFormatPlugin {
 						}
 						const final = i + 1 === entries.length;
 						const moduleId = chunkGraph.getModuleId(module);
-						const entryDependentChunks = /** @type {Set<Chunk>} */ (
-							chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-						);
 						const chunks = getAllChunks(
 							/** @type {Entrypoint} */ (entrypoint),
 							/** @type {Chunk} */ (runtimeChunk),
@@ -248,10 +229,7 @@ class ModuleChunkFormatPlugin {
 						);
 						const processChunks = new Set();
 						for (const _chunk of chunks) {
-							if (
-								loadedChunks.has(_chunk) ||
-								entryDependentChunks.has(_chunk)
-							) {
+							if (loadedChunks.has(_chunk)) {
 								continue;
 							}
 							loadedChunks.add(_chunk);
@@ -287,19 +265,7 @@ class ModuleChunkFormatPlugin {
 				}
 				return source;
 			});
-			hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, { chunkGraph }) => {
-				if (chunk.hasRuntime()) return;
-				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
-				hash.update(PLUGIN_NAME);
-				hash.update("1");
-				if (runtimeChunk && runtimeChunk.hash) {
-					// Any change to runtimeChunk should trigger a hash update,
-					// we shouldn't depend on or inspect its internal implementation.
-					// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
-					hash.update(runtimeChunk.hash);
-				}
-				updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-			});
+			hooks.chunkHash.tap(PLUGIN_NAME, createChunkHashHandler(PLUGIN_NAME));
 		});
 	}
 }

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -71,11 +71,8 @@ class ModuleChunkLoadingPlugin {
 				.tap(PLUGIN_NAME, handler);
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+				.tap(PLUGIN_NAME, (chunk) => {
 					if (!isEnabledForChunk(chunk)) return;
-					// If a chunk contains an entryModule, all exports are determined by the entryModule.
-					// The ExportWebpackRequireRuntimeModule is for internal use only and not exposed to users.
-					if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return;
 					compilation.addRuntimeModule(
 						chunk,
 						new ExportWebpackRequireRuntimeModule()

package/lib/index.js

@@ -56,6 +56,9 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
 /** @typedef {import("./ResolverFactory").Resolver} Resolver */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./Watching")} Watching */
 /** @typedef {import("./cli").Argument} Argument */
 /** @typedef {import("./cli").Problem} Problem */
@@ -75,6 +78,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 
@@ -288,6 +293,9 @@ module.exports = mergeExports(fn, {
 	get Module() {
 		return require("./Module");
 	},
+	get ModuleFactory() {
+		return require("./ModuleFactory");
+	},
 	get ModuleFilenameHelpers() {
 		return require("./ModuleFilenameHelpers");
 	},

package/lib/javascript/ChunkFormatHelpers.js

@@ -0,0 +1,70 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const { updateHashForEntryStartup } = require("./StartupHelpers");
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+
+/**
+ * Gets information about a chunk including its entries and runtime chunk
+ * @param {Chunk} chunk The chunk to get information for
+ * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
+ * @returns {{entries: Array<[Module, Entrypoint | undefined]>, runtimeChunk: Chunk|null}} Object containing chunk entries and runtime chunk
+ */
+function getChunkInfo(chunk, chunkGraph) {
+	const entries = [
+		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+	];
+	const runtimeChunk =
+		entries.length > 0
+			? /** @type {Entrypoint[][]} */
+				(entries)[0][1].getRuntimeChunk()
+			: null;
+
+	return {
+		entries,
+		runtimeChunk
+	};
+}
+
+/**
+ * Creates a chunk hash handler
+ * @param {string} name The name of the chunk
+ * @returns {(chunk: Chunk, hash: Hash, { chunkGraph }: ChunkHashContext) => void} The chunk hash handler
+ */
+function createChunkHashHandler(name) {
+	/**
+	 * @param {Chunk} chunk The chunk to get information for
+	 * @param {Hash} hash The hash to update
+	 * @param {ChunkHashContext} chunkHashContext The chunk hash context
+	 * @returns {void}
+	 */
+	return (chunk, hash, { chunkGraph }) => {
+		if (chunk.hasRuntime()) return;
+		const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+		hash.update(name);
+		hash.update("1");
+		if (runtimeChunk && runtimeChunk.hash) {
+			// https://github.com/webpack/webpack/issues/19439
+			// Any change to runtimeChunk should trigger a hash update,
+			// we shouldn't depend on or inspect its internal implementation.
+			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
+			hash.update(runtimeChunk.hash);
+		}
+		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+	};
+}
+
+module.exports = {
+	createChunkHashHandler,
+	getChunkInfo
+};

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -9,14 +9,15 @@ const { ConcatSource, RawSource } = require("webpack-sources");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { getUndoPath } = require("../util/identifier");
+const {
+	createChunkHashHandler,
+	getChunkInfo
+} = require("./ChunkFormatHelpers");
 const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
 } = require("./JavascriptModulesPlugin");
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = require("./StartupHelpers");
+const { generateEntryStartup } = require("./StartupHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -59,13 +60,8 @@ class CommonJsChunkFormatPlugin {
 						Template.renderChunkRuntimeModules(runtimeModules, renderContext)
 					);
 				}
-				const entries = [
-					...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-				];
-				if (entries.length > 0) {
-					const runtimeChunk =
-						/** @type {Entrypoint} */
-						(entries[0][1]).getRuntimeChunk();
+				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+				if (runtimeChunk) {
 					const currentOutputName = compilation
 						.getPath(
 							getChunkFilenameTemplate(chunk, compilation.outputOptions),
@@ -144,15 +140,8 @@ class CommonJsChunkFormatPlugin {
 				}
 				return source;
 			});
-			hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, { chunkGraph }) => {
-				if (chunk.hasRuntime()) return;
-				hash.update(PLUGIN_NAME);
-				hash.update("1");
-				const entries = [
-					...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-				];
-				updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-			});
+
+			hooks.chunkHash.tap(PLUGIN_NAME, createChunkHashHandler(PLUGIN_NAME));
 		});
 	}
 }

package/lib/javascript/JavascriptModulesPlugin.js

@@ -173,13 +173,38 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {string} hash hash to be used for render call
  */
 
-/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
+/**
+ * @typedef {object} StartupRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {boolean | undefined} strictMode rendering in strict context
+ * @property {boolean } inlined inlined
+ * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE
+ */
+
+/**
+ * @typedef {object} ModuleRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ * @property {boolean | undefined} strictMode rendering in strict context
+ * @property {boolean} factory true: renders as factory method, false: pure module content
+ * @property {boolean=} inlinedInIIFE the inlined entry module is wrapped in an IIFE, existing only when `factory` is set to false
+ */
 
 /**
  * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModulePackage
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
@@ -217,17 +242,17 @@ class JavascriptModulesPlugin {
 				renderModuleContent: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				renderModuleContainer: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				renderModulePackage: new SyncWaterfallHook([
 					"source",
 					"module",
-					"renderContext"
+					"moduleRenderContext"
 				]),
 				render: new SyncWaterfallHook(["source", "renderContext"]),
 				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
@@ -575,18 +600,18 @@ class JavascriptModulesPlugin {
 
 	/**
 	 * @param {Module} module the rendered module
-	 * @param {ChunkRenderContext} renderContext options object
+	 * @param {ModuleRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
-	 * @param {boolean} factory true: renders as factory method, false: pure module content
 	 * @returns {Source | null} the newly generated source from rendering
 	 */
-	renderModule(module, renderContext, hooks, factory) {
+	renderModule(module, renderContext, hooks) {
 		const {
 			chunk,
 			chunkGraph,
 			runtimeTemplate,
 			codeGenerationResults,
-			strictMode
+			strictMode,
+			factory
 		} = renderContext;
 		try {
 			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
@@ -729,7 +754,11 @@ class JavascriptModulesPlugin {
 		};
 		const moduleSources =
 			Template.renderChunkModules(chunkRenderContext, allModules, (module) =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true },
+					hooks
+				)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
 			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
@@ -841,7 +870,12 @@ class JavascriptModulesPlugin {
 						(m) => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
 					)
 				: allModules,
-			(module) => this.renderModule(module, chunkRenderContext, hooks, true),
+			(module) =>
+				this.renderModule(
+					module,
+					{ ...chunkRenderContext, factory: true },
+					hooks
+				),
 			prefix
 		);
 		if (
@@ -913,6 +947,8 @@ class JavascriptModulesPlugin {
 			const avoidEntryIife = compilation.options.optimization.avoidEntryIife;
 			/** @type {Map<Module, Source> | false} */
 			let renamedInlinedModule = false;
+			let inlinedInIIFE = false;
+
 			if (avoidEntryIife) {
 				renamedInlinedModule = this.getRenamedInlineModule(
 					allModules,
@@ -926,31 +962,46 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const m of inlinedModules) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					m,
+					chunk.runtime
+				);
+				const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+				const webpackExports =
+					exports && m.exportsArgument === RuntimeGlobals.exports;
+
+				const innerStrict =
+					!allStrict && /** @type {BuildInfo} */ (m.buildInfo).strict;
+
+				const iife = innerStrict
+					? "it needs to be in strict mode."
+					: inlinedModules.size > 1
+						? // TODO check globals and top-level declarations of other entries and chunk modules
+							// to make a better decision
+							"it needs to be isolated against other entry modules."
+						: chunkModules && !renamedInlinedModule
+							? "it needs to be isolated against other modules in the chunk."
+							: exports && !webpackExports
+								? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+								: hooks.embedInRuntimeBailout.call(m, renderContext);
+
+				if (iife) {
+					inlinedInIIFE = true;
+				}
+
 				const renderedModule = renamedInlinedModule
 					? renamedInlinedModule.get(m)
-					: this.renderModule(m, chunkRenderContext, hooks, false);
+					: this.renderModule(
+							m,
+							{
+								...chunkRenderContext,
+								factory: false,
+								inlinedInIIFE
+							},
+							hooks
+						);
 
 				if (renderedModule) {
-					const innerStrict =
-						!allStrict && /** @type {BuildInfo} */ (m.buildInfo).strict;
-					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-						m,
-						chunk.runtime
-					);
-					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
-					const webpackExports =
-						exports && m.exportsArgument === RuntimeGlobals.exports;
-					const iife = innerStrict
-						? "it needs to be in strict mode."
-						: inlinedModules.size > 1
-							? // TODO check globals and top-level declarations of other entries and chunk modules
-								// to make a better decision
-								"it needs to be isolated against other entry modules."
-							: chunkModules && !renamedInlinedModule
-								? "it needs to be isolated against other modules in the chunk."
-								: exports && !webpackExports
-									? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-									: hooks.embedInRuntimeBailout.call(m, renderContext);
 					let footer;
 					if (iife !== undefined) {
 						startupSource.add(
@@ -989,7 +1040,8 @@ class JavascriptModulesPlugin {
 			source.add(
 				hooks.renderStartup.call(startupSource, lastInlinedModule, {
 					...renderContext,
-					inlined: true
+					inlined: true,
+					inlinedInIIFE
 				})
 			);
 			if (bootstrap.afterStartup.length > 0) {
@@ -1557,7 +1609,6 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-
 		// TODO:
 		// This step is before the IIFE reason calculation. Ideally, it should only be executed when this function can optimize the
 		// IIFE reason. Otherwise, it should directly return false. There are four reasons now, we have skipped two already, the left
@@ -1581,9 +1632,12 @@ class JavascriptModulesPlugin {
 			const isInlinedModule = inlinedModules && inlinedModules.has(m);
 			const moduleSource = this.renderModule(
 				m,
-				chunkRenderContext,
-				hooks,
-				!isInlinedModule
+				{
+					...chunkRenderContext,
+					factory: !isInlinedModule,
+					inlinedInIIFE: false
+				},
+				hooks
 			);
 
 			if (!moduleSource) continue;