webpack 5.97.1 → 5.104.1

package/lib/util/serialization.js

@@ -4,16 +4,19 @@
 
 "use strict";
 
+const { DEFAULTS } = require("../config/defaults");
 const memoize = require("./memoize");
 
 /** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
 /** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../serialization/Serializer")} Serializer */
 /** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/**
+ * @template D, S, C
+ * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
+ */
+
 const getBinaryMiddleware = memoize(() =>
 	require("../serialization/BinaryMiddleware")
 );
@@ -38,7 +41,8 @@ const registerSerializers = memoize(() => {
 	// Load internal paths with a relative require
 	// This allows bundling all internal serializers
 	const internalSerializables = require("./internalSerializables");
-	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
+
+	getObjectMiddleware().registerLoader(/^webpack\/lib\//, (req) => {
 		const loader =
 			internalSerializables[
 				/** @type {keyof import("./internalSerializables")} */
@@ -47,13 +51,16 @@ const registerSerializers = memoize(() => {
 		if (loader) {
 			loader();
 		} else {
+			// eslint-disable-next-line no-console
 			console.warn(`${req} not found in internalSerializables`);
 		}
 		return true;
 	});
 });
 
-/** @type {Serializer} */
+/**
+ * @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>}
+ */
 let buffersSerializer;
 
 // Expose serialization API
@@ -78,9 +85,6 @@ module.exports = {
 	get MEASURE_END_OPERATION() {
 		return getBinaryMiddleware().MEASURE_END_OPERATION;
 	},
-	/**
-	 * @returns {Serializer} buffer serializer
-	 */
 	get buffersSerializer() {
 		if (buffersSerializer !== undefined) return buffersSerializer;
 		registerSerializers();
@@ -88,66 +92,62 @@ module.exports = {
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return (buffersSerializer = new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					/**
-					 * @param {any} value value
-					 */
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-				}
-			}, "md4"),
-			binaryMiddleware
-		]));
+		return /** @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} */ (
+			buffersSerializer = new Serializer([
+				new SingleItemMiddleware(),
+				new (getObjectMiddleware())((context) => {
+					if ("write" in context) {
+						context.writeLazy = (value) => {
+							context.write(
+								SerializerMiddleware.createLazy(value, binaryMiddleware)
+							);
+						};
+					}
+				}, DEFAULTS.HASH_FUNCTION),
+				binaryMiddleware
+			])
+		);
 	},
 	/**
+	 * @template D, S, C
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {string | Hash} hashFunction hash function to use
-	 * @returns {Serializer} file serializer
+	 * @returns {Serializer<D, S, C>} file serializer
 	 */
 	createFileSerializer: (fs, hashFunction) => {
 		registerSerializers();
 		const Serializer = getSerializer();
+
 		const FileMiddleware = require("../serialization/FileMiddleware");
+
 		const fileMiddleware = new FileMiddleware(fs, hashFunction);
 		const binaryMiddleware = getBinaryMiddlewareInstance();
 		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
-		return new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					/**
-					 * @param {any} value value
-					 */
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-					/**
-					 * @param {any} value value
-					 * @param {object=} options lazy options
-					 * @returns {function(): Promise<any> | any} lazy function
-					 */
-					context.writeSeparate = (value, options) => {
-						const lazy = SerializerMiddleware.createLazy(
-							value,
-							fileMiddleware,
-							options
-						);
-						context.write(lazy);
-						return lazy;
-					};
-				}
-			}, hashFunction),
-			binaryMiddleware,
-			fileMiddleware
-		]);
+		return /** @type {Serializer<D, S, C>} */ (
+			new Serializer([
+				new SingleItemMiddleware(),
+				new (getObjectMiddleware())((context) => {
+					if ("write" in context) {
+						context.writeLazy = (value) => {
+							context.write(
+								SerializerMiddleware.createLazy(value, binaryMiddleware)
+							);
+						};
+						context.writeSeparate = (value, options) => {
+							const lazy = SerializerMiddleware.createLazy(
+								value,
+								fileMiddleware,
+								options
+							);
+							context.write(lazy);
+							return lazy;
+						};
+					}
+				}, hashFunction),
+				binaryMiddleware,
+				fileMiddleware
+			])
+		);
 	}
 };

package/lib/util/smartGrouping.js

@@ -13,42 +13,53 @@
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
  * @typedef {object} GroupConfig
- * @property {function(T): string[] | undefined} getKeys
- * @property {function(string, (R | T)[], T[]): R} createGroup
- * @property {function(string, T[]): GroupOptions=} getOptions
+ * @property {(item: I) => string[] | undefined} getKeys
+ * @property {(name: string, items: I[]) => GroupOptions=} getOptions
+ * @property {(key: string, children: I[], items: I[]) => G} createGroup
  */
 
 /**
- * @template T
- * @template R
+ * @template I
+ * @template G
+ * @typedef {{ config: GroupConfig<I, G>, name: string, alreadyGrouped: boolean, items: Items<I, G> | undefined }} Group
+ */
+
+/**
+ * @template I, G
+ * @typedef {Set<Group<I, G>>} Groups
+ */
+
+/**
+ * @template I
+ * @template G
  * @typedef {object} ItemWithGroups
- * @property {T} item
- * @property {Set<Group<T, R>>} groups
+ * @property {I} item
+ * @property {Groups<I, G>} groups
  */
 
 /**
- * @template T
- * @template R
- * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
+ * @template T, G
+ * @typedef {Set<ItemWithGroups<T, G>>} Items
  */
 
 /**
- * @template T
+ * @template I
+ * @template G
  * @template R
- * @param {T[]} items the list of items
- * @param {GroupConfig<T, R>[]} groupConfigs configuration
- * @returns {(R | T)[]} grouped items
+ * @param {I[]} items the list of items
+ * @param {GroupConfig<I, G>[]} groupConfigs configuration
+ * @returns {(I | G)[]} grouped items
  */
 const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T, R>>} */
+	/** @type {Items<I, G>} */
 	const itemsWithGroups = new Set();
-	/** @type {Map<string, Group<T, R>>} */
+	/** @type {Map<string, Group<I, G>>} */
 	const allGroups = new Map();
 	for (const item of items) {
-		/** @type {Set<Group<T, R>>} */
+		/** @type {Groups<I, G>} */
 		const groups = new Set();
 		for (let i = 0; i < groupConfigs.length; i++) {
 			const groupConfig = groupConfigs[i];
@@ -77,11 +88,12 @@ const smartGrouping = (items, groupConfigs) => {
 			groups
 		});
 	}
+
 	/**
-	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
-	 * @returns {(T | R)[]} groups items
+	 * @param {Items<I, G>} itemsWithGroups input items with groups
+	 * @returns {(I | G)[]} groups items
 	 */
-	const runGrouping = itemsWithGroups => {
+	const runGrouping = (itemsWithGroups) => {
 		const totalSize = itemsWithGroups.size;
 		for (const entry of itemsWithGroups) {
 			for (const group of entry.groups) {
@@ -94,7 +106,7 @@ const smartGrouping = (items, groupConfigs) => {
 				}
 			}
 		}
-		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		/** @type {Map<Group<I, G>, { items: Items<I, G>, options: GroupOptions | false | undefined, used: boolean }>} */
 		const groupMap = new Map();
 		for (const group of allGroups.values()) {
 			if (group.items) {
@@ -107,13 +119,15 @@ const smartGrouping = (items, groupConfigs) => {
 				});
 			}
 		}
-		/** @type {(T | R)[]} */
+		/** @type {(I | G)[]} */
 		const results = [];
 		for (;;) {
-			/** @type {Group<T, R> | undefined} */
+			/** @type {Group<I, G> | undefined} */
 			let bestGroup;
 			let bestGroupSize = -1;
+			/** @type {Items<I, G> | undefined} */
 			let bestGroupItems;
+			/** @type {GroupOptions | false | undefined} */
 			let bestGroupOptions;
 			for (const [group, state] of groupMap) {
 				const { items, used } = state;
@@ -192,8 +206,9 @@ const smartGrouping = (items, groupConfigs) => {
 			bestGroup.alreadyGrouped = true;
 			const children = groupChildren ? runGrouping(items) : allItems;
 			bestGroup.alreadyGrouped = false;
-
-			results.push(groupConfig.createGroup(key, children, allItems));
+			results.push(
+				groupConfig.createGroup(key, /** @type {I[]} */ (children), allItems)
+			);
 		}
 		for (const { item } of itemsWithGroups) {
 			results.push(item);

package/lib/util/source.js

@@ -17,14 +17,14 @@ const equalityCache = new WeakMap();
  */
 const _isSourceEqual = (a, b) => {
 	// prefer .buffer(), it's called anyway during emit
-	/** @type {Buffer|string} */
+	/** @type {Buffer | string} */
 	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
-	/** @type {Buffer|string} */
+	/** @type {Buffer | string} */
 	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
 	if (aSource === bSource) return true;
 	if (typeof aSource === "string" && typeof bSource === "string") return false;
-	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
-	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
+	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf8");
+	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf8");
 	return aSource.equals(bSource);
 };
 
@@ -58,4 +58,5 @@ const isSourceEqual = (a, b) => {
 	}
 	return result;
 };
+
 module.exports.isSourceEqual = isSourceEqual;

package/lib/util/traverseDestructuringAssignmentProperties.js

@@ -0,0 +1,45 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+
+/**
+ * Deep first traverse the properties of a destructuring assignment.
+ * @param {DestructuringAssignmentProperties} properties destructuring assignment properties
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} onLeftNode on left node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} enterNode enter node callback
+ * @param {((stack: DestructuringAssignmentProperty[]) => void) | undefined=} exitNode exit node callback
+ * @param {DestructuringAssignmentProperty[] | undefined=} stack stack of the walking nodes
+ */
+function traverseDestructuringAssignmentProperties(
+	properties,
+	onLeftNode,
+	enterNode,
+	exitNode,
+	stack = []
+) {
+	for (const property of properties) {
+		stack.push(property);
+		if (enterNode) enterNode(stack);
+		if (property.pattern) {
+			traverseDestructuringAssignmentProperties(
+				property.pattern,
+				onLeftNode,
+				enterNode,
+				exitNode,
+				stack
+			);
+		} else if (onLeftNode) {
+			onLeftNode(stack);
+		}
+		if (exitNode) exitNode(stack);
+		stack.pop();
+	}
+}
+
+module.exports = traverseDestructuringAssignmentProperties;

package/lib/validateSchema.js

@@ -85,9 +85,9 @@ const validateSchema = (schema, options, validationConfiguration) => {
 				if (
 					children &&
 					children.some(
-						child =>
+						(child) =>
 							child.keyword === "absolutePath" &&
-							child.dataPath === ".output.filename"
+							child.instancePath === "/output/filename"
 					)
 				) {
 					return `${formattedError}\nPlease use output.path to specify absolute path and output.filename for the file name.`;
@@ -96,8 +96,8 @@ const validateSchema = (schema, options, validationConfiguration) => {
 				if (
 					children &&
 					children.some(
-						child =>
-							child.keyword === "pattern" && child.dataPath === ".devtool"
+						(child) =>
+							child.keyword === "pattern" && child.instancePath === "/devtool"
 					)
 				) {
 					return (
@@ -108,10 +108,7 @@ const validateSchema = (schema, options, validationConfiguration) => {
 				}
 
 				if (error.keyword === "additionalProperties") {
-					const params =
-						/** @type {import("ajv").AdditionalPropertiesParams} */ (
-							error.params
-						);
+					const params = error.params;
 					if (
 						Object.prototype.hasOwnProperty.call(
 							DID_YOU_MEAN,
@@ -136,7 +133,7 @@ const validateSchema = (schema, options, validationConfiguration) => {
 						}?`;
 					}
 
-					if (!error.dataPath) {
+					if (!error.instancePath) {
 						if (params.additionalProperty === "debug") {
 							return (
 								`${formattedError}\n` +
@@ -176,4 +173,5 @@ const validateSchema = (schema, options, validationConfiguration) => {
 		}
 	);
 };
+
 module.exports = validateSchema;

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -5,18 +5,19 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
 /** @typedef {import("../Compiler")} Compiler */
 
+/** @typedef {Set<WasmLoadingType>} WasmLoadingTypes */
+
 /** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
 const enabledTypes = new WeakMap();
 
 /**
  * @param {Compiler} compiler compiler instance
- * @returns {Set<WasmLoadingType>} enabled types
+ * @returns {WasmLoadingTypes} enabled types
  */
-const getEnabledTypes = compiler => {
+const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {
 		set = new Set();
@@ -54,9 +55,7 @@ class EnableWasmLoadingPlugin {
 					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
 					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
 					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
-					`These types are enabled: ${Array.from(
-						getEnabledTypes(compiler)
-					).join(", ")}`
+					`These types are enabled: ${[...getEnabledTypes(compiler)].join(", ")}`
 			);
 		}
 	}
@@ -78,8 +77,8 @@ class EnableWasmLoadingPlugin {
 			switch (type) {
 				case "fetch": {
 					if (compiler.options.experiments.syncWebAssembly) {
-						// TODO webpack 6 remove FetchCompileWasmPlugin
 						const FetchCompileWasmPlugin = require("../web/FetchCompileWasmPlugin");
+
 						new FetchCompileWasmPlugin({
 							mangleImports: compiler.options.optimization.mangleWasmImports
 						}).apply(compiler);
@@ -87,6 +86,7 @@ class EnableWasmLoadingPlugin {
 
 					if (compiler.options.experiments.asyncWebAssembly) {
 						const FetchCompileAsyncWasmPlugin = require("../web/FetchCompileAsyncWasmPlugin");
+
 						new FetchCompileAsyncWasmPlugin().apply(compiler);
 					}
 
@@ -94,21 +94,22 @@ class EnableWasmLoadingPlugin {
 				}
 				case "async-node": {
 					if (compiler.options.experiments.syncWebAssembly) {
-						// TODO webpack 6 remove ReadFileCompileWasmPlugin
 						const ReadFileCompileWasmPlugin = require("../node/ReadFileCompileWasmPlugin");
+
 						new ReadFileCompileWasmPlugin({
 							mangleImports: compiler.options.optimization.mangleWasmImports,
 							import:
-								compiler.options.output.environment.module &&
+								compiler.options.output.module &&
 								compiler.options.output.environment.dynamicImport
 						}).apply(compiler);
 					}
 
 					if (compiler.options.experiments.asyncWebAssembly) {
 						const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
+
 						new ReadFileCompileAsyncWasmPlugin({
 							import:
-								compiler.options.output.environment.module &&
+								compiler.options.output.module &&
 								compiler.options.output.environment.dynamicImport
 						}).apply(compiler);
 					}
@@ -116,8 +117,17 @@ class EnableWasmLoadingPlugin {
 					break;
 				}
 				case "universal": {
-					const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
-					new UniversalCompileAsyncWasmPlugin().apply(compiler);
+					if (compiler.options.experiments.syncWebAssembly) {
+						throw new Error(
+							"Universal wasm loading type is only supported by asynchronous web assembly."
+						);
+					}
+
+					if (compiler.options.experiments.asyncWebAssembly) {
+						const UniversalCompileAsyncWasmPlugin = require("../wasm-async/UniversalCompileAsyncWasmPlugin");
+
+						new UniversalCompileAsyncWasmPlugin().apply(compiler);
+					}
 					break;
 				}
 				default:

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -14,9 +14,9 @@ const Template = require("../Template");
 
 /**
  * @typedef {object} AsyncWasmLoadingRuntimeModuleOptions
- * @property {(function(string): string)=} generateBeforeLoadBinaryCode
- * @property {function(string): string} generateLoadBinaryCode
- * @property {(function(): string)=} generateBeforeInstantiateStreaming
+ * @property {((wasmModuleSrcPath: string) => string)=} generateBeforeLoadBinaryCode
+ * @property {(wasmModuleSrcPath: string) => string} generateLoadBinaryCode
+ * @property {(() => string)=} generateBeforeInstantiateStreaming
  * @property {boolean} supportsStreaming
  */
 
@@ -50,7 +50,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 			JSON.stringify(outputOptions.webassemblyModuleFilename),
 			{
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
+				hashWithLength: (length) =>
 					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
 				module: {
 					id: '" + wasmModuleId + "',
@@ -76,7 +76,11 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 			)})`
 		];
 		const getStreaming = () => {
-			const concat = (/** @type {string[]} */ ...text) => text.join("");
+			/**
+			 * @param {string[]} text text
+			 * @returns {string} merged text
+			 */
+			const concat = (...text) => text.join("");
 			return [
 				this.generateBeforeLoadBinaryCode
 					? this.generateBeforeLoadBinaryCode(wasmModuleSrcPath)

package/lib/wasm-async/AsyncWebAssemblyGenerator.js

@@ -5,17 +5,19 @@
 
 "use strict";
 
+const { RawSource } = require("webpack-sources");
 const Generator = require("../Generator");
-const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypesConstants");
+const { WEBASSEMBLY_TYPES } = require("../ModuleSourceTypeConstants");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 
 /**
  * @typedef {object} AsyncWebAssemblyGeneratorOptions
- * @property {boolean} [mangleImports] mangle imports
+ * @property {boolean=} mangleImports mangle imports
  */
 
 class AsyncWebAssemblyGenerator extends Generator {
@@ -37,7 +39,7 @@ class AsyncWebAssemblyGenerator extends Generator {
 
 	/**
 	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
+	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
@@ -56,6 +58,16 @@ class AsyncWebAssemblyGenerator extends Generator {
 	generate(module, generateContext) {
 		return /** @type {Source} */ (module.originalSource());
 	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(error.message);
+	}
 }
 
 module.exports = AsyncWebAssemblyGenerator;