webpack 5.59.0 → 5.94.0

package/lib/cache/AddManagedPathsPlugin.js

@@ -11,10 +11,12 @@ class AddManagedPathsPlugin {
 	/**
 	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
 	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
+	 * @param {Iterable<string | RegExp>} unmanagedPaths list of unmanaged paths
 	 */
-	constructor(managedPaths, immutablePaths) {
+	constructor(managedPaths, immutablePaths, unmanagedPaths) {
 		this.managedPaths = new Set(managedPaths);
 		this.immutablePaths = new Set(immutablePaths);
+		this.unmanagedPaths = new Set(unmanagedPaths);
 	}
 
 	/**
@@ -29,6 +31,9 @@ class AddManagedPathsPlugin {
 		for (const immutablePath of this.immutablePaths) {
 			compiler.immutablePaths.add(immutablePath);
 		}
+		for (const unmanagedPath of this.unmanagedPaths) {
+			compiler.unmanagedPaths.add(unmanagedPath);
+		}
 	}
 }
 

package/lib/cache/IdleFileCachePlugin.js

@@ -9,12 +9,13 @@ const Cache = require("../Cache");
 const ProgressPlugin = require("../ProgressPlugin");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
-const BUILD_DEPENDENCIES_KEY = Symbol();
+const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
 
 class IdleFileCachePlugin {
 	/**
-	 * @param {TODO} strategy cache strategy
+	 * @param {PackFileCacheStrategy} strategy cache strategy
 	 * @param {number} idleTimeout timeout
 	 * @param {number} idleTimeoutForInitialStore initial timeout
 	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
@@ -37,7 +38,7 @@ class IdleFileCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		let strategy = this.strategy;
+		const strategy = this.strategy;
 		const idleTimeout = this.idleTimeout;
 		const idleTimeoutForInitialStore = Math.min(
 			idleTimeout,
@@ -50,7 +51,7 @@ class IdleFileCachePlugin {
 		let timeSpendInStore = 0;
 		let avgTimeSpendInStore = 0;
 
-		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
+		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise<void>>} */
 		const pendingIdleTasks = new Map();
 
 		compiler.cache.hooks.store.tap(
@@ -93,7 +94,9 @@ class IdleFileCachePlugin {
 			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
 			dependencies => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
-					strategy.storeBuildDependencies(dependencies)
+					Promise.resolve().then(() =>
+						strategy.storeBuildDependencies(dependencies)
+					)
 				);
 			}
 		);
@@ -116,7 +119,7 @@ class IdleFileCachePlugin {
 				currentIdlePromise = promise.then(() => strategy.afterAllStored());
 				if (reportProgress) {
 					currentIdlePromise = currentIdlePromise.then(() => {
-						reportProgress(1, `stored`);
+						reportProgress(1, "stored");
 					});
 				}
 				return currentIdlePromise.then(() => {
@@ -171,7 +174,8 @@ class IdleFileCachePlugin {
 				isInitialStore = false;
 			}
 		};
-		let idleTimer = undefined;
+		/** @type {ReturnType<typeof setTimeout> | undefined} */
+		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
 			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
 			() => {
@@ -198,11 +202,18 @@ class IdleFileCachePlugin {
 							}s.`
 						);
 				}
-				idleTimer = setTimeout(() => {
-					idleTimer = undefined;
-					isIdle = true;
-					resolvedPromise.then(processIdleTasks);
-				}, Math.min(isInitialStore ? idleTimeoutForInitialStore : Infinity, isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, idleTimeout));
+				idleTimer = setTimeout(
+					() => {
+						idleTimer = undefined;
+						isIdle = true;
+						resolvedPromise.then(processIdleTasks);
+					},
+					Math.min(
+						isInitialStore ? idleTimeoutForInitialStore : Infinity,
+						isLargeChange ? idleTimeoutAfterLargeChanges : Infinity,
+						idleTimeout
+					)
+				);
 				idleTimer.unref();
 			}
 		);
@@ -219,7 +230,9 @@ class IdleFileCachePlugin {
 		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
-			timeSpendInBuild += stats.endTime - stats.startTime;
+			timeSpendInBuild +=
+				/** @type {number} */ (stats.endTime) -
+				/** @type {number} */ (stats.startTime);
 		});
 	}
 }

package/lib/cache/MemoryCachePlugin.js

@@ -19,7 +19,7 @@ class MemoryCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		/** @type {Map<string, { etag: Etag | null, data: any } | null>} */
 		const cache = new Map();
 		compiler.cache.hooks.store.tap(
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -13,9 +13,14 @@ const Cache = require("../Cache");
 /** @typedef {import("../Module")} Module */
 
 class MemoryWithGcCachePlugin {
+	/**
+	 * @param {object} options Options
+	 * @param {number} options.maxGenerations max generations
+	 */
 	constructor({ maxGenerations }) {
 		this._maxGenerations = maxGenerations;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -23,9 +28,9 @@ class MemoryWithGcCachePlugin {
 	 */
 	apply(compiler) {
 		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		/** @type {Map<string, { etag: Etag | null, data: any } | undefined | null>} */
 		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
+		/** @type {Map<string, { entry: { etag: Etag | null, data: any } | null, until: number }>} */
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;
@@ -34,6 +39,8 @@ class MemoryWithGcCachePlugin {
 			generation++;
 			let clearedEntries = 0;
 			let lastClearedIdentifier;
+			// Avoid coverage problems due indirect changes
+			/* istanbul ignore next */
 			for (const [identifier, entry] of oldCache) {
 				if (entry.until > generation) break;
 
@@ -100,12 +107,11 @@ class MemoryWithGcCachePlugin {
 						oldCache.delete(identifier);
 						cache.set(identifier, cacheEntry);
 						return null;
-					} else {
-						if (cacheEntry.etag !== etag) return null;
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return cacheEntry.data;
 					}
+					if (cacheEntry.etag !== etag) return null;
+					oldCache.delete(identifier);
+					cache.set(identifier, cacheEntry);
+					return cacheEntry.data;
 				}
 				gotHandlers.push((result, callback) => {
 					if (result === undefined) {