fix

Author: SyMind

crates/node_binding/src/plugins/js_loader/context.rs

@@ -1,5 +1,6 @@
 use std::{collections::HashMap, ptr::NonNull, sync::Arc};
 
+use derive_more::Debug;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 use rspack_core::{LoaderContext, Module, RunnerContext};
@@ -81,33 +82,41 @@ impl From<LoaderState> for JsLoaderState {
 }
 
 #[napi(object)]
+#[derive(Debug)]
 pub struct JsLoaderContext {
+  #[debug(skip)]
   #[napi(ts_type = "Readonly<JsResourceData>")]
   pub resource_data: JsResourceData,
   /// Will be deprecated. Use module.module_identifier instead
   #[napi(js_name = "_moduleIdentifier", ts_type = "Readonly<string>")]
   pub module_identifier: String,
   #[napi(js_name = "_module", ts_type = "Module")]
+  #[debug(skip)]
   pub module: ModuleObject,
   #[napi(ts_type = "Readonly<boolean>")]
   pub hot: bool,
 
   /// Content maybe empty in pitching stage
+  #[debug(skip)]
   pub content: Either<Null, Buffer>,
   #[napi(ts_type = "any")]
+  #[debug(skip)]
   pub additional_data: Option<ThreadsafeJsValueRef<Unknown<'static>>>,
   #[napi(js_name = "__internal__parseMeta")]
   pub parse_meta: HashMap<String, String>,
+  #[debug(skip)]
   pub source_map: Option<Buffer>,
   pub cacheable: bool,
   pub file_dependencies: Vec<String>,
   pub context_dependencies: Vec<String>,
   pub missing_dependencies: Vec<String>,
   pub build_dependencies: Vec<String>,
 
+  #[debug(skip)]
   pub loader_items: Vec<JsLoaderItem>,
   pub loader_index: i32,
   #[napi(ts_type = "Readonly<JsLoaderState>")]
+  #[debug(skip)]
   pub loader_state: JsLoaderState,
   #[napi(js_name = "__internal__error")]
   pub error: Option<JsRspackError>,

crates/node_binding/src/plugins/js_loader/mod.rs

@@ -24,7 +24,7 @@ use crate::{RspackResultToNapiResultExt, COMPILER_REFERENCES};
 pub type JsLoaderRunner = ThreadsafeFunction<
   (
     JsLoaderContext,
-    tokio::sync::oneshot::Sender<napi::Result<JsLoaderContext>>,
+    tokio::sync::oneshot::Sender<JsLoaderContext>,
   ),
   (),
   FnArgs<(JsLoaderContext, napi_value)>,
@@ -33,44 +33,38 @@ pub type JsLoaderRunner = ThreadsafeFunction<
   0,
 >;
 
-unsafe extern "C" fn raw_done<Value>(
+unsafe extern "C" fn raw_done(
   env: sys::napi_env,
-  cbinfo: sys::napi_callback_info,
-) -> sys::napi_value
-where
-  Value: FromNapiValue,
-{
-  handle_done_callback::<Value>(env, cbinfo)
-    .unwrap_or_else(|err| throw_error(env, err, "Error in done"))
+  cb_info: sys::napi_callback_info,
+) -> sys::napi_value {
+  handle_done_callback(env, cb_info).unwrap_or_else(|err| throw_error(env, err, "Error in done"))
 }
 
 #[inline(always)]
-fn handle_done_callback<Value>(
+fn handle_done_callback(
   env: sys::napi_env,
-  cbinfo: sys::napi_callback_info,
-) -> napi::Result<sys::napi_value>
-where
-  Value: FromNapiValue,
-{
+  cb_info: sys::napi_callback_info,
+) -> napi::Result<sys::napi_value> {
   let mut callback_values = [ptr::null_mut()];
-  let mut rust_cb = ptr::null_mut();
+  let mut data = ptr::null_mut();
   check_status!(
     unsafe {
       sys::napi_get_cb_info(
         env,
-        cbinfo,
+        cb_info,
         &mut 1,
         callback_values.as_mut_ptr(),
         ptr::null_mut(),
-        &mut rust_cb,
+        &mut data,
       )
     },
-    "Get callback info from finally callback failed"
+    "Get callback info from loader runner callback failed"
   )?;
 
-  let tx: Box<tokio::sync::oneshot::Sender<Value>> = unsafe { Box::from_raw(rust_cb.cast()) };
+  let tx: Box<tokio::sync::oneshot::Sender<JsLoaderContext>> =
+    unsafe { Box::from_raw(data.cast()) };
 
-  let value: Value = unsafe { FromNapiValue::from_napi_value(env, callback_values[0]) }?;
+  let value = unsafe { FromNapiValue::from_napi_value(env, callback_values[0]) }?;
   let _ = tx.send(value);
 
   Ok(ptr::null_mut())
@@ -146,19 +140,21 @@ extern "C" fn napi_js_callback(
         .build_callback(
           |ctx: ThreadsafeCallContext<(
             JsLoaderContext,
-            tokio::sync::oneshot::Sender<napi::Result<JsLoaderContext>>,
+            tokio::sync::oneshot::Sender<JsLoaderContext>,
           )>| {
-            let (context, sender): (_, _) = ctx.value;
+            let context = ctx.value.0;
+            let sender = ctx.value.1;
             let mut done = ptr::null_mut();
             const DONE: &[u8; 5] = b"done\0";
+            let data = Box::into_raw(Box::new(sender)).cast();
             check_status!(
               unsafe {
                 sys::napi_create_function(
                   ctx.env.raw(),
                   DONE.as_ptr().cast(),
                   4,
-                  Some(raw_done::<JsLoaderContext>),
-                  Box::into_raw(Box::new(sender)).cast(),
+                  Some(raw_done),
+                  data,
                   &mut done,
                 )
               },

crates/node_binding/src/plugins/js_loader/scheduler.rs

@@ -35,12 +35,12 @@ pub(crate) async fn loader_yield(
   let read_guard = self.runner.read().await;
   match &*read_guard {
     Some(runner) => {
-      let (tx, rx) = tokio::sync::oneshot::channel::<napi::Result<JsLoaderContext>>();
+      let (tx, rx) = tokio::sync::oneshot::channel::<JsLoaderContext>();
       runner
         .call_async((loader_context.try_into()?, tx))
         .await
         .into_diagnostic()?;
-      let new_cx = rx.await.into_diagnostic()?.into_diagnostic()?;
+      let new_cx = rx.await.into_diagnostic()?;
       drop(read_guard);
 
       merge_loader_context(loader_context, new_cx)?;
@@ -62,15 +62,15 @@ pub(crate) async fn loader_yield(
       };
 
       let read_guard = self.runner.read().await;
-      let (tx, rx) = tokio::sync::oneshot::channel::<napi::Result<JsLoaderContext>>();
+      let (tx, rx) = tokio::sync::oneshot::channel::<JsLoaderContext>();
       #[allow(clippy::unwrap_used)]
       read_guard
         .as_ref()
         .unwrap()
         .call_async((loader_context.try_into()?, tx))
         .await
         .into_diagnostic()?;
-      let new_cx = rx.await.into_diagnostic()?.into_diagnostic()?;
+      let new_cx = rx.await.into_diagnostic()?;
       drop(read_guard);
 
       merge_loader_context(loader_context, new_cx)?;
@@ -131,7 +131,6 @@ pub(crate) fn merge_loader_context(
       } else {
         rspack_core::Content::from(Into::<Vec<u8>>::into(c))
       };
-
       Some(content)
     }
   };

packages/rspack/src/loader-runner/index.ts

@@ -256,7 +256,7 @@ export function runLoaders(
 	context: JsLoaderContext,
 	callback: (loaderContext: JsLoaderContext) => void
 ): void {
-	runLoadersAsync(compiler, context).then(ctx => callback(ctx));
+	runLoadersAsync(compiler, context).then(callback);
 }
 
 async function runLoadersAsync(