webpack 5.97.1 → 5.104.1

package/lib/serialization/FileMiddleware.js

@@ -7,12 +7,15 @@
 const { constants } = require("buffer");
 const { pipeline } = require("stream");
 const {
+	constants: zConstants,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliCompress,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliDecompress,
-	createGzip,
 	createGunzip,
-	constants: zConstants
+	createGzip
 } = require("zlib");
+const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
@@ -52,13 +55,13 @@ const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
 const hashForName = (buffers, hashFunction) => {
 	const hash = createHash(hashFunction);
 	for (const buf of buffers) hash.update(buf);
-	return /** @type {string} */ (hash.digest("hex"));
+	return hash.digest("hex");
 };
 
 const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 
-/** @type {function(Buffer, number, number): void} */
+/** @type {(buffer: Buffer, value: number, offset: number) => void} */
 const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
 	? (buf, value, offset) => {
 			buf.writeBigUInt64LE(BigInt(value), offset);
@@ -70,7 +73,7 @@ const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
 			buf.writeUInt32LE(high, offset + 4);
 		};
 
-/** @type {function(Buffer, number): void} */
+/** @type {(buffer: Buffer, offset: number) => void} */
 const readUInt64LE = Buffer.prototype.readBigUInt64LE
 	? (buf, offset) => Number(buf.readBigUInt64LE(offset))
 	: (buf, offset) => {
@@ -79,18 +82,25 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
 			return high * 0x100000000 + low;
 		};
 
+/** @typedef {Promise<void | void[]>} BackgroundJob */
+
 /**
  * @typedef {object} SerializeResult
  * @property {string | false} name
  * @property {number} size
- * @property {Promise<any>=} backgroundJob
+ * @property {BackgroundJob=} backgroundJob
+ */
+
+/** @typedef {{ name: string, size: number }} LazyOptions */
+/**
+ * @typedef {import("./SerializerMiddleware").LazyFunction<BufferSerializableType[], Buffer, FileMiddleware, LazyOptions>} LazyFunction
  */
 
 /**
  * @param {FileMiddleware} middleware this
- * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
+ * @param {(BufferSerializableType | LazyFunction)[]} data data to be serialized
  * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[], number): Promise<void>} writeFile writes a file
+ * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
  * @param {string | Hash} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
@@ -99,18 +109,19 @@ const serialize = async (
 	data,
 	name,
 	writeFile,
-	hashFunction = "md4"
+	hashFunction = DEFAULTS.HASH_FUNCTION
 ) => {
-	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
+	/** @type {(Buffer[] | Buffer | Promise<SerializeResult>)[]} */
 	const processedData = [];
-	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
+	/** @type {WeakMap<SerializeResult, LazyFunction>} */
 	const resultToLazy = new WeakMap();
 	/** @type {Buffer[] | undefined} */
 	let lastBuffers;
 	for (const item of await data) {
 		if (typeof item === "function") {
-			if (!SerializerMiddleware.isLazy(item))
+			if (!SerializerMiddleware.isLazy(item)) {
 				throw new Error("Unexpected function");
+			}
 			if (!SerializerMiddleware.isLazy(item, middleware)) {
 				throw new Error(
 					"Unexpected lazy value with non-this target (can't pass through lazy values)"
@@ -133,12 +144,14 @@ const serialize = async (
 					processedData.push(
 						serialize(
 							middleware,
-							content,
+							/** @type {BufferSerializableType[]} */
+							(content),
 							(options && options.name) || true,
 							writeFile,
 							hashFunction
-						).then(result => {
-							/** @type {any} */ (item).options.size = result.size;
+						).then((result) => {
+							/** @type {LazyOptions} */
+							(item.options).size = result.size;
 							resultToLazy.set(result, item);
 							return result;
 						})
@@ -160,24 +173,24 @@ const serialize = async (
 			throw new Error("Unexpected falsy value in items array");
 		}
 	}
-	/** @type {Promise<any>[]} */
+	/** @type {BackgroundJob[]} */
 	const backgroundJobs = [];
-	const resolvedData = (
-		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */
-			(processedData)
-		)
-	).map(item => {
+	const resolvedData = (await Promise.all(processedData)).map((item) => {
 		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
 
-		backgroundJobs.push(item.backgroundJob);
+		backgroundJobs.push(
+			/** @type {BackgroundJob} */
+			(item.backgroundJob)
+		);
 		// create pointer buffer from size and name
 		const name = /** @type {string} */ (item.name);
 		const nameBuffer = Buffer.from(name);
 		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
 		writeUInt64LE(buf, item.size, 0);
 		nameBuffer.copy(buf, 8, 0);
-		const lazy = resultToLazy.get(item);
+		const lazy =
+			/** @type {LazyFunction} */
+			(resultToLazy.get(item));
 		SerializerMiddleware.setLazySerializedValue(lazy, buf);
 		return buf;
 	});
@@ -225,14 +238,14 @@ const serialize = async (
 		backgroundJob:
 			backgroundJobs.length === 1
 				? backgroundJobs[0]
-				: Promise.all(backgroundJobs)
+				: /** @type {BackgroundJob} */ (Promise.all(backgroundJobs))
 	};
 };
 
 /**
  * @param {FileMiddleware} middleware this
  * @param {string | false} name filename
- * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
+ * @param {(name: string | false) => Promise<Buffer[]>} readFile read content of a file
  * @returns {Promise<BufferSerializableType[]>} deserialized data
  */
 const deserialize = async (middleware, name, readFile) => {
@@ -252,13 +265,14 @@ const deserialize = async (middleware, name, readFile) => {
 	/**
 	 * @param {number} n number of bytes to ensure
 	 */
-	const ensureData = n => {
+	const ensureData = (n) => {
 		if (contentPosition === contentItemLength) {
 			nextContent();
 		}
 		while (contentItemLength - contentPosition < n) {
 			const remaining = contentItem.slice(contentPosition);
 			let lengthFromNext = n - remaining.length;
+			/** @type {Buffer[]} */
 			const buffers = [remaining];
 			for (let i = contentsIndex + 1; i < contents.length; i++) {
 				const l = contents[i].length;
@@ -301,7 +315,7 @@ const deserialize = async (middleware, name, readFile) => {
 	 * @param {number} l length
 	 * @returns {Buffer} buffer
 	 */
-	const readSlice = l => {
+	const readSlice = (l) => {
 		ensureData(l);
 		if (contentPosition === 0 && contentItemLength === l) {
 			const result = contentItem;
@@ -334,6 +348,7 @@ const deserialize = async (middleware, name, readFile) => {
 			lastLengthPositive = valuePositive;
 		}
 	}
+	/** @type {BufferSerializableType[]} */
 	const result = [];
 	for (let length of lengths) {
 		if (length < 0) {
@@ -341,17 +356,17 @@ const deserialize = async (middleware, name, readFile) => {
 			const size = Number(readUInt64LE(slice, 0));
 			const nameBuffer = slice.slice(8);
 			const name = nameBuffer.toString();
-			result.push(
-				SerializerMiddleware.createLazy(
-					memoize(() => deserialize(middleware, name, readFile)),
-					middleware,
-					{
-						name,
-						size
-					},
-					slice
-				)
-			);
+			const lazy =
+				/** @type {LazyFunction} */
+				(
+					SerializerMiddleware.createLazy(
+						memoize(() => deserialize(middleware, name, readFile)),
+						middleware,
+						{ name, size },
+						slice
+					)
+				);
+			result.push(lazy);
 		} else {
 			if (contentPosition === contentItemLength) {
 				nextContent();
@@ -408,19 +423,19 @@ const deserialize = async (middleware, name, readFile) => {
 	return result;
 };
 
-/** @typedef {{ filename: string, extension?: string }} FileMiddlewareContext */
+/** @typedef {BufferSerializableType[]} DeserializedType */
+/** @typedef {true} SerializedType */
+/** @typedef {{ filename: string, extension?: string }} Context */
 
 /**
- * @typedef {BufferSerializableType[]} DeserializedType
- * @typedef {true} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class FileMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(fs, hashFunction = "md4") {
+	constructor(fs, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		super();
 		this.fs = fs;
 		this._hashFunction = hashFunction;
@@ -428,13 +443,13 @@ class FileMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {DeserializedType} data data
-	 * @param {object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Context} context context object
+	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
 		const { filename, extension = "" } = context;
 		return new Promise((resolve, reject) => {
-			mkdirp(this.fs, dirname(this.fs, filename), err => {
+			mkdirp(this.fs, dirname(this.fs, filename), (err) => {
 				if (err) return reject(err);
 
 				// It's important that we don't touch existing files during serialization
@@ -479,11 +494,11 @@ class FileMiddleware extends SerializerMiddleware {
 								stream = compression;
 								stream.on("finish", () => resolve());
 							} else {
-								stream.on("error", err => reject(err));
+								stream.on("error", (err) => reject(err));
 								stream.on("finish", () => resolve());
 							}
 							// split into chunks for WRITE_LIMIT_CHUNK size
-							/** @type {TODO[]} */
+							/** @type {Buffer[]} */
 							const chunks = [];
 							for (const b of content) {
 								if (b.length < WRITE_LIMIT_CHUNK) {
@@ -500,7 +515,7 @@ class FileMiddleware extends SerializerMiddleware {
 							/**
 							 * @param {(Error | null)=} err err
 							 */
-							const batchWrite = err => {
+							const batchWrite = (err) => {
 								// will be handled in "on" error handler
 								if (err) return;
 
@@ -539,8 +554,8 @@ class FileMiddleware extends SerializerMiddleware {
 								/**
 								 * @param {(value?: undefined) => void} resolve resolve
 								 */
-								resolve => {
-									this.fs.rename(filename, `${filename}.old`, err => {
+								(resolve) => {
+									this.fs.rename(filename, `${filename}.old`, (_err) => {
 										resolve();
 									});
 								}
@@ -550,7 +565,7 @@ class FileMiddleware extends SerializerMiddleware {
 							await Promise.all(
 								Array.from(
 									allWrittenFiles,
-									file =>
+									(file) =>
 										new Promise(
 											/**
 											 * @param {(value?: undefined) => void} resolve resolve
@@ -558,7 +573,7 @@ class FileMiddleware extends SerializerMiddleware {
 											 * @returns {void}
 											 */
 											(resolve, reject) => {
-												this.fs.rename(`${file}_`, file, err => {
+												this.fs.rename(`${file}_`, file, (err) => {
 													if (err) return reject(err);
 													resolve();
 												});
@@ -573,8 +588,8 @@ class FileMiddleware extends SerializerMiddleware {
 								 * @param {(value?: undefined) => void} resolve resolve
 								 * @returns {void}
 								 */
-								resolve => {
-									this.fs.rename(`${filename}_`, filename, err => {
+								(resolve) => {
+									this.fs.rename(`${filename}_`, filename, (err) => {
 										if (err) return reject(err);
 										resolve();
 									});
@@ -590,16 +605,16 @@ class FileMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @param {SerializedType} data data
-	 * @param {object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {Context} context context object
+	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
 	 */
 	deserialize(data, context) {
 		const { filename, extension = "" } = context;
 		/**
 		 * @param {string | boolean} name name
-		 * @returns {Promise<TODO>} result
+		 * @returns {Promise<Buffer[]>} result
 		 */
-		const readFile = name =>
+		const readFile = (name) =>
 			new Promise((resolve, reject) => {
 				const file = name
 					? join(this.fs, filename, `../${name}${extension}`)
@@ -614,7 +629,7 @@ class FileMiddleware extends SerializerMiddleware {
 					let currentBuffer;
 					/** @type {number | undefined} */
 					let currentBufferUsed;
-					/** @type {any[]} */
+					/** @type {Buffer[]} */
 					const buf = [];
 					/** @type {import("zlib").Zlib & import("stream").Transform | undefined} */
 					let decompression;
@@ -628,7 +643,12 @@ class FileMiddleware extends SerializerMiddleware {
 						});
 					}
 					if (decompression) {
+						/** @typedef {(value: Buffer[] | PromiseLike<Buffer[]>) => void} NewResolve */
+						/** @typedef {(reason?: Error) => void} NewReject */
+
+						/** @type {NewResolve | undefined} */
 						let newResolve;
+						/** @type {NewReject | undefined} */
 						let newReject;
 						resolve(
 							Promise.all([
@@ -636,15 +656,21 @@ class FileMiddleware extends SerializerMiddleware {
 									newResolve = rs;
 									newReject = rj;
 								}),
-								new Promise((resolve, reject) => {
-									decompression.on("data", chunk => buf.push(chunk));
-									decompression.on("end", () => resolve());
-									decompression.on("error", err => reject(err));
-								})
+								new Promise(
+									/**
+									 * @param {(value?: undefined) => void} resolve resolve
+									 * @param {(reason?: Error) => void} reject reject
+									 */
+									(resolve, reject) => {
+										decompression.on("data", (chunk) => buf.push(chunk));
+										decompression.on("end", () => resolve());
+										decompression.on("error", (err) => reject(err));
+									}
+								)
 							]).then(() => buf)
 						);
-						resolve = newResolve;
-						reject = newReject;
+						resolve = /** @type {NewResolve} */ (newResolve);
+						reject = /** @type {NewReject} */ (newReject);
 					}
 					this.fs.open(file, "r", (err, _fd) => {
 						if (err) {
@@ -694,19 +720,23 @@ class FileMiddleware extends SerializerMiddleware {
 									remaining -= bytesRead;
 									if (
 										currentBufferUsed ===
-										/** @type {Buffer} */ (currentBuffer).length
+										/** @type {Buffer} */
+										(currentBuffer).length
 									) {
 										if (decompression) {
 											decompression.write(currentBuffer);
 										} else {
-											buf.push(currentBuffer);
+											buf.push(
+												/** @type {Buffer} */
+												(currentBuffer)
+											);
 										}
 										currentBuffer = undefined;
 										if (remaining === 0) {
 											if (decompression) {
 												decompression.end();
 											}
-											this.fs.close(fd, err => {
+											this.fs.close(fd, (err) => {
 												if (err) {
 													reject(err);
 													return;

package/lib/serialization/NullPrototypeObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {string[]} Keys */
+
 class NullPrototypeObjectSerializer {
 	/**
 	 * @template {object} T
@@ -14,7 +16,7 @@ class NullPrototypeObjectSerializer {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(obj, context) {
-		/** @type {string[]} */
+		/** @type {Keys} */
 		const keys = Object.keys(obj);
 		for (const key of keys) {
 			context.write(key);
@@ -33,9 +35,9 @@ class NullPrototypeObjectSerializer {
 	deserialize(context) {
 		/** @type {T} */
 		const obj = Object.create(null);
-		/** @type {string[]} */
+		/** @type {Keys} */
 		const keys = [];
-		/** @type {string | null} */
+		/** @type {Keys[number] | null} */
 		let key = context.read();
 		while (key !== null) {
 			keys.push(key);