webpack 5.58.1 → 5.60.0

package/lib/config/defaults.js

@@ -19,6 +19,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
 /** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
+/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
 /** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
@@ -161,6 +162,8 @@ const applyWebpackOptionsDefaults = options => {
 
 	applyExperimentsDefaults(options.experiments, { production, development });
 
+	const futureDefaults = options.experiments.futureDefaults;
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -172,7 +175,10 @@ const applyWebpackOptionsDefaults = options => {
 	});
 	const cache = !!options.cache;
 
-	applySnapshotDefaults(options.snapshot, { production });
+	applySnapshotDefaults(options.snapshot, {
+		production,
+		futureDefaults
+	});
 
 	applyModuleDefaults(options.module, {
 		cache,
@@ -192,7 +198,7 @@ const applyWebpackOptionsDefaults = options => {
 		development,
 		entry: options.entry,
 		module: options.module,
-		futureDefaults: options.experiments.futureDefaults
+		futureDefaults
 	});
 
 	applyExternalsPresetsDefaults(options.externalsPresets, {
@@ -252,7 +258,7 @@ const applyWebpackOptionsDefaults = options => {
 };
 
 /**
- * @param {Experiments} experiments options
+ * @param {ExperimentsNormalized} experiments options
  * @param {Object} options options
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
@@ -265,14 +271,14 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "outputModule", false);
 	D(experiments, "asset", false);
 	D(experiments, "layers", false);
-	D(experiments, "lazyCompilation", false);
-	D(experiments, "buildHttp", false);
+	D(experiments, "lazyCompilation", undefined);
+	D(experiments, "buildHttp", undefined);
 	D(experiments, "futureDefaults", false);
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
-		D(experiments.buildHttp, "upgrade", development);
+		D(experiments.buildHttp, "upgrade", false);
 	}
 };
 
@@ -348,49 +354,65 @@ const applyCacheDefaults = (
  * @param {SnapshotOptions} snapshot options
  * @param {Object} options options
  * @param {boolean} options.production is production
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-const applySnapshotDefaults = (snapshot, { production }) => {
-	A(snapshot, "managedPaths", () => {
-		if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [path.resolve(match[1], "unplugged")];
-			}
-		} else {
-			const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
-				// eslint-disable-next-line node/no-extraneous-require
-				require.resolve("watchpack")
-			);
-			if (match) {
-				return [match[1]];
-			}
-		}
-		return [];
-	});
-	A(snapshot, "immutablePaths", () => {
-		if (process.versions.pnp === "1") {
-			const match =
-				/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+	if (futureDefaults) {
+		F(snapshot, "managedPaths", () =>
+			process.versions.pnp === "3"
+				? [
+						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
+				  ]
+				: [/^(.+?[\\/]node_modules[\\/])/]
+		);
+		F(snapshot, "immutablePaths", () =>
+			process.versions.pnp === "3"
+				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+				: []
+		);
+	} else {
+		A(snapshot, "managedPaths", () => {
+			if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [path.resolve(match[1], "unplugged")];
+				}
+			} else {
+				const match = /^(.+?[\\/]node_modules)[\\/]/.exec(
+					// eslint-disable-next-line node/no-extraneous-require
 					require.resolve("watchpack")
 				);
-			if (match) {
-				return [match[1]];
+				if (match) {
+					return [match[1]];
+				}
 			}
-		} else if (process.versions.pnp === "3") {
-			const match =
-				/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-					require.resolve("watchpack")
-				);
-			if (match) {
-				return [match[1]];
+			return [];
+		});
+		A(snapshot, "immutablePaths", () => {
+			if (process.versions.pnp === "1") {
+				const match =
+					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
+			} else if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						require.resolve("watchpack")
+					);
+				if (match) {
+					return [match[1]];
+				}
 			}
-		}
-		return [];
-	});
+			return [];
+		});
+	}
 	F(snapshot, "resolveBuildDependencies", () => ({
 		timestamp: true,
 		hash: true

package/lib/config/normalization.js

@@ -174,7 +174,12 @@ const getNormalizedWebpackOptions = config => {
 		experiments: nestedConfig(config.experiments, experiments => ({
 			...experiments,
 			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
-				options === true ? {} : options
+				Array.isArray(options) ? { allowedUris: options } : options
+			),
+			lazyCompilation: optionalNestedConfig(
+				experiments.lazyCompilation,
+				options =>
+					options === true ? {} : options === false ? undefined : options
 			)
 		})),
 		externals: config.externals,

package/lib/hmr/LazyCompilationPlugin.js

@@ -32,6 +32,12 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/**
+ * @typedef {Object} BackendApi
+ * @property {function(Error=): void} dispose
+ * @property {function(Module): { client: string, data: string, active: boolean }} module
+ */
+
 const IGNORED_DEPENDENCY_TYPES = new Set([
 	"import.meta.webpackHot.accept",
 	"import.meta.webpackHot.decline",
@@ -303,15 +309,13 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 class LazyCompilationPlugin {
 	/**
 	 * @param {Object} options options
-	 * @param {(function(Compiler, string, function(Error?, any?): void): void) | function(Compiler, string): Promise<any>} options.backend the backend
-	 * @param {string} options.client the client reference
+	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
 	 * @param {boolean} options.entries true, when entries are lazy compiled
 	 * @param {boolean} options.imports true, when import() modules are lazy compiled
 	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
 	 */
-	constructor({ backend, client, entries, imports, test }) {
+	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
-		this.client = client;
 		this.entries = entries;
 		this.imports = imports;
 		this.test = test;
@@ -327,7 +331,7 @@ class LazyCompilationPlugin {
 			"LazyCompilationPlugin",
 			(params, callback) => {
 				if (backend !== undefined) return callback();
-				const promise = this.backend(compiler, this.client, (err, result) => {
+				const promise = this.backend(compiler, (err, result) => {
 					if (err) return callback(err);
 					backend = result;
 					callback();

package/lib/hmr/lazyCompilationBackend.js

@@ -5,21 +5,46 @@
 
 "use strict";
 
-const http = require("http");
-
+/** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {string} client client reference
  * @param {function(Error?, any?): void} callback callback
  * @returns {void}
  */
-module.exports = (compiler, client, callback) => {
+
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+module.exports = options => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
 
+	const isHttps =
+		options.protocol === "https" ||
+		(typeof options.server === "object" &&
+			("key" in options.server || "pfx" in options.server));
+
+	const createServer =
+		typeof options.server === "function"
+			? options.server
+			: (() => {
+					const http = isHttps ? require("https") : require("http");
+					return http.createServer.bind(http, options.server);
+			  })();
+	const listen =
+		typeof options.listen === "function"
+			? options.listen
+			: server => server.listen(options.listen);
+
+	const protocol = options.protocol || (isHttps ? "https" : "http");
+
 	const requestListener = (req, res) => {
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
@@ -52,7 +77,10 @@ module.exports = (compiler, client, callback) => {
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
-	const server = http.createServer(requestListener);
+
+	const server = /** @type {import("net").Server} */ (createServer());
+	server.on("request", requestListener);
+
 	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
@@ -63,16 +91,19 @@ module.exports = (compiler, client, callback) => {
 		});
 		if (isClosing) socket.destroy();
 	});
-	server.listen(err => {
+	server.on("clientError", e => {
+		if (e.message !== "Server is disposing") logger.warn(e);
+	});
+	server.on("listening", err => {
 		if (err) return callback(err);
 		const addr = server.address();
 		if (typeof addr === "string") throw new Error("addr must not be a string");
 		const urlBase =
 			addr.address === "::" || addr.address === "0.0.0.0"
-				? `http://localhost:${addr.port}`
+				? `${protocol}://localhost:${addr.port}`
 				: addr.family === "IPv6"
-				? `http://[${addr.address}]:${addr.port}`
-				: `http://${addr.address}:${addr.port}`;
+				? `${protocol}://[${addr.address}]:${addr.port}`
+				: `${protocol}://${addr.address}:${addr.port}`;
 		logger.log(
 			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
 		);
@@ -94,11 +125,12 @@ module.exports = (compiler, client, callback) => {
 				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
 				const active = activeModules.get(key) > 0;
 				return {
-					client: `${client}?${encodeURIComponent(urlBase + prefix)}`,
+					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
 					data: key,
 					active
 				};
 			}
 		});
 	});
+	listen(server);
 };

package/lib/optimize/ConcatenatedModule.js

@@ -564,7 +564,7 @@ const getFinalName = (
 				? `(0,${reference})`
 				: asiSafe === false
 				? `;(0,${reference})`
-				: `Object(${reference})`;
+				: `/*#__PURE__*/Object(${reference})`;
 		}
 		return reference;
 	}

package/lib/optimize/SplitChunksPlugin.js

@@ -59,6 +59,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {boolean=} enforce
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -80,6 +81,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {GetName=} getName
  * @property {ChunkFilterFunction=} chunksFilter
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxAsyncSize
@@ -132,6 +134,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {ChunkFilterFunction} chunksFilter
  * @property {string[]} defaultSizeTypes
  * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
  * @property {SplitChunksSizes} minRemainingSize
  * @property {SplitChunksSizes} enforceSizeThreshold
  * @property {SplitChunksSizes} maxInitialSize
@@ -336,6 +339,21 @@ const checkMinSize = (sizes, minSize) => {
 	return true;
 };
 
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
+
 /**
  * @param {SplitChunksSizes} sizes the sizes
  * @param {SplitChunksSizes} minSize the min sizes
@@ -548,6 +566,10 @@ const checkModuleLayer = (test, module) => {
  */
 const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
+	);
 	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 	return {
 		key,
@@ -556,6 +578,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 		chunksFilter: normalizeChunksFilter(options.chunks),
 		enforce: options.enforce,
 		minSize,
+		minSizeReduction,
 		minRemainingSize: mergeSizes(
 			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 			minSize
@@ -594,6 +617,10 @@ module.exports = class SplitChunksPlugin {
 		];
 		const fallbackCacheGroup = options.fallbackCacheGroup || {};
 		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
 		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
 		/** @type {SplitChunksOptions} */
@@ -601,6 +628,7 @@ module.exports = class SplitChunksPlugin {
 			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
 			defaultSizeTypes,
 			minSize,
+			minSizeReduction,
 			minRemainingSize: mergeSizes(
 				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
 				minSize
@@ -668,6 +696,10 @@ module.exports = class SplitChunksPlugin {
 			cacheGroupSource.minSize,
 			cacheGroupSource.enforce ? undefined : this.options.minSize
 		);
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
 		const minRemainingSize = mergeSizes(
 			cacheGroupSource.minRemainingSize,
 			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
@@ -681,6 +713,7 @@ module.exports = class SplitChunksPlugin {
 			priority: cacheGroupSource.priority || 0,
 			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
 			minSize,
+			minSizeReduction,
 			minRemainingSize,
 			enforceSizeThreshold,
 			maxAsyncSize: mergeSizes(
@@ -774,9 +807,13 @@ module.exports = class SplitChunksPlugin {
 					const chunkIndexMap = new Map();
 					const ZERO = BigInt("0");
 					const ONE = BigInt("1");
-					let index = ONE;
+					const START = ONE << BigInt("31");
+					let index = START;
 					for (const chunk of chunks) {
-						chunkIndexMap.set(chunk, index);
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
 						index = index << ONE;
 					}
 					/**
@@ -793,7 +830,8 @@ module.exports = class SplitChunksPlugin {
 						let key =
 							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
 						while (!(result = iterator.next()).done) {
-							key = key | chunkIndexMap.get(result.value);
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
 						}
 						return key;
 					};
@@ -1239,6 +1277,14 @@ module.exports = class SplitChunksPlugin {
 					for (const [key, info] of chunksInfoMap) {
 						if (removeMinSizeViolatingModules(info)) {
 							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
 						}
 					}
 
@@ -1526,7 +1572,14 @@ module.exports = class SplitChunksPlugin {
 										chunksInfoMap.delete(key);
 										continue;
 									}
-									if (removeMinSizeViolatingModules(info)) {
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
 										chunksInfoMap.delete(key);
 										continue;
 									}