fix: should run invalidation when watching is invalid (#8966)

fix: should run next invalidation when watching is invalid

Author: JSerFeng

crates/rspack_plugin_extract_css/src/plugin.rs

@@ -727,7 +727,6 @@ fn get_undo_path(filename: &str, output_path: &str, enforce_relative: bool) -> S
   let mut depth: isize = -1;
   let mut append = "".into();
 
-  // eslint-disable-next-line no-param-reassign
   let output_path = output_path.strip_suffix('\\').unwrap_or(output_path);
   let mut output_path = output_path
     .strip_suffix('/')

packages/rspack-test-tools/tests/compilerCases/invalidation-multi-times.js

@@ -0,0 +1,47 @@
+const path = require('path');
+
+const mockFn = jest.fn(() => {});
+
+class MyPlugin {
+	apply(compiler) {
+		compiler.hooks.watchRun.tap("MyPlugin", mockFn)
+	}
+}
+
+/** @type {import('../../dist').TCompilerCaseConfig} */
+module.exports = {
+	description: "should be invalidated correctly",
+	options(context) {
+		return {
+			context: context.getSource(),
+			entry: "./abc",
+			plugins: [new MyPlugin()]
+		};
+	},
+	async build(_, compiler) {
+		try {
+			await new Promise((resolve, reject) => {
+				let firstRun = true;
+				compiler.watch({}, (err) => {
+					if (err) {
+						return reject(err);
+					}
+					if (firstRun) {
+						firstRun = false;
+						compiler.watching.lazyCompilationInvalidate(path.resolve(__dirname, "../fixtures/a.js"));
+						compiler.watching.lazyCompilationInvalidate(path.resolve(__dirname, "../fixtures/b.js"));
+						setTimeout(() => {
+							resolve()
+						}, 2000)
+					}
+				});
+			});
+		} catch(err) {
+			throw err
+		}
+
+	},
+	async check() {
+		expect(mockFn).toHaveBeenCalledTimes(3);
+	}
+};

packages/rspack/src/Watching.ts

@@ -330,19 +330,33 @@ export class Watching {
 			}
 		};
 
-		const cbs = this.callbacks;
-		this.callbacks = [];
-		const startTime = this.startTime; // store last startTime for compilation
-		// reset startTime for next compilation, before throwing error
-		this.startTime = undefined;
 		if (error) {
 			return handleError(error);
 		}
 		assert(compilation);
 
+		stats = new Stats(compilation);
+
+		if (
+			this.invalid &&
+			!this.suspended &&
+			!this.blocked &&
+			!(this.isBlocked() && (this.blocked = true))
+		) {
+			this.#go();
+			return;
+		}
+
+		const startTime = this.startTime; // store last startTime for compilation
+		// reset startTime for next compilation, before throwing error
+		this.startTime = undefined;
 		compilation.startTime = startTime;
 		compilation.endTime = Date.now();
-		stats = new Stats(compilation);
+		const cbs = this.callbacks;
+		this.callbacks = [];
+		const fileDependencies = new Set([...compilation.fileDependencies]);
+		const contextDependencies = new Set([...compilation.contextDependencies]);
+		const missingDependencies = new Set([...compilation.missingDependencies]);
 
 		this.compiler.hooks.done.callAsync(stats, err => {
 			if (err) return handleError(err, cbs);
@@ -351,9 +365,9 @@ export class Watching {
 			process.nextTick(() => {
 				if (!this.#closed) {
 					this.watch(
-						compilation.fileDependencies,
-						compilation.contextDependencies,
-						compilation.missingDependencies
+						fileDependencies,
+						contextDependencies,
+						missingDependencies
 					);
 				}
 			});