webpack 5.97.1 → 5.104.1

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -16,6 +16,10 @@ const {
 } = require("./StartupHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+
+const PLUGIN_NAME = "ArrayPushCallbackChunkFormatPlugin";
 
 class ArrayPushCallbackChunkFormatPlugin {
 	/**
@@ -24,132 +28,125 @@ class ArrayPushCallbackChunkFormatPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ArrayPushCallbackChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.exports);
-							set.add(RuntimeGlobals.require);
-						}
-						set.add(RuntimeGlobals.chunkCallback);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (chunk.hasRuntime()) return;
+					if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+						set.add(RuntimeGlobals.onChunksLoaded);
+						set.add(RuntimeGlobals.exports);
+						set.add(RuntimeGlobals.require);
 					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-						const globalObject = runtimeTemplate.globalObject;
-						const source = new ConcatSource();
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-						if (hotUpdateChunk) {
-							const hotUpdateGlobal =
-								runtimeTemplate.outputOptions.hotUpdateGlobal;
-							source.add(
-								`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`
-							);
-							source.add(`${JSON.stringify(chunk.id)},`);
-							source.add(modules);
-							if (runtimeModules.length > 0) {
-								source.add(",\n");
-								const runtimePart = Template.renderChunkRuntimeModules(
-									runtimeModules,
-									renderContext
-								);
-								source.add(runtimePart);
-							}
-							source.add(")");
-						} else {
-							const chunkLoadingGlobal =
-								runtimeTemplate.outputOptions.chunkLoadingGlobal;
-							source.add(
-								`(${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] = ${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] || []).push([`
+					set.add(RuntimeGlobals.chunkCallback);
+				}
+			);
+			const hooks = getCompilationHooks(compilation);
+			hooks.renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
+				const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
+				const globalObject = runtimeTemplate.globalObject;
+				const source = new ConcatSource();
+				const runtimeModules = chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+				if (hotUpdateChunk) {
+					const hotUpdateGlobal = runtimeTemplate.outputOptions.hotUpdateGlobal;
+					source.add(`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`);
+					source.add(`${JSON.stringify(chunk.id)},`);
+					source.add(modules);
+					if (runtimeModules.length > 0) {
+						source.add(",\n");
+						const runtimePart = Template.renderChunkRuntimeModules(
+							runtimeModules,
+							renderContext
+						);
+						source.add(runtimePart);
+					}
+					source.add(")");
+				} else {
+					const chunkLoadingGlobal =
+						runtimeTemplate.outputOptions.chunkLoadingGlobal;
+					source.add(
+						`(${globalObject}[${JSON.stringify(
+							chunkLoadingGlobal
+						)}] = ${globalObject}[${JSON.stringify(
+							chunkLoadingGlobal
+						)}] || []).push([`
+					);
+					source.add(`${JSON.stringify(chunk.ids)},`);
+					source.add(modules);
+					/** @type {EntryModuleWithChunkGroup[]} */
+					const entries = [
+						...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+					];
+					if (runtimeModules.length > 0 || entries.length > 0) {
+						const runtime = new ConcatSource(
+							`${
+								runtimeTemplate.supportsArrowFunction()
+									? `${RuntimeGlobals.require} =>`
+									: `function(${RuntimeGlobals.require})`
+							} { // webpackRuntimeModules\n`
+						);
+						if (runtimeModules.length > 0) {
+							runtime.add(
+								Template.renderRuntimeModules(runtimeModules, {
+									...renderContext,
+									codeGenerationResults:
+										/** @type {CodeGenerationResults} */
+										(compilation.codeGenerationResults)
+								})
 							);
-							source.add(`${JSON.stringify(chunk.ids)},`);
-							source.add(modules);
-							const entries = Array.from(
-								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						}
+						if (entries.length > 0) {
+							const startupSource = new RawSource(
+								generateEntryStartup(
+									chunkGraph,
+									runtimeTemplate,
+									entries,
+									chunk,
+									true
+								)
 							);
-							if (runtimeModules.length > 0 || entries.length > 0) {
-								const runtime = new ConcatSource(
-									`${
-										runtimeTemplate.supportsArrowFunction()
-											? `${RuntimeGlobals.require} =>`
-											: `function(${RuntimeGlobals.require})`
-									} { // webpackRuntimeModules\n`
-								);
-								if (runtimeModules.length > 0) {
-									runtime.add(
-										Template.renderRuntimeModules(runtimeModules, {
-											...renderContext,
-											codeGenerationResults: compilation.codeGenerationResults
-										})
-									);
-								}
-								if (entries.length > 0) {
-									const startupSource = new RawSource(
-										generateEntryStartup(
-											chunkGraph,
-											runtimeTemplate,
-											entries,
-											chunk,
-											true
-										)
-									);
-									runtime.add(
-										hooks.renderStartup.call(
-											startupSource,
-											entries[entries.length - 1][0],
-											{
-												...renderContext,
-												inlined: false
-											}
-										)
-									);
-									if (
-										chunkGraph
-											.getChunkRuntimeRequirements(chunk)
-											.has(RuntimeGlobals.returnExportsFromRuntime)
-									) {
-										runtime.add(`return ${RuntimeGlobals.exports};\n`);
+							runtime.add(
+								hooks.renderStartup.call(
+									startupSource,
+									entries[entries.length - 1][0],
+									{
+										...renderContext,
+										inlined: false
 									}
-								}
-								runtime.add("}\n");
-								source.add(",\n");
-								source.add(new PrefixSource("/******/ ", runtime));
+								)
+							);
+							if (
+								chunkGraph
+									.getChunkRuntimeRequirements(chunk)
+									.has(RuntimeGlobals.returnExportsFromRuntime)
+							) {
+								runtime.add(`return ${RuntimeGlobals.exports};\n`);
 							}
-							source.add("])");
 						}
-						return source;
-					}
-				);
-				hooks.chunkHash.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update(
-							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
-						);
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+						runtime.add("}\n");
+						source.add(",\n");
+						source.add(new PrefixSource("/******/ ", runtime));
 					}
-				);
-			}
-		);
+					source.add("])");
+				}
+				return source;
+			});
+			hooks.chunkHash.tap(
+				PLUGIN_NAME,
+				(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+					if (chunk.hasRuntime()) return;
+					hash.update(
+						`${PLUGIN_NAME}1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
+					);
+					/** @type {EntryModuleWithChunkGroup[]} */
+					const entries = [
+						...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+					];
+					updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+				}
+			);
+		});
 	}
 }
 

package/lib/javascript/BasicEvaluatedExpression.js

@@ -7,7 +7,10 @@
 
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("./JavascriptParser").Range} Range */
-/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
+/** @typedef {import("./JavascriptParser").VariableInfo} VariableInfo */
+/** @typedef {import("./JavascriptParser").Members} Members */
+/** @typedef {import("./JavascriptParser").MembersOptionals} MembersOptionals */
+/** @typedef {import("./JavascriptParser").MemberRanges} MemberRanges */
 
 const TypeUnknown = 0;
 const TypeUndefined = 1;
@@ -24,6 +27,10 @@ const TypeWrapped = 11;
 const TypeTemplateString = 12;
 const TypeBigInt = 13;
 
+/** @typedef {() => Members} GetMembers */
+/** @typedef {() => MembersOptionals} GetMembersOptionals */
+/** @typedef {() => MemberRanges} GetMemberRanges */
+
 class BasicEvaluatedExpression {
 	constructor() {
 		this.type = TypeUnknown;
@@ -51,7 +58,7 @@ class BasicEvaluatedExpression {
 		this.quasis = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.parts = undefined;
-		/** @type {any[] | undefined} */
+		/** @type {EXPECTED_ANY[] | undefined} */
 		this.array = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.items = undefined;
@@ -63,15 +70,15 @@ class BasicEvaluatedExpression {
 		this.postfix = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.identifier = undefined;
-		/** @type {string | VariableInfoInterface | undefined} */
+		/** @type {string | VariableInfo | undefined} */
 		this.rootInfo = undefined;
-		/** @type {(() => string[]) | undefined} */
+		/** @type {GetMembers | undefined} */
 		this.getMembers = undefined;
-		/** @type {(() => boolean[]) | undefined} */
+		/** @type {GetMembersOptionals | undefined} */
 		this.getMembersOptionals = undefined;
-		/** @type {(() => Range[]) | undefined} */
+		/** @type {GetMemberRanges | undefined} */
 		this.getMemberRanges = undefined;
 		/** @type {Node | undefined} */
 		this.expression = undefined;
@@ -179,7 +186,7 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * Gets the compile-time value of the expression
-	 * @returns {any} the javascript value
+	 * @returns {undefined | null | string | number | boolean | RegExp | EXPECTED_ANY[] | bigint} the javascript value
 	 */
 	asCompileTimeValue() {
 		switch (this.type) {
@@ -386,11 +393,11 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * Set's the value of this expression to a particular identifier and its members.
-	 * @param {string | VariableInfoInterface} identifier identifier to set
-	 * @param {string | VariableInfoInterface} rootInfo root info
-	 * @param {() => string[]} getMembers members
-	 * @param {() => boolean[]=} getMembersOptionals optional members
-	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions
+	 * @param {string | VariableInfo} identifier identifier to set
+	 * @param {string | VariableInfo} rootInfo root info
+	 * @param {GetMembers} getMembers members
+	 * @param {GetMembersOptionals=} getMembersOptionals optional members
+	 * @param {GetMemberRanges=} getMemberRanges ranges of progressively increasing sub-expressions
 	 * @returns {this} this
 	 */
 	setIdentifier(
@@ -463,7 +470,7 @@ class BasicEvaluatedExpression {
 	setItems(items) {
 		this.type = TypeArray;
 		this.items = items;
-		this.sideEffects = items.some(i => i.couldHaveSideEffects());
+		this.sideEffects = items.some((i) => i.couldHaveSideEffects());
 		return this;
 	}
 
@@ -492,7 +499,7 @@ class BasicEvaluatedExpression {
 		this.quasis = quasis;
 		this.parts = parts;
 		this.templateStringKind = kind;
-		this.sideEffects = parts.some(p => p.sideEffects);
+		this.sideEffects = parts.some((p) => p.sideEffects);
 		return this;
 	}
 
@@ -524,7 +531,7 @@ class BasicEvaluatedExpression {
 
 	/**
 	 * Set's the range for the expression.
-	 * @param {[number, number]} range range to set
+	 * @param {Range} range range to set
 	 * @returns {this} this
 	 */
 	setRange(range) {
@@ -557,7 +564,7 @@ class BasicEvaluatedExpression {
  * @param {string} flags regexp flags
  * @returns {boolean} is valid flags
  */
-BasicEvaluatedExpression.isValidRegExpFlags = flags => {
+BasicEvaluatedExpression.isValidRegExpFlags = (flags) => {
 	const len = flags.length;
 
 	if (len === 0) return true;
@@ -566,7 +573,7 @@ BasicEvaluatedExpression.isValidRegExpFlags = flags => {
 	// cspell:word gimy
 	let remaining = 0b0000; // bit per RegExp flag: gimy
 
-	for (let i = 0; i < len; i++)
+	for (let i = 0; i < len; i++) {
 		switch (flags.charCodeAt(i)) {
 			case 103 /* g */:
 				if (remaining & 0b1000) return false;
@@ -587,6 +594,7 @@ BasicEvaluatedExpression.isValidRegExpFlags = flags => {
 			default:
 				return false;
 		}
+	}
 
 	return true;
 };

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: [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/ChunkHelpers.js

@@ -16,18 +16,30 @@ const Entrypoint = require("../Entrypoint");
  * @returns {Set<Chunk>} chunks
  */
 const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
+	/** @type {Set<Entrypoint>} */
 	const queue = new Set([entrypoint]);
+	/** @type {Set<Entrypoint>} */
+	const groups = new Set();
+	for (const group of queue) {
+		if (group !== entrypoint) {
+			groups.add(group);
+		}
+		for (const parent of group.parentsIterable) {
+			if (parent instanceof Entrypoint) queue.add(parent);
+		}
+	}
+	groups.add(entrypoint);
+
+	/** @type {Set<Chunk>} */
 	const chunks = new Set();
-	for (const entrypoint of queue) {
-		for (const chunk of entrypoint.chunks) {
+	for (const group of groups) {
+		for (const chunk of group.chunks) {
 			if (chunk === excludedChunk1) continue;
 			if (chunk === excludedChunk2) continue;
 			chunks.add(chunk);
 		}
-		for (const parent of entrypoint.parentsIterable) {
-			if (parent instanceof Entrypoint) queue.add(parent);
-		}
 	}
 	return chunks;
 };
+
 module.exports.getAllChunks = getAllChunks;