rspack_napi 0.100.0-rc.2

rspack napi
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{
  marker::PhantomData,
  os::raw::c_void,
  ptr,
  sync::{
    Arc,
    atomic::{AtomicBool, AtomicPtr, Ordering},
  },
};

use napi::{Env, Result, check_status, sys};

struct DeferredData<Resolver: FnOnce(Env)> {
  resolver: Resolver,
}

struct JsCallbackInfo {
  tsfn: AtomicPtr<sys::napi_threadsafe_function__>,
  aborted: AtomicBool,
}

impl Drop for JsCallbackInfo {
  fn drop(&mut self) {
    if self.aborted.load(Ordering::Relaxed) {
      return;
    }
    let status = unsafe {
      sys::napi_release_threadsafe_function(
        self.tsfn.load(Ordering::Acquire),
        sys::ThreadsafeFunctionReleaseMode::release,
      )
    };
    debug_assert!(
      status == sys::Status::napi_ok,
      "Release ThreadsafeFunction in JsCallback failed"
    );
  }
}

pub struct JsCallback<Resolver: FnOnce(Env)> {
  callback_info: Arc<JsCallbackInfo>,
  _resolver: PhantomData<Resolver>,
}

unsafe impl<Resolver: FnOnce(Env)> Send for JsCallback<Resolver> {}
unsafe impl<Resolver: FnOnce(Env)> Sync for JsCallback<Resolver> {}

impl<Resolver: FnOnce(Env)> JsCallback<Resolver> {
  /// # Safety
  /// The provided `env` must be a valid `napi_env`.
  pub unsafe fn new(env: sys::napi_env) -> Result<Self> {
    let mut async_resource_name = ptr::null_mut();
    let s = c"napi_js_callback";
    check_status!(
      unsafe { sys::napi_create_string_utf8(env, s.as_ptr(), 16, &mut async_resource_name) },
      "Create async resource name in JsCallback failed"
    )?;

    let mut tsfn = ptr::null_mut();
    let callback_info = Arc::new(JsCallbackInfo {
      aborted: AtomicBool::new(false),
      tsfn: AtomicPtr::new(ptr::null_mut()),
    });
    check_status!(
      unsafe {
        sys::napi_create_threadsafe_function(
          env,
          ptr::null_mut(),
          ptr::null_mut(),
          async_resource_name,
          0,
          1,
          Arc::into_raw(callback_info.clone()) as _,
          Some(napi_js_finalize_cb),
          ptr::null_mut(),
          Some(napi_js_callback::<Resolver>),
          &mut tsfn,
        )
      },
      "Create threadsafe function in JsCallback failed"
    )?;
    callback_info.tsfn.store(tsfn, Ordering::Release);
    check_status!(unsafe { sys::napi_unref_threadsafe_function(env, tsfn) })?;

    let deferred = Self {
      callback_info,
      _resolver: PhantomData,
    };

    Ok(deferred)
  }

  /// The provided function will be called from the JavaScript thread
  pub fn call(&self, resolver: Resolver) {
    self.call_tsfn(resolver)
  }

  fn call_tsfn(&self, result: Resolver) {
    let data = DeferredData { resolver: result };

    // Call back into the JS thread via a threadsafe function. This results in napi_js_callback being called.
    let status = unsafe {
      sys::napi_call_threadsafe_function(
        self.callback_info.tsfn.load(Ordering::Acquire),
        Box::into_raw(Box::from(data)).cast(),
        sys::ThreadsafeFunctionCallMode::blocking,
      )
    };
    debug_assert!(
      status == sys::Status::napi_ok,
      "Call threadsafe function in JsCallback failed"
    );
  }
}

impl<Resolver: FnOnce(Env)> Clone for JsCallback<Resolver> {
  fn clone(&self) -> Self {
    if self.callback_info.aborted.load(Ordering::Relaxed) {
      panic!("JsCallback was aborted, can not clone it");
    }
    Self {
      callback_info: self.callback_info.clone(),
      _resolver: PhantomData,
    }
  }
}

extern "C" fn napi_js_finalize_cb(
  _env: sys::napi_env,
  finalize_data: *mut c_void,
  _finalize_hint: *mut c_void,
) {
  let callback_info = unsafe { Arc::<JsCallbackInfo>::from_raw(finalize_data.cast()) };
  callback_info.aborted.store(true, Ordering::Relaxed);
}

extern "C" fn napi_js_callback<Resolver: FnOnce(Env)>(
  env: sys::napi_env,
  _js_callback: sys::napi_value,
  _context: *mut c_void,
  data: *mut c_void,
) {
  if env.is_null() {
    return;
  }
  let deferred_data = unsafe { Box::<DeferredData<Resolver>>::from_raw(data.cast()) };
  (deferred_data.resolver)(Env::from_raw(env));
}