webpack 5.110.2 → 5.111.0

package/lib/serialization/ObjectMiddleware.js

@@ -107,21 +107,6 @@ Technically any value can be used.
  * @property {(context: ObjectDeserializerContext<EXPECTED_ANY>) => EXPECTED_ANY} deserialize
  */
 
-/**
- * Updates set size using the provided set.
- * @template T
- * @param {Set<T>} set set
- * @param {number} size count of items to keep
- */
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
-		}
-	}
-};
-
 /**
  * Updates map size using the provided map.
  * @template K, X
@@ -149,6 +134,9 @@ const toHash = (buffer, hashFunction) => {
 	return hash.digest("latin1");
 };
 
+/** Marks an object whose children are still being written; never a real position. */
+const IN_PROGRESS = -1;
+
 const ESCAPE = null;
 const ESCAPE_ESCAPE_VALUE = null;
 const ESCAPE_END_OBJECT = true;
@@ -463,16 +451,22 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
-		/** @type {Set<ComplexSerializableType>} */
-		const cycleStack = new Set();
+		/**
+		 * One-entry cache in front of `objectTypeLookup`, since runs of one class are common.
+		 * @type {SerializerConfigWithSerializer | undefined}
+		 */
+		let lastConfig;
+		/** @type {number} */
+		let lastConfigIndex = 0;
+		/** @type {ComplexSerializableType[]} */
+		const cycleStack = [];
 		/**
 		 * Returns stack.
 		 * @param {ComplexSerializableType} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = (item) => {
-			const arr = [...cycleStack];
-			arr.push(item);
+			const arr = [...cycleStack, item];
 			return arr
 				.map((item) => {
 					if (typeof item === "string") {
@@ -528,63 +522,35 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
-		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
-		let ctx = {
-			write(value) {
-				try {
-					process(/** @type {ComplexSerializableType} */ (value));
-				} catch (err) {
-					if (err !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined) {
-							hasDebugInfoAttached = new WeakSet();
-						}
-						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
-							/** @type {Error} */
-							(err).message +=
-								`\nwhile serializing ${stackToString(/** @type {ComplexSerializableType} */ (value))}`;
-							hasDebugInfoAttached.add(/** @type {Error} */ (err));
-						}
-					}
-					throw err;
-				}
-				return ctx;
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
+		/**
+		 * Appends the path from the root to `item`, once per error.
+		 * @param {Error} err error thrown while writing `item`
+		 * @param {ComplexSerializableType} item item being written
+		 * @returns {Error} err
+		 */
+		const attachSerializationPath = (err, item) => {
+			if (hasDebugInfoAttached === undefined) {
+				hasDebugInfoAttached = new WeakSet();
+			}
+			if (!hasDebugInfoAttached.has(err)) {
+				err.message += `\nwhile serializing ${stackToString(item)}`;
+				hasDebugInfoAttached.add(err);
+			}
+			return err;
 		};
-		this.extendContext(ctx);
 		// Dispatched on `typeof` first: two thirds of the items are numbers,
 		// booleans and `undefined`, and only 3% are buffers.
 		/**
-		 * Processes the provided item.
+		 * Writes one item into the output; the context is returned so writes chain.
 		 * @param {ComplexSerializableType} item item to serialize
+		 * @returns {ObjectSerializerContext<EXPECTED_ANY>} context
 		 */
 		const process = (item) => {
 			switch (typeof item) {
 				case "number":
 				case "boolean":
 					result.push(item);
-					return;
+					return ctx;
 				case "string": {
 					if (item.length > 1) {
 						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
@@ -602,10 +568,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 							) {
 								// A back-reference is `null` + the offset.
 								result.push(ESCAPE, offset);
-								return;
+								return ctx;
 							}
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 					}
 
 					if (item.length > 102400 && context.logger) {
@@ -617,87 +583,115 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 
 					result.push(item);
-					return;
+					return ctx;
 				}
 				case "undefined":
 					result.push(ESCAPE, ESCAPE_UNDEFINED);
-					return;
+					return ctx;
 				case "object": {
 					// ESCAPE is null, so this covers null too
 					if (item === ESCAPE) {
 						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-						return;
+						return ctx;
 					}
 
-					if (Buffer.isBuffer(item)) {
-						// check if we can emit a reference
-						const ref = referenceable.get(item);
-						if (ref !== undefined) {
-							result.push(ESCAPE, ref - currentPos);
-							return;
+					// buffers and objects share one reference table, so a single
+					// lookup answers both before the costlier buffer test
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						if (ref === IN_PROGRESS) {
+							throw attachSerializationPath(
+								new Error(
+									"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+								),
+								item
+							);
 						}
+						result.push(ESCAPE, ref - currentPos);
+						return ctx;
+					}
+
+					if (Buffer.isBuffer(item)) {
 						const alreadyUsedBuffer = dedupeBuffer(item);
 						if (alreadyUsedBuffer !== item) {
 							const ref = referenceable.get(alreadyUsedBuffer);
 							if (ref !== undefined) {
 								referenceable.set(item, ref);
 								result.push(ESCAPE, ref - currentPos);
-								return;
+								return ctx;
 							}
 							item = alreadyUsedBuffer;
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 
 						result.push(/** @type {Buffer} */ (item));
-						return;
-					}
-
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-
-					if (cycleStack.has(item)) {
-						throw new Error(
-							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-						);
+						return ctx;
 					}
 
 					// Keyed by the registration itself: one per class, so it stands in for
 					// `${request}/${name}` without building that string per object.
-					const config = ObjectMiddleware.getSerializerFor(
-						/** @type {Constructor} */
-						(item)
+					const proto = Object.getPrototypeOf(item);
+					const registered = serializers.get(
+						proto === null ? null : proto.constructor
 					);
+					/** @type {SerializerConfigWithSerializer} */
+					let config;
+					if (registered !== undefined && registered.serializer !== undefined) {
+						config = /** @type {SerializerConfigWithSerializer} */ (registered);
+					} else {
+						try {
+							// re-resolved so the miss reports which class is unregistered
+							config = ObjectMiddleware.getSerializerFor(
+								/** @type {Constructor} */
+								(item)
+							);
+						} catch (err) {
+							if (err === NOT_SERIALIZABLE) throw err;
+							throw attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+					}
 					const { request, name, serializer } = config;
-					const lastIndex = objectTypeLookup.get(config);
+					const lastIndex =
+						config === lastConfig
+							? lastConfigIndex
+							: objectTypeLookup.get(config);
 
 					if (lastIndex === undefined) {
-						objectTypeLookup.set(config, currentPosTypeLookup++);
+						lastConfigIndex = currentPosTypeLookup++;
+						objectTypeLookup.set(config, lastConfigIndex);
 
 						result.push(ESCAPE, request, name);
 					} else {
+						lastConfigIndex = lastIndex;
 						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
 					}
+					lastConfig = config;
 
-					cycleStack.add(item);
+					referenceable.set(item, IN_PROGRESS);
+					cycleStack.push(item);
 
 					try {
 						serializer.serialize(item, ctx);
-					} finally {
-						cycleStack.delete(item);
+					} catch (err) {
+						cycleStack.pop();
+						if (err !== NOT_SERIALIZABLE) {
+							attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+						throw err;
 					}
+					cycleStack.pop();
 
 					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-					addReferenceable(item);
-					return;
+					referenceable.set(item, currentPos++);
+					return ctx;
 				}
 				case "function": {
 					if (!SerializerMiddleware.isLazy(item)) {
-						throw new Error(`Unexpected function ${item}`);
+						throw attachSerializationPath(
+							new Error(`Unexpected function ${item}`),
+							item
+						);
 					}
 
 					/** @type {SerializedType | undefined} */
@@ -708,10 +702,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 						if (typeof serializedData === "function") {
 							result.push(serializedData);
 						} else {
-							throw new Error("Not implemented");
+							throw attachSerializationPath(new Error("Not implemented"), item);
 						}
 					} else if (SerializerMiddleware.isLazy(item, this)) {
-						throw new Error("Not implemented");
+						throw attachSerializationPath(new Error("Not implemented"), item);
 					} else {
 						const data =
 							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
@@ -723,12 +717,50 @@ class ObjectMiddleware extends SerializerMiddleware {
 						SerializerMiddleware.setLazySerializedValue(item, data);
 						result.push(data);
 					}
-					return;
+					return ctx;
 				}
 				default:
 					result.push(item);
 			}
+			return ctx;
 		};
+		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
+		let ctx = {
+			write: process,
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			snapshot() {
+				return {
+					length: result.length,
+					cycleStackSize: cycleStack.length,
+					referenceableSize: referenceable.size,
+					currentPos,
+					objectTypeLookupSize: objectTypeLookup.size,
+					currentPosTypeLookup
+				};
+			},
+			rollback(snapshot) {
+				result.length = snapshot.length;
+				cycleStack.length = snapshot.cycleStackSize;
+				// a `setCircularReference` since the snapshot replaced a marker on an
+				// item already keyed here, which `setMapSize` cannot undo
+				for (let i = 0; i < cycleStack.length; i++) {
+					const item = /** @type {ReferenceableItem} */ (cycleStack[i]);
+					const ref = referenceable.get(item);
+					if (ref !== undefined && ref >= snapshot.currentPos) {
+						referenceable.set(item, IN_PROGRESS);
+					}
+				}
+				setMapSize(referenceable, snapshot.referenceableSize);
+				currentPos = snapshot.currentPos;
+				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+				lastConfig = undefined;
+				currentPosTypeLookup = snapshot.currentPosTypeLookup;
+			},
+			...context
+		};
+		this.extendContext(ctx);
 
 		try {
 			for (const item of data) {

package/lib/sharing/ConsumeSharedPlugin.js

@@ -15,6 +15,7 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 const ConsumeSharedModule = require("./ConsumeSharedModule");
 const ConsumeSharedRuntimeModule = require("./ConsumeSharedRuntimeModule");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
+const { addDeclaredShared } = require("./declaredShared");
 const { resolveMatchedConfigs } = require("./resolveMatchedConfigs");
 const {
 	getDescriptionFile,
@@ -137,6 +138,17 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
+				// A key ending in a slash shares everything under it, and the
+				// modules then carry the remainder appended to the share key.
+				addDeclaredShared(
+					compilation,
+					consumes.map(([key, config]) => ({
+						name: key,
+						shareKey: config.shareKey,
+						prefix: key.endsWith("/")
+					}))
+				);
+
 				/** @typedef {Map<string, ConsumeOptions>} Consumes */
 
 				/** @type {Consumes} */

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -33,6 +33,17 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+			? [[RuntimeGlobals.ensureChunkHandlers, "consumes"]]
+			: [];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/ShareRuntimeModule.js

@@ -23,6 +23,15 @@ class ShareRuntimeModule extends RuntimeModule {
 		super("sharing");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/declaredShared.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Compilation from "../Compilation" */
+
+/**
+ * @typedef {object} SharedDeclaration
+ * @property {string} name the config key, as the config spells it
+ * @property {string} shareKey the key the modules created for it carry
+ * @property {boolean} prefix whether it shares everything under the key
+ */
+
+/** @type {WeakMap<Compilation, SharedDeclaration[]>} */
+const DECLARED_SHARED = new WeakMap();
+
+/**
+ * What this build declared as shared, one entry per config key, since several
+ * may name one share key. `performance.unusedConfig` matches modules on the
+ * share key and reports the config key.
+ * @param {Compilation} compilation the compilation
+ * @returns {SharedDeclaration[] | undefined} the declarations, when any were made
+ */
+const getDeclaredShared = (compilation) => DECLARED_SHARED.get(compilation);
+
+/**
+ * Records declarations, appending when a build applies the plugin more than
+ * once, as `ModuleFederationPlugin` and `SharePlugin` do.
+ * @param {Compilation} compilation the compilation
+ * @param {SharedDeclaration[]} declarations what this application declared
+ * @returns {void}
+ */
+const addDeclaredShared = (compilation, declarations) => {
+	const declared = DECLARED_SHARED.get(compilation);
+
+	if (declared === undefined) {
+		DECLARED_SHARED.set(compilation, [...declarations]);
+	} else {
+		for (const declaration of declarations) declared.push(declaration);
+	}
+};
+
+module.exports.addDeclaredShared = addDeclaredShared;
+module.exports.getDeclaredShared = getDeclaredShared;

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1340,9 +1340,11 @@ const SIMPLE_EXTRACTORS = {
 			const warnings = module.getWarnings();
 			const warningsCount =
 				warnings !== undefined ? countIterable(warnings) : 0;
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (
 				module.buildInfo
 			);
+			const notCacheableReasons =
+				diagnostics === undefined ? undefined : diagnostics.notCacheableReasons;
 			const preOrderIndex = /** @type {number} */ (
 				moduleGraph.getPreOrderIndex(module)
 			);

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -460,6 +460,8 @@ const ASSET_SIMPLE_PRINTERS = {
 		javascriptModule ? formatFlag("javascript module") : undefined,
 	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
 		sourceFilename ? formatFlag(`from: ${sourceFilename}`) : undefined,
+	"asset.info.copied": (copied, { green, formatFlag }) =>
+		copied ? green(formatFlag("copied")) : undefined,
 	"asset.info.development": (development, { green, formatFlag }) =>
 		development ? green(formatFlag("dev")) : undefined,
 	"asset.info.hotModuleReplacement": (
@@ -1045,6 +1047,7 @@ const PREFERRED_ORDERS = {
 	"asset.info": [
 		"immutable",
 		"sourceFilename",
+		"copied",
 		"javascriptModule",
 		"development",
 		"hotModuleReplacement"

package/lib/util/ArrayQueue.js

@@ -90,11 +90,11 @@ class ArrayQueue {
 	[Symbol.iterator]() {
 		return {
 			next: () => {
-				const item = this.dequeue();
-				if (item) {
+				// length, not truthiness: a queued `0`/`false`/`undefined` is a value
+				if (this.length > 0) {
 					return {
 						done: false,
-						value: item
+						value: /** @type {T} */ (this.dequeue())
 					};
 				}
 				return {