fix: avoid cache invalidation using ProgressPlugin and importModule

Author: alexander-akait

lib/ProgressPlugin.js

@@ -15,11 +15,18 @@ const { contextify } = require("./util/identifier");
 /** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+/** @typedef {import("./Compilation").FactorizeModuleOptions} FactorizeModuleOptions */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 
+/**
+ * @template T, K, R
+ * @typedef {import("./util/AsyncQueue")<T, K, R>} AsyncQueue
+ */
+
 /**
  * @typedef {object} CountsData
  * @property {number} modulesCount modules count
@@ -217,7 +224,9 @@ class ProgressPlugin {
 		let lastDependenciesCount = 0;
 		let lastEntriesCount = 0;
 		let modulesCount = 0;
+		let skippedModulesCount = 0;
 		let dependenciesCount = 0;
+		let skippedDependenciesCount = 0;
 		let entriesCount = 1;
 		let doneModules = 0;
 		let doneDependencies = 0;
@@ -298,7 +307,15 @@ class ProgressPlugin {
 			lastUpdate = Date.now();
 		};
 
-		const factorizeAdd = () => {
+		/**
+		 * @template T
+		 * @param {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} factorizeQueue async queue
+		 * @param {T} _item item
+		 */
+		const factorizeAdd = (factorizeQueue, _item) => {
+			if (factorizeQueue.getContext() === "import-module") {
+				skippedDependenciesCount++;
+			}
 			dependenciesCount++;
 			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
 				updateThrottled();
@@ -310,7 +327,15 @@ class ProgressPlugin {
 				updateThrottled();
 		};
 
-		const moduleAdd = () => {
+		/**
+		 * @template T
+		 * @param {AsyncQueue<Module, string, Module>} addModuleQueue async queue
+		 * @param {T} _item item
+		 */
+		const moduleAdd = (addModuleQueue, _item) => {
+			if (addModuleQueue.getContext() === "import-module") {
+				skippedModulesCount++;
+			}
 			modulesCount++;
 			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
 		};
@@ -397,12 +422,19 @@ class ProgressPlugin {
 			if (compilation.compiler.isChild()) return Promise.resolve();
 			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
 				async oldData => {
+					const realModulesCount = modulesCount - skippedModulesCount;
+					const realDependenciesCount =
+						dependenciesCount - skippedDependenciesCount;
+
 					if (
 						!oldData ||
-						oldData.modulesCount !== modulesCount ||
-						oldData.dependenciesCount !== dependenciesCount
+						oldData.modulesCount !== realModulesCount ||
+						oldData.dependenciesCount !== realDependenciesCount
 					) {
-						await cache.storePromise({ modulesCount, dependenciesCount });
+						await cache.storePromise({
+							modulesCount: realModulesCount,
+							dependenciesCount: realDependenciesCount
+						});
 					}
 				}
 			);
@@ -413,19 +445,25 @@ class ProgressPlugin {
 			lastModulesCount = modulesCount;
 			lastEntriesCount = entriesCount;
 			lastDependenciesCount = dependenciesCount;
-			modulesCount = dependenciesCount = entriesCount = 0;
+			modulesCount =
+				skippedModulesCount =
+				dependenciesCount =
+				skippedDependenciesCount =
+				entriesCount =
+					0;
 			doneModules = doneDependencies = doneEntries = 0;
 
-			compilation.factorizeQueue.hooks.added.tap(
-				"ProgressPlugin",
-				factorizeAdd
+			compilation.factorizeQueue.hooks.added.tap("ProgressPlugin", item =>
+				factorizeAdd(compilation.factorizeQueue, item)
 			);
 			compilation.factorizeQueue.hooks.result.tap(
 				"ProgressPlugin",
 				factorizeDone
 			);
 
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
+			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", item =>
+				moduleAdd(compilation.addModuleQueue, item)
+			);
 			compilation.processDependenciesQueue.hooks.result.tap(
 				"ProgressPlugin",
 				moduleDone

lib/dependencies/LoaderPlugin.js

@@ -173,6 +173,13 @@ class LoaderPlugin {
 								)
 							);
 						}
+
+						const oldFactorizeQueueContext =
+							compilation.factorizeQueue.getContext();
+						compilation.factorizeQueue.setContext("import-module");
+						const oldAddModuleQueueContext =
+							compilation.addModuleQueue.getContext();
+						compilation.addModuleQueue.setContext("import-module");
 						compilation.buildQueue.increaseParallelism();
 						compilation.handleModuleCreation(
 							{
@@ -189,6 +196,8 @@ class LoaderPlugin {
 								checkCycle: true
 							},
 							err => {
+								compilation.factorizeQueue.setContext(oldFactorizeQueueContext);
+								compilation.addModuleQueue.setContext(oldAddModuleQueueContext);
 								compilation.buildQueue.decreaseParallelism();
 								if (err) {
 									return callback(err);

lib/util/AsyncQueue.js

@@ -68,12 +68,14 @@ class AsyncQueue {
 	 * @param {object} options options object
 	 * @param {string=} options.name name of the queue
 	 * @param {number=} options.parallelism how many items should be processed at once
+	 * @param {string=} options.context context of execution
 	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
 	 * @param {getKey<T, K>=} options.getKey extract key from item
 	 * @param {Processor<T, R>} options.processor async function to process items
 	 */
-	constructor({ name, parallelism, parent, processor, getKey }) {
+	constructor({ name, context, parallelism, parent, processor, getKey }) {
 		this._name = name;
+		this._context = context || "normal";
 		this._parallelism = parallelism || 1;
 		this._processor = processor;
 		this._getKey =
@@ -115,6 +117,20 @@ class AsyncQueue {
 		this._ensureProcessing = this._ensureProcessing.bind(this);
 	}
 
+	/**
+	 * @returns {string} context of execution
+	 */
+	getContext() {
+		return this._context;
+	}
+
+	/**
+	 * @param {string} value context of execution
+	 */
+	setContext(value) {
+		this._context = value;
+	}
+
 	/**
 	 * @param {T} item an item
 	 * @param {Callback<R>} callback callback function

types.d.ts

@@ -407,6 +407,8 @@ declare abstract class AsyncQueue<T, K, R> {
 			[T, undefined | null | WebpackError, undefined | null | R]
 		>;
 	};
+	getContext(): string;
+	setContext(value: string): void;
 	add(item: T, callback: CallbackAsyncQueue<R>): void;
 	invalidate(item: T): void;