feat: add afterCompile hook (#3235)

crates/node_binding/binding.d.ts

@@ -183,6 +183,7 @@ export interface JsHooks {
   optimizeModules: (...args: any[]) => any
   optimizeChunkModule: (...args: any[]) => any
   beforeCompile: (...args: any[]) => any
+  afterCompile: (...args: any[]) => any
   finishModules: (...args: any[]) => any
   beforeResolve: (...args: any[]) => any
   afterResolve: (...args: any[]) => any

crates/node_binding/src/hook.rs

@@ -18,6 +18,7 @@ pub enum Hook {
   AfterEmit,
   OptimizeChunkModules,
   BeforeCompile,
+  AfterCompile,
   FinishModules,
   OptimizeModules,
   /// webpack `compilation.hooks.chunkAsset`
@@ -45,6 +46,7 @@ impl From<String> for Hook {
       "afterEmit" => Hook::AfterEmit,
       "optimizeChunkModules" => Hook::OptimizeChunkModules,
       "beforeCompile" => Hook::BeforeCompile,
+      "afterCompile" => Hook::AfterCompile,
       "finishModules" => Hook::FinishModules,
       "optimizeModules" => Hook::OptimizeModules,
       "chunkAsset" => Hook::ChunkAsset,

crates/node_binding/src/js_values/hooks.rs

@@ -18,6 +18,7 @@ pub struct JsHooks {
   pub optimize_modules: JsFunction,
   pub optimize_chunk_module: JsFunction,
   pub before_compile: JsFunction,
+  pub after_compile: JsFunction,
   pub finish_modules: JsFunction,
   pub before_resolve: JsFunction,
   pub after_resolve: JsFunction,

crates/node_binding/src/plugins/mod.rs

@@ -39,6 +39,7 @@ pub struct JsHooksAdapter {
   pub optimize_modules_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub optimize_chunk_modules_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub before_compile_tsfn: ThreadsafeFunction<(), ()>,
+  pub after_compile_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub finish_modules_tsfn: ThreadsafeFunction<JsCompilation, ()>,
   pub chunk_asset_tsfn: ThreadsafeFunction<JsChunkAssetArgs, ()>,
   pub before_resolve: ThreadsafeFunction<BeforeResolveData, Option<bool>>,
@@ -407,6 +408,28 @@ impl rspack_core::Plugin for JsHooksAdapter {
       .map_err(|err| internal_error!("Failed to call before compile: {err}",))?
   }
 
+  async fn after_compile(
+    &mut self,
+    compilation: &mut rspack_core::Compilation,
+  ) -> rspack_error::Result<()> {
+    if self.is_hook_disabled(&Hook::AfterCompile) {
+      return Ok(());
+    }
+
+    let compilation = JsCompilation::from_compilation(unsafe {
+      std::mem::transmute::<&'_ mut rspack_core::Compilation, &'static mut rspack_core::Compilation>(
+        compilation,
+      )
+    });
+
+    self
+      .after_compile_tsfn
+      .call(compilation, ThreadsafeFunctionCallMode::NonBlocking)
+      .into_rspack_result()?
+      .await
+      .map_err(|err| internal_error!("Failed to call after compile: {err}"))?
+  }
+
   async fn finish_modules(
     &mut self,
     compilation: &mut rspack_core::Compilation,
@@ -479,6 +502,7 @@ impl JsHooksAdapter {
       context_module_before_resolve,
       normal_module_factory_resolve_for_scheme,
       before_compile,
+      after_compile,
       finish_modules,
       chunk_asset,
     } = js_hooks;
@@ -512,6 +536,8 @@ impl JsHooksAdapter {
       js_fn_into_theadsafe_fn!(optimize_chunk_module, env);
     let before_compile_tsfn: ThreadsafeFunction<(), ()> =
       js_fn_into_theadsafe_fn!(before_compile, env);
+    let after_compile_tsfn: ThreadsafeFunction<JsCompilation, ()> =
+      js_fn_into_theadsafe_fn!(after_compile, env);
     let finish_modules_tsfn: ThreadsafeFunction<JsCompilation, ()> =
       js_fn_into_theadsafe_fn!(finish_modules, env);
     let context_module_before_resolve: ThreadsafeFunction<BeforeResolveData, Option<bool>> =
@@ -545,6 +571,7 @@ impl JsHooksAdapter {
       optimize_modules_tsfn,
       optimize_chunk_modules_tsfn,
       before_compile_tsfn,
+      after_compile_tsfn,
       before_resolve,
       context_module_before_resolve,
       normal_module_factory_resolve_for_scheme,

crates/rspack_core/src/compiler/mod.rs

@@ -177,6 +177,13 @@ where
     }
     self.compilation.seal(self.plugin_driver.clone()).await?;
 
+    self
+      .plugin_driver
+      .write()
+      .await
+      .after_compile(&mut self.compilation)
+      .await?;
+
     // Consume plugin driver diagnostic
     let plugin_driver_diagnostics = self.plugin_driver.read().await.take_diagnostic();
     self

crates/rspack_core/src/plugin/api.rs

@@ -320,6 +320,10 @@ pub trait Plugin: Debug + Send + Sync {
     Ok(())
   }
 
+  async fn after_compile(&mut self, _compilation: &mut Compilation) -> Result<()> {
+    Ok(())
+  }
+
   async fn finish_modules(&mut self, _modules: &mut Compilation) -> Result<()> {
     Ok(())
   }

crates/rspack_core/src/plugin/plugin_driver.rs

@@ -177,6 +177,17 @@ impl PluginDriver {
 
     Ok(())
   }
+
+  pub async fn after_compile(
+    &mut self,
+    compilation: &mut Compilation,
+  ) -> PluginCompilationHookOutput {
+    for plugin in &mut self.plugins {
+      plugin.after_compile(compilation).await?;
+    }
+
+    Ok(())
+  }
   /// Executed while initializing the compilation, right before emitting the compilation event. This hook is not copied to child compilers.
   ///
   /// See: https://webpack.js.org/api/compiler-hooks/#thiscompilation

packages/rspack/src/compiler.ts

@@ -131,6 +131,7 @@ class Compiler {
 		afterResolvers: tapable.SyncHook<[Compiler]>;
 		make: tapable.AsyncParallelHook<[Compilation]>;
 		beforeCompile: tapable.AsyncSeriesHook<any>;
+		afterCompile: tapable.AsyncSeriesHook<[Compilation]>;
 		finishModules: tapable.AsyncSeriesHook<[any]>;
 	};
 	options: RspackOptionsNormalized;
@@ -226,6 +227,7 @@ class Compiler {
 			afterResolvers: new tapable.SyncHook(["compiler"]),
 			make: new tapable.AsyncParallelHook(["compilation"]),
 			beforeCompile: new tapable.AsyncSeriesHook(["params"]),
+			afterCompile: new tapable.AsyncSeriesHook(["compilation"]),
 			finishModules: new tapable.AsyncSeriesHook(["modules"])
 		};
 		this.modifiedFiles = undefined;
@@ -275,6 +277,7 @@ class Compiler {
 				options,
 				{
 					beforeCompile: this.#beforeCompile.bind(this),
+					afterCompile: this.#afterCompile.bind(this),
 					make: this.#make.bind(this),
 					emit: this.#emit.bind(this),
 					afterEmit: this.#afterEmit.bind(this),
@@ -554,6 +557,7 @@ class Compiler {
 		const hookMap = {
 			make: this.hooks.make,
 			beforeCompile: this.hooks.beforeCompile,
+			afterCompile: this.hooks.afterCompile,
 			emit: this.hooks.emit,
 			afterEmit: this.hooks.afterEmit,
 			processAssetsStageAdditional:
@@ -607,6 +611,11 @@ class Compiler {
 		// this.#updateDisabledHooks();
 	}
 
+	async #afterCompile() {
+		await this.hooks.afterCompile.promise(this.compilation);
+		this.#updateDisabledHooks();
+	}
+
 	async #finishModules() {
 		await this.compilation.hooks.finishModules.promise(
 			this.compilation.getModules()