webpack 5.99.6 → 5.99.8

package/lib/schemes/HttpUriPlugin.js

@@ -16,6 +16,7 @@ const { mkdirp, dirname, join } = require("../util/fs");
 const memoize = require("../util/memoize");
 
 /** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").OutgoingHttpHeaders} OutgoingHttpHeaders */
 /** @typedef {import("http").RequestOptions} RequestOptions */
 /** @typedef {import("net").Socket} Socket */
 /** @typedef {import("stream").Readable} Readable */
@@ -147,7 +148,7 @@ const parseKeyValuePairs = str => {
 /**
  * @param {string | undefined} cacheControl Cache-Control header
  * @param {number} requestTime timestamp of request
- * @returns {{storeCache: boolean, storeLock: boolean, validUntil: number}} Logic for storing in cache and lockfile cache
+ * @returns {{ storeCache: boolean, storeLock: boolean, validUntil: number }} Logic for storing in cache and lockfile cache
  */
 const parseCacheControl = (cacheControl, requestTime) => {
 	// When false resource is not stored in cache
@@ -190,7 +191,7 @@ const areLockfileEntriesEqual = (a, b) =>
 
 /**
  * @param {LockfileEntry} entry lockfile entry
- * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${*}`} stringified entry
+ * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${string}`} stringified entry
  */
 const entryToString = entry =>
 	`resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
@@ -405,6 +406,8 @@ const cachedWithKey = (fn, forceFn = fn) => {
 /** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
 /** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
+const PLUGIN_NAME = "HttpUriPlugin";
+
 class HttpUriPlugin {
 	/**
 	 * @param {HttpUriPluginOptions} options options
@@ -440,14 +443,14 @@ class HttpUriPlugin {
 		/** @type {LockfileCache} */
 		let lockfileCache;
 		compiler.hooks.compilation.tap(
-			"HttpUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const intermediateFs =
 					/** @type {IntermediateFileSystem} */
 					(compiler.intermediateFileSystem);
 				const fs = compilation.inputFileSystem;
-				const cache = compilation.getCache("webpack.HttpUriPlugin");
-				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				const cache = compilation.getCache(`webpack.${PLUGIN_NAME}`);
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				/** @type {string} */
 				const lockfileLocation =
 					this._lockfileLocation ||
@@ -634,11 +637,14 @@ class HttpUriPlugin {
 					const resolveContent = (url, integrity, callback) => {
 						/**
 						 * @param {Error | null} err error
-						 * @param {TODO} result result result
+						 * @param {FetchResult=} _result fetch result
 						 * @returns {void}
 						 */
-						const handleResult = (err, result) => {
+						const handleResult = (err, _result) => {
 							if (err) return callback(err);
+
+							const result = /** @type {FetchResult} */ (_result);
+
 							if ("location" in result) {
 								return resolveContent(
 									result.location,
@@ -655,6 +661,7 @@ class HttpUriPlugin {
 									}
 								);
 							}
+
 							if (
 								!result.fresh &&
 								integrity &&
@@ -663,12 +670,14 @@ class HttpUriPlugin {
 							) {
 								return fetchContent.force(url, handleResult);
 							}
+
 							return callback(null, {
 								entry: result.entry,
 								content: result.content,
 								storeLock: result.storeLock
 							});
 						};
+
 						fetchContent(url, handleResult);
 					};
 
@@ -680,164 +689,162 @@ class HttpUriPlugin {
 					 */
 					const fetchContentRaw = (url, cachedResult, callback) => {
 						const requestTime = Date.now();
-						fetch(
-							new URL(url),
-							{
-								headers: {
-									"accept-encoding": "gzip, deflate, br",
-									"user-agent": "webpack",
-									"if-none-match": /** @type {TODO} */ (
-										cachedResult ? cachedResult.etag || null : null
-									)
-								}
-							},
-							res => {
-								const etag = res.headers.etag;
-								const location = res.headers.location;
-								const cacheControl = res.headers["cache-control"];
-								const { storeLock, storeCache, validUntil } = parseCacheControl(
-									cacheControl,
-									requestTime
-								);
-								/**
-								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
-								 * @returns {void}
-								 */
-								const finishWith = partialResult => {
-									if ("location" in partialResult) {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
-										);
-									} else {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] ${Math.ceil(
-												partialResult.content.length / 1024
-											)} kB${!storeLock ? " no-cache" : ""}`
-										);
-									}
-									const result = {
-										...partialResult,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									};
-									if (!storeCache) {
-										logger.log(
-											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
-										);
-										return callback(null, result);
-									}
-									cache.store(
-										url,
-										null,
-										{
-											...result,
-											fresh: false
-										},
-										err => {
-											if (err) {
-												logger.warn(
-													`${url} can't be stored in cache: ${err.message}`
-												);
-												logger.debug(err.stack);
-											}
-											callback(null, result);
-										}
+						/** @type {OutgoingHttpHeaders} */
+						const headers = {
+							"accept-encoding": "gzip, deflate, br",
+							"user-agent": "webpack"
+						};
+
+						if (cachedResult && cachedResult.etag) {
+							headers["if-none-match"] = cachedResult.etag;
+						}
+
+						fetch(new URL(url), { headers }, res => {
+							const etag = res.headers.etag;
+							const location = res.headers.location;
+							const cacheControl = res.headers["cache-control"];
+							const { storeLock, storeCache, validUntil } = parseCacheControl(
+								cacheControl,
+								requestTime
+							);
+							/**
+							 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
+							 * @returns {void}
+							 */
+							const finishWith = partialResult => {
+								if ("location" in partialResult) {
+									logger.debug(
+										`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
+									);
+								} else {
+									logger.debug(
+										`GET ${url} [${res.statusCode}] ${Math.ceil(
+											partialResult.content.length / 1024
+										)} kB${!storeLock ? " no-cache" : ""}`
 									);
+								}
+								const result = {
+									...partialResult,
+									fresh: true,
+									storeLock,
+									storeCache,
+									validUntil,
+									etag
 								};
-								if (res.statusCode === 304) {
-									const result = /** @type {FetchResult} */ (cachedResult);
-									if (
-										result.validUntil < validUntil ||
-										result.storeLock !== storeLock ||
-										result.storeCache !== storeCache ||
-										result.etag !== etag
-									) {
-										return finishWith(result);
-									}
-									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-									return callback(null, { ...result, fresh: true });
+								if (!storeCache) {
+									logger.log(
+										`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
+									);
+									return callback(null, result);
 								}
+								cache.store(
+									url,
+									null,
+									{
+										...result,
+										fresh: false
+									},
+									err => {
+										if (err) {
+											logger.warn(
+												`${url} can't be stored in cache: ${err.message}`
+											);
+											logger.debug(err.stack);
+										}
+										callback(null, result);
+									}
+								);
+							};
+							if (res.statusCode === 304) {
+								const result = /** @type {FetchResult} */ (cachedResult);
 								if (
-									location &&
-									res.statusCode &&
-									res.statusCode >= 301 &&
-									res.statusCode <= 308
+									result.validUntil < validUntil ||
+									result.storeLock !== storeLock ||
+									result.storeCache !== storeCache ||
+									result.etag !== etag
 								) {
-									const result = {
-										location: new URL(location, url).href
-									};
-									if (
-										!cachedResult ||
-										!("location" in cachedResult) ||
-										cachedResult.location !== result.location ||
-										cachedResult.validUntil < validUntil ||
-										cachedResult.storeLock !== storeLock ||
-										cachedResult.storeCache !== storeCache ||
-										cachedResult.etag !== etag
-									) {
-										return finishWith(result);
-									}
-									logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-									return callback(null, {
-										...result,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									});
+									return finishWith(result);
 								}
-								const contentType = res.headers["content-type"] || "";
-								/** @type {Buffer[]} */
-								const bufferArr = [];
-
-								const contentEncoding = res.headers["content-encoding"];
-								/** @type {Readable} */
-								let stream = res;
-								if (contentEncoding === "gzip") {
-									stream = stream.pipe(createGunzip());
-								} else if (contentEncoding === "br") {
-									stream = stream.pipe(createBrotliDecompress());
-								} else if (contentEncoding === "deflate") {
-									stream = stream.pipe(createInflate());
+								logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+								return callback(null, { ...result, fresh: true });
+							}
+							if (
+								location &&
+								res.statusCode &&
+								res.statusCode >= 301 &&
+								res.statusCode <= 308
+							) {
+								const result = {
+									location: new URL(location, url).href
+								};
+								if (
+									!cachedResult ||
+									!("location" in cachedResult) ||
+									cachedResult.location !== result.location ||
+									cachedResult.validUntil < validUntil ||
+									cachedResult.storeLock !== storeLock ||
+									cachedResult.storeCache !== storeCache ||
+									cachedResult.etag !== etag
+								) {
+									return finishWith(result);
 								}
-
-								stream.on("data", chunk => {
-									bufferArr.push(chunk);
+								logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+								return callback(null, {
+									...result,
+									fresh: true,
+									storeLock,
+									storeCache,
+									validUntil,
+									etag
 								});
+							}
+							const contentType = res.headers["content-type"] || "";
+							/** @type {Buffer[]} */
+							const bufferArr = [];
 
-								stream.on("end", () => {
-									if (!res.complete) {
-										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
-										return callback(new Error(`${url} request was terminated`));
-									}
+							const contentEncoding = res.headers["content-encoding"];
+							/** @type {Readable} */
+							let stream = res;
+							if (contentEncoding === "gzip") {
+								stream = stream.pipe(createGunzip());
+							} else if (contentEncoding === "br") {
+								stream = stream.pipe(createBrotliDecompress());
+							} else if (contentEncoding === "deflate") {
+								stream = stream.pipe(createInflate());
+							}
 
-									const content = Buffer.concat(bufferArr);
+							stream.on("data", chunk => {
+								bufferArr.push(chunk);
+							});
 
-									if (res.statusCode !== 200) {
-										logger.log(`GET ${url} [${res.statusCode}]`);
-										return callback(
-											new Error(
-												`${url} request status code = ${
-													res.statusCode
-												}\n${content.toString("utf-8")}`
-											)
-										);
-									}
+							stream.on("end", () => {
+								if (!res.complete) {
+									logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
+									return callback(new Error(`${url} request was terminated`));
+								}
 
-									const integrity = computeIntegrity(content);
-									const entry = { resolved: url, integrity, contentType };
+								const content = Buffer.concat(bufferArr);
 
-									finishWith({
-										entry,
-										content
-									});
+								if (res.statusCode !== 200) {
+									logger.log(`GET ${url} [${res.statusCode}]`);
+									return callback(
+										new Error(
+											`${url} request status code = ${
+												res.statusCode
+											}\n${content.toString("utf-8")}`
+										)
+									);
+								}
+
+								const integrity = computeIntegrity(content);
+								const entry = { resolved: url, integrity, contentType };
+
+								finishWith({
+									entry,
+									content
 								});
-							}
-						).on("error", err => {
+							});
+						}).on("error", err => {
 							logger.log(`GET ${url} (error)`);
 							err.message += `\nwhile fetching ${url}`;
 							callback(err);
@@ -847,7 +854,7 @@ class HttpUriPlugin {
 					const fetchContent = cachedWithKey(
 						/**
 						 * @param {string} url URL
-						 * @param {(err: Error | null, result?: { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }) => void} callback callback
+						 * @param {(err: Error | null, result?: FetchResult) => void} callback callback
 						 * @returns {void}
 						 */
 						(url, callback) => {
@@ -1154,19 +1161,16 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					};
 					normalModuleFactory.hooks.resolveForScheme
 						.for(scheme)
-						.tapAsync(
-							"HttpUriPlugin",
-							(resourceData, resolveData, callback) => {
-								respondWithUrlModule(
-									new URL(resourceData.resource),
-									resourceData,
-									callback
-								);
-							}
-						);
+						.tapAsync(PLUGIN_NAME, (resourceData, resolveData, callback) => {
+							respondWithUrlModule(
+								new URL(resourceData.resource),
+								resourceData,
+								callback
+							);
+						});
 					normalModuleFactory.hooks.resolveInScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
+						.tapAsync(PLUGIN_NAME, (resourceData, data, callback) => {
 							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
 							if (
 								data.dependencyType !== "url" &&
@@ -1183,7 +1187,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					const hooks = NormalModule.getCompilationHooks(compilation);
 					hooks.readResourceForScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) =>
+						.tapAsync(PLUGIN_NAME, (resource, module, callback) =>
 							getInfo(resource, (err, _result) => {
 								if (err) return callback(err);
 								const result = /** @type {Info} */ (_result);
@@ -1192,33 +1196,27 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								callback(null, result.content);
 							})
 						);
-					hooks.needBuild.tapAsync(
-						"HttpUriPlugin",
-						(module, context, callback) => {
-							if (
-								module.resource &&
-								module.resource.startsWith(`${scheme}://`)
-							) {
-								getInfo(module.resource, (err, _result) => {
-									if (err) return callback(err);
-									const result = /** @type {Info} */ (_result);
-									if (
-										result.entry.integrity !==
-										/** @type {BuildInfo} */
-										(module.buildInfo).resourceIntegrity
-									) {
-										return callback(null, true);
-									}
-									callback();
-								});
-							} else {
-								return callback();
-							}
+					hooks.needBuild.tapAsync(PLUGIN_NAME, (module, context, callback) => {
+						if (module.resource && module.resource.startsWith(`${scheme}://`)) {
+							getInfo(module.resource, (err, _result) => {
+								if (err) return callback(err);
+								const result = /** @type {Info} */ (_result);
+								if (
+									result.entry.integrity !==
+									/** @type {BuildInfo} */
+									(module.buildInfo).resourceIntegrity
+								) {
+									return callback(null, true);
+								}
+								callback();
+							});
+						} else {
+							return callback();
 						}
-					);
+					});
 				}
 				compilation.hooks.finishModules.tapAsync(
-					"HttpUriPlugin",
+					PLUGIN_NAME,
 					(modules, callback) => {
 						if (!lockfileUpdates) return callback();
 						const ext = extname(lockfileLocation);

package/lib/serialization/AggregateErrorSerializer.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {Error & { cause: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+
+class AggregateErrorSerializer {
+	/**
+	 * @param {AggregateError} obj error
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.errors);
+		context.write(obj.message);
+		context.write(obj.stack);
+		context.write(obj.cause);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {AggregateError} error
+	 */
+	deserialize(context) {
+		const errors = context.read();
+		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		const err = new AggregateError(errors);
+
+		err.message = context.read();
+		err.stack = context.read();
+		err.cause = context.read();
+
+		return err;
+	}
+}
+
+module.exports = AggregateErrorSerializer;

package/lib/serialization/ErrorObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+
 class ErrorObjectSerializer {
 	/**
 	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
@@ -22,7 +24,10 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
+		context.write(
+			/** @type {ErrorWithCause} */
+			(obj).cause
+		);
 	}
 
 	/**
@@ -34,7 +39,7 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
-		/** @type {Error & { cause: "unknown" }} */
+		/** @type {ErrorWithCause} */
 		(err).cause = context.read();
 
 		return err;

package/lib/serialization/ObjectMiddleware.js

@@ -6,6 +6,7 @@
 
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
+const AggregateErrorSerializer = require("./AggregateErrorSerializer");
 const ArraySerializer = require("./ArraySerializer");
 const DateObjectSerializer = require("./DateObjectSerializer");
 const ErrorObjectSerializer = require("./ErrorObjectSerializer");
@@ -140,6 +141,7 @@ const loadedRequests = new Set();
 const NOT_SERIALIZABLE = {};
 
 const jsTypes = new Map();
+
 jsTypes.set(Object, new PlainObjectSerializer());
 jsTypes.set(Array, new ArraySerializer());
 jsTypes.set(null, new NullPrototypeObjectSerializer());
@@ -154,6 +156,17 @@ jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
 jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
 jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 
+// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+if (typeof AggregateError !== "undefined") {
+	jsTypes.set(
+		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		AggregateError,
+		new AggregateErrorSerializer()
+	);
+}
+
 // If in a sandboxed environment (e.g. jest), this escapes the sandbox and registers
 // real Object and Array types to. These types may occur in the wild too, e.g. when
 // using Structured Clone in postMessage.

package/lib/sharing/ProvideSharedPlugin.js

@@ -36,6 +36,8 @@ const validate = createSchemaValidation(
 
 /** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
 
+const PLUGIN_NAME = "ProvideSharedPlugin";
+
 class ProvideSharedPlugin {
 	/**
 	 * @param {ProvideSharedPluginOptions} options options
@@ -83,7 +85,7 @@ class ProvideSharedPlugin {
 		const compilationData = new WeakMap();
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/** @type {ResolvedProvideMap} */
 				const resolvedProvideMap = new Map();
@@ -156,7 +158,7 @@ class ProvideSharedPlugin {
 					});
 				};
 				normalModuleFactory.hooks.module.tap(
-					"ProvideSharedPlugin",
+					PLUGIN_NAME,
 					(module, { resource, resourceResolveData }, resolveData) => {
 						if (resolvedProvideMap.has(/** @type {string} */ (resource))) {
 							return module;
@@ -194,7 +196,7 @@ class ProvideSharedPlugin {
 				);
 			}
 		);
-		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
+		compiler.hooks.finishMake.tapPromise(PLUGIN_NAME, compilation => {
 			const resolvedProvideMap = compilationData.get(compilation);
 			if (!resolvedProvideMap) return Promise.resolve();
 			return Promise.all(
@@ -225,7 +227,7 @@ class ProvideSharedPlugin {
 		});
 
 		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ProvideForSharedDependency,