webpack 5.97.1 → 5.104.1

package/lib/cache/PackFileCacheStrategy.js

@@ -13,28 +13,31 @@ const LazySet = require("../util/LazySet");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 const {
-	createFileSerializer,
-	NOT_SERIALIZABLE
+	NOT_SERIALIZABLE,
+	createFileSerializer
 } = require("../util/serialization");
 
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
+/** @typedef {import("../Cache").Data} Data */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
+/** @typedef {import("../FileSystemInfo").ResolveResults} ResolveResults */
 /** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("../logging/Logger").Logger} Logger */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-/** @typedef {Map<string, string | false>} ResolveResults */
 /** @typedef {Set<string>} Items */
 /** @typedef {Set<string>} BuildDependencies */
 /** @typedef {Map<string, PackItemInfo>} ItemInfo */
 
 class PackContainer {
 	/**
-	 * @param {object} data stored data
+	 * @param {Pack} data stored data
 	 * @param {string} version version identifier
 	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
 	 * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured
@@ -49,11 +52,17 @@ class PackContainer {
 		resolveResults,
 		resolveBuildDependenciesSnapshot
 	) {
+		/** @type {Pack | (() => Pack)} */
 		this.data = data;
+		/** @type {string} */
 		this.version = version;
+		/** @type {Snapshot} */
 		this.buildSnapshot = buildSnapshot;
+		/** @type {BuildDependencies} */
 		this.buildDependencies = buildDependencies;
+		/** @type {ResolveResults} */
 		this.resolveResults = resolveResults;
+		/** @type {Snapshot} */
 		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
@@ -99,13 +108,18 @@ class PackItemInfo {
 	/**
 	 * @param {string} identifier identifier of item
 	 * @param {string | null | undefined} etag etag of item
-	 * @param {any} value fresh value of item
+	 * @param {Data} value fresh value of item
 	 */
 	constructor(identifier, etag, value) {
+		/** @type {string} */
 		this.identifier = identifier;
+		/** @type {string | null | undefined} */
 		this.etag = etag;
+		/** @type {number} */
 		this.location = -1;
+		/** @type {number} */
 		this.lastAccess = Date.now();
+		/** @type {Data} */
 		this.freshValue = value;
 	}
 }
@@ -154,7 +168,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @returns {any} cached content
+	 * @returns {Data} cached content
 	 */
 	get(identifier, etag) {
 		const info = this.itemInfo.get(identifier);
@@ -177,7 +191,7 @@ class Pack {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {string | null} etag etag of the resource
-	 * @param {any} data cached content
+	 * @param {Data} data cached content
 	 * @returns {void}
 	 */
 	set(identifier, etag, data) {
@@ -268,7 +282,7 @@ class Pack {
 	}
 
 	_persistFreshContent() {
-		/** @typedef {{ items: Items, map: Map<string, any>, loc: number }} PackItem */
+		/** @typedef {{ items: Items, map: Content, loc: number }} PackItem */
 		const itemsCount = this.freshContent.size;
 		if (itemsCount > 0) {
 			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
@@ -290,8 +304,9 @@ class Pack {
 				return pack;
 			};
 			let pack = createNextPack();
-			if (this.requestsTimeout !== undefined)
+			if (this.requestsTimeout !== undefined) {
 				clearTimeout(this.requestsTimeout);
+			}
 			for (const identifier of this.requests) {
 				if (identifier === undefined) {
 					if (ignoreNextTimeTick) {
@@ -327,7 +342,7 @@ class Pack {
 				`${itemsCount} fresh items in cache put into pack ${
 					packs.length > 1
 						? packs
-								.map(pack => `${pack.loc} (${pack.items.size} items)`)
+								.map((pack) => `${pack.loc} (${pack.items.size} items)`)
 								.join(", ")
 						: packs[0].loc
 				}`
@@ -377,9 +392,11 @@ class Pack {
 			smallUnusedContentSize > MIN_CONTENT_SIZE
 		) {
 			mergedIndices = smallUnusedContents;
-		} else return;
+		} else {
+			return;
+		}
 
-		/** @type {PackContent[] } */
+		/** @type {PackContent[]} */
 		const mergedContent = [];
 
 		// 3. Remove old content entries
@@ -393,7 +410,7 @@ class Pack {
 		const mergedItems = new Set();
 		/** @type {Items} */
 		const mergedUsedItems = new Set();
-		/** @type {(function(Map<string, any>): Promise<void>)[]} */
+		/** @type {((map: Content) => Promise<void>)[]} */
 		const addToMergedMap = [];
 		for (const content of mergedContent) {
 			for (const identifier of content.items) {
@@ -402,7 +419,7 @@ class Pack {
 			for (const identifier of content.used) {
 				mergedUsedItems.add(identifier);
 			}
-			addToMergedMap.push(async map => {
+			addToMergedMap.push(async (map) => {
 				// unpack existing content
 				// after that values are accessible in .content
 				await content.unpack(
@@ -428,7 +445,7 @@ class Pack {
 				memoize(async () => {
 					/** @type {Content} */
 					const map = new Map();
-					await Promise.all(addToMergedMap.map(fn => fn(map)));
+					await Promise.all(addToMergedMap.map((fn) => fn(map)));
 					return new PackContentItems(map);
 				})
 			);
@@ -472,6 +489,7 @@ class Pack {
 							await content.unpack(
 								"it should be splitted into used and unused items"
 							);
+							/** @type {Content} */
 							const map = new Map();
 							for (const identifier of usedItems) {
 								map.set(
@@ -597,7 +615,10 @@ class Pack {
 			const content = this.content[i];
 			if (content !== undefined) {
 				write(content.items);
-				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
+				content.writeLazy((lazy) =>
+					/** @type {NonNullable<ObjectSerializerContext["writeSeparate"]>} */
+					(writeSeparate)(lazy, { name: `${i}` })
+				);
 			} else {
 				write(undefined); // undefined marks an empty content slot
 			}
@@ -618,7 +639,7 @@ class Pack {
 				item = read();
 			}
 			this.itemInfo.clear();
-			const infoItems = items.map(identifier => {
+			const infoItems = items.map((identifier) => {
 				const info = new PackItemInfo(identifier, undefined, undefined);
 				this.itemInfo.set(identifier, info);
 				return info;
@@ -659,7 +680,7 @@ class Pack {
 
 makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
-/** @typedef {Map<string, any>} Content */
+/** @typedef {Map<string, Data>} Content */
 
 class PackContentItems {
 	/**
@@ -670,7 +691,7 @@ class PackContentItems {
 	}
 
 	/**
-	 * @param {ObjectSerializerContext & { snapshot: TODO, rollback: TODO, logger: Logger, profile: boolean | undefined  }} context context
+	 * @param {ObjectSerializerContext & { logger: Logger, profile: boolean | undefined  }} context context
 	 */
 	serialize({ write, snapshot, rollback, logger, profile }) {
 		if (profile) {
@@ -684,15 +705,17 @@ class PackContentItems {
 					const durationHr = process.hrtime(start);
 					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
 					if (duration > 1) {
-						if (duration > 500)
+						if (duration > 500) {
 							logger.error(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 50)
+						} else if (duration > 50) {
 							logger.warn(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 10)
+						} else if (duration > 10) {
 							logger.info(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 5)
+						} else if (duration > 5) {
 							logger.log(`Serialization of '${key}': ${duration} ms`);
-						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+						} else {
+							logger.debug(`Serialization of '${key}': ${duration} ms`);
+						}
 					}
 				} catch (err) {
 					rollback(s);
@@ -759,15 +782,17 @@ class PackContentItems {
 				const durationHr = process.hrtime(start);
 				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
 				if (duration > 1) {
-					if (duration > 100)
+					if (duration > 100) {
 						logger.error(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 20)
+					} else if (duration > 20) {
 						logger.warn(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 5)
+					} else if (duration > 5) {
 						logger.info(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 2)
+					} else if (duration > 2) {
 						logger.log(`Deserialization of '${key}': ${duration} ms`);
-					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+					} else {
+						logger.debug(`Deserialization of '${key}': ${duration} ms`);
+					}
 				}
 				map.set(key, value);
 				key = read();
@@ -791,7 +816,7 @@ makeSerializable(
 	"PackContentItems"
 );
 
-/** @typedef {(function(): Promise<PackContentItems> | PackContentItems)} LazyFn */
+/** @typedef {(() => Promise<PackContentItems> | PackContentItems) & Partial<{ options: { size?: number }}>} LazyFunction */
 
 class PackContent {
 	/*
@@ -816,13 +841,13 @@ class PackContent {
 	/**
 	 * @param {Items} items keys
 	 * @param {Items} usedItems used keys
-	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
+	 * @param {PackContentItems | (() => Promise<PackContentItems>)} dataOrFn sync or async content
 	 * @param {Logger=} logger logger for logging
 	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
 		this.items = items;
-		/** @type {LazyFn | undefined} */
+		/** @type {LazyFunction | undefined} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
 		/** @type {Content | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
@@ -860,19 +885,16 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = /** @type {LazyFn} */ (this.lazy)();
+		const value = /** @type {LazyFunction} */ (this.lazy)();
 		if ("then" in value) {
-			return value.then(data => {
+			return value.then((data) => {
 				const map = data.map;
 				if (timeMessage) {
 					logger.timeEnd(timeMessage);
 				}
 				// Move to state C
 				this.content = map;
-				this.lazy = SerializerMiddleware.unMemoizeLazy(
-					/** @type {LazyFn} */
-					(this.lazy)
-				);
+				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 				return map.get(identifier);
 			});
 		}
@@ -883,10 +905,7 @@ class PackContent {
 		}
 		// Move to state C
 		this.content = map;
-		this.lazy = SerializerMiddleware.unMemoizeLazy(
-			/** @type {LazyFn} */
-			(this.lazy)
-		);
+		this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 		return map.get(identifier);
 	}
 
@@ -916,9 +935,11 @@ class PackContent {
 				);
 				logger.time(timeMessage);
 			}
-			const value = this.lazy();
+			const value =
+				/** @type {PackContentItems | Promise<PackContentItems>} */
+				(this.lazy());
 			if ("then" in value) {
-				return value.then(data => {
+				return value.then((data) => {
 					if (timeMessage) {
 						logger.timeEnd(timeMessage);
 					}
@@ -937,7 +958,9 @@ class PackContent {
 	 */
 	getSize() {
 		if (!this.lazy) return -1;
-		const options = /** @type {any} */ (this.lazy).options;
+		const options =
+			/** @type {{ options: { size?: number } }} */
+			(this.lazy).options;
 		if (!options) return -1;
 		const size = options.size;
 		if (typeof size !== "number") return -1;
@@ -954,8 +977,7 @@ class PackContent {
 	}
 
 	/**
-	 * @template T
-	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
+	 * @param {(lazy: LazyFunction) => (() => PackContentItems | Promise<PackContentItems>)} write write function
 	 * @returns {void}
 	 */
 	writeLazy(write) {
@@ -1007,12 +1029,12 @@ class PackContent {
 			);
 			logger.time(timeMessage);
 		}
-		const value = /** @type {LazyFn} */ (this.lazy)();
+		const value = /** @type {LazyFunction} */ (this.lazy)();
 		this.outdated = false;
 		if ("then" in value) {
 			// Move to state B1
 			this.lazy = write(() =>
-				value.then(data => {
+				value.then((data) => {
 					if (timeMessage) {
 						logger.timeEnd(timeMessage);
 					}
@@ -1024,10 +1046,7 @@ class PackContent {
 					}
 					// Move to state C1 (or maybe C2)
 					this.content = map;
-					this.lazy = SerializerMiddleware.unMemoizeLazy(
-						/** @type {LazyFn} */
-						(this.lazy)
-					);
+					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 
 					return new PackContentItems(map);
 				})
@@ -1053,7 +1072,7 @@ class PackContent {
  * @param {Buffer} buf buffer
  * @returns {Buffer} buffer that can be collected
  */
-const allowCollectingMemory = buf => {
+const allowCollectingMemory = (buf) => {
 	const wasted = buf.buffer.byteLength - buf.byteLength;
 	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
 		return Buffer.from(buf);
@@ -1091,9 +1110,11 @@ class PackFileCacheStrategy {
 		compression,
 		readonly
 	}) {
+		/** @type {import("../serialization/Serializer")<PackContainer, null, EXPECTED_OBJECT>} */
 		this.fileSerializer = createFileSerializer(
 			fs,
-			compiler.options.output.hashFunction
+			/** @type {string | Hash} */
+			(compiler.options.output.hashFunction)
 		);
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
@@ -1120,7 +1141,7 @@ class PackFileCacheStrategy {
 		this.snapshot = snapshot;
 		/** @type {BuildDependencies} */
 		this.buildDependencies = new Set();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
 		/** @type {Snapshot | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
@@ -1169,7 +1190,7 @@ class PackFileCacheStrategy {
 					? allowCollectingMemory
 					: undefined
 			})
-			.catch(err => {
+			.catch((err) => {
 				if (err.code !== "ENOENT") {
 					logger.warn(
 						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
@@ -1182,7 +1203,7 @@ class PackFileCacheStrategy {
 				}
 				return undefined;
 			})
-			.then(packContainer => {
+			.then((packContainer) => {
 				logger.timeEnd("restore cache container");
 				if (!packContainer) return;
 				if (!(packContainer instanceof PackContainer)) {
@@ -1200,7 +1221,7 @@ class PackFileCacheStrategy {
 				}
 				logger.time("check build dependencies");
 				return Promise.all([
-					new Promise((resolve, reject) => {
+					new Promise((resolve, _reject) => {
 						this.fileSystemInfo.checkSnapshotValid(
 							packContainer.buildSnapshot,
 							(err, valid) => {
@@ -1222,7 +1243,7 @@ class PackFileCacheStrategy {
 							}
 						);
 					}),
-					new Promise((resolve, reject) => {
+					new Promise((resolve, _reject) => {
 						this.fileSystemInfo.checkSnapshotValid(
 							packContainer.resolveBuildDependenciesSnapshot,
 							(err, valid) => {
@@ -1268,7 +1289,7 @@ class PackFileCacheStrategy {
 						);
 					})
 				])
-					.catch(err => {
+					.catch((err) => {
 						logger.timeEnd("check build dependencies");
 						throw err;
 					})
@@ -1276,20 +1297,23 @@ class PackFileCacheStrategy {
 						logger.timeEnd("check build dependencies");
 						if (buildSnapshotValid && resolveValid) {
 							logger.time("restore cache content metadata");
-							const d = packContainer.data();
+							const d =
+								/** @type {() => Pack} */
+								(packContainer.data)();
 							logger.timeEnd("restore cache content metadata");
 							return d;
 						}
 						return undefined;
 					});
 			})
-			.then(pack => {
+			.then((pack) => {
 				if (pack) {
 					pack.maxAge = this.maxAge;
 					this.buildSnapshot = buildSnapshot;
 					if (buildDependencies) this.buildDependencies = buildDependencies;
-					if (newBuildDependencies)
+					if (newBuildDependencies) {
 						this.newBuildDependencies.addAll(newBuildDependencies);
+					}
 					this.resolveResults = resolveResults;
 					this.resolveBuildDependenciesSnapshot =
 						resolveBuildDependenciesSnapshot;
@@ -1297,7 +1321,7 @@ class PackFileCacheStrategy {
 				}
 				return new Pack(logger, this.maxAge);
 			})
-			.catch(err => {
+			.catch((err) => {
 				this.logger.warn(
 					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
 				);
@@ -1309,13 +1333,13 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @param {any} data cached content
+	 * @param {Data} data cached content
 	 * @returns {Promise<void>} promise
 	 */
 	store(identifier, etag, data) {
 		if (this.readonly) return Promise.resolve();
 
-		return this._getPack().then(pack => {
+		return this._getPack().then((pack) => {
 			pack.set(identifier, etag === null ? null : etag.toString(), data);
 		});
 	}
@@ -1323,14 +1347,14 @@ class PackFileCacheStrategy {
 	/**
 	 * @param {string} identifier unique name for the resource
 	 * @param {Etag | null} etag etag of the resource
-	 * @returns {Promise<any>} promise to the cached content
+	 * @returns {Promise<Data>} promise to the cached content
 	 */
 	restore(identifier, etag) {
 		return this._getPack()
-			.then(pack =>
+			.then((pack) =>
 				pack.get(identifier, etag === null ? null : etag.toString())
 			)
-			.catch(err => {
+			.catch((err) => {
 				if (err && err.code !== "ENOENT") {
 					this.logger.warn(
 						`Restoring failed for ${identifier} from pack: ${err}`
@@ -1341,7 +1365,7 @@ class PackFileCacheStrategy {
 	}
 
 	/**
-	 * @param {LazySet<string> | Iterable<string>} dependencies dependencies to store
+	 * @param {FileSystemDependencies | Iterable<string>} dependencies dependencies to store
 	 */
 	storeBuildDependencies(dependencies) {
 		if (this.readonly) return;
@@ -1353,7 +1377,7 @@ class PackFileCacheStrategy {
 		if (packPromise === undefined) return Promise.resolve();
 		const reportProgress = ProgressPlugin.getReporter(this.compiler);
 		return (this.storePromise = packPromise
-			.then(pack => {
+			.then((pack) => {
 				pack.stopCapturingRequests();
 				if (!pack.invalid) return;
 				this.packPromise = undefined;
@@ -1368,108 +1392,112 @@ class PackFileCacheStrategy {
 				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
 					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
 					this.logger.debug(
-						`Capturing build dependencies... (${Array.from(
-							newBuildDependencies
-						).join(", ")})`
+						`Capturing build dependencies... (${[...newBuildDependencies].join(", ")})`
 					);
-					promise = new Promise((resolve, reject) => {
-						this.logger.time("resolve build dependencies");
-						this.fileSystemInfo.resolveBuildDependencies(
-							this.context,
-							newBuildDependencies,
-							(err, result) => {
-								this.logger.timeEnd("resolve build dependencies");
-								if (err) return reject(err);
-
-								this.logger.time("snapshot build dependencies");
-								const {
-									files,
-									directories,
-									missing,
-									resolveResults,
-									resolveDependencies
-								} = /** @type {ResolveBuildDependenciesResult} */ (result);
-								if (this.resolveResults) {
-									for (const [key, value] of resolveResults) {
-										this.resolveResults.set(key, value);
-									}
-								} else {
-									this.resolveResults = resolveResults;
-								}
-								if (reportProgress) {
-									reportProgress(
-										0.6,
-										"snapshot build dependencies",
-										"resolving"
-									);
-								}
-								this.fileSystemInfo.createSnapshot(
-									undefined,
-									resolveDependencies.files,
-									resolveDependencies.directories,
-									resolveDependencies.missing,
-									this.snapshot.resolveBuildDependencies,
-									(err, snapshot) => {
-										if (err) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(err);
-										}
-										if (!snapshot) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(
-												new Error("Unable to snapshot resolve dependencies")
-											);
-										}
-										if (this.resolveBuildDependenciesSnapshot) {
-											this.resolveBuildDependenciesSnapshot =
-												this.fileSystemInfo.mergeSnapshots(
-													this.resolveBuildDependenciesSnapshot,
-													snapshot
-												);
-										} else {
-											this.resolveBuildDependenciesSnapshot = snapshot;
-										}
-										if (reportProgress) {
-											reportProgress(
-												0.7,
-												"snapshot build dependencies",
-												"modules"
-											);
+					promise = new Promise(
+						/**
+						 * @param {(value?: undefined) => void} resolve resolve
+						 * @param {(reason?: Error) => void} reject reject
+						 */
+						(resolve, reject) => {
+							this.logger.time("resolve build dependencies");
+							this.fileSystemInfo.resolveBuildDependencies(
+								this.context,
+								newBuildDependencies,
+								(err, result) => {
+									this.logger.timeEnd("resolve build dependencies");
+									if (err) return reject(err);
+
+									this.logger.time("snapshot build dependencies");
+									const {
+										files,
+										directories,
+										missing,
+										resolveResults,
+										resolveDependencies
+									} = /** @type {ResolveBuildDependenciesResult} */ (result);
+									if (this.resolveResults) {
+										for (const [key, value] of resolveResults) {
+											this.resolveResults.set(key, value);
 										}
-										this.fileSystemInfo.createSnapshot(
-											undefined,
-											files,
-											directories,
-											missing,
-											this.snapshot.buildDependencies,
-											(err, snapshot) => {
+									} else {
+										this.resolveResults = resolveResults;
+									}
+									if (reportProgress) {
+										reportProgress(
+											0.6,
+											"snapshot build dependencies",
+											"resolving"
+										);
+									}
+									this.fileSystemInfo.createSnapshot(
+										undefined,
+										resolveDependencies.files,
+										resolveDependencies.directories,
+										resolveDependencies.missing,
+										this.snapshot.resolveBuildDependencies,
+										(err, snapshot) => {
+											if (err) {
 												this.logger.timeEnd("snapshot build dependencies");
-												if (err) return reject(err);
-												if (!snapshot) {
-													return reject(
-														new Error("Unable to snapshot build dependencies")
+												return reject(err);
+											}
+											if (!snapshot) {
+												this.logger.timeEnd("snapshot build dependencies");
+												return reject(
+													new Error("Unable to snapshot resolve dependencies")
+												);
+											}
+											if (this.resolveBuildDependenciesSnapshot) {
+												this.resolveBuildDependenciesSnapshot =
+													this.fileSystemInfo.mergeSnapshots(
+														this.resolveBuildDependenciesSnapshot,
+														snapshot
 													);
-												}
-												this.logger.debug("Captured build dependencies");
-
-												if (this.buildSnapshot) {
-													this.buildSnapshot =
-														this.fileSystemInfo.mergeSnapshots(
-															this.buildSnapshot,
-															snapshot
+											} else {
+												this.resolveBuildDependenciesSnapshot = snapshot;
+											}
+											if (reportProgress) {
+												reportProgress(
+													0.7,
+													"snapshot build dependencies",
+													"modules"
+												);
+											}
+											this.fileSystemInfo.createSnapshot(
+												undefined,
+												files,
+												directories,
+												missing,
+												this.snapshot.buildDependencies,
+												(err, snapshot) => {
+													this.logger.timeEnd("snapshot build dependencies");
+													if (err) return reject(err);
+													if (!snapshot) {
+														return reject(
+															new Error("Unable to snapshot build dependencies")
 														);
-												} else {
-													this.buildSnapshot = snapshot;
+													}
+													this.logger.debug("Captured build dependencies");
+
+													if (this.buildSnapshot) {
+														this.buildSnapshot =
+															this.fileSystemInfo.mergeSnapshots(
+																this.buildSnapshot,
+																snapshot
+															);
+													} else {
+														this.buildSnapshot = snapshot;
+													}
+
+													resolve();
 												}
-
-												resolve();
-											}
-										);
-									}
-								);
-							}
-						);
-					});
+											);
+										}
+									);
+								}
+							);
+						}
+					);
 				} else {
 					promise = Promise.resolve();
 				}
@@ -1512,14 +1540,14 @@ class PackFileCacheStrategy {
 								Math.round(stats.size / 1024 / 1024)
 							);
 						})
-						.catch(err => {
+						.catch((err) => {
 							this.logger.timeEnd("store pack");
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});
 				});
 			})
-			.catch(err => {
+			.catch((err) => {
 				this.logger.warn(`Caching failed for pack: ${err}`);
 				this.logger.debug(err.stack);
 			}));