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
use crate::{api, prelude::*};
use std::{marker::PhantomData, mem::MaybeUninit, os::raw::c_char};
#[derive(Debug, Copy, Clone)]
pub struct JsPromise<L: NapiValueT, R: NapiValueT>(
pub(crate) JsValue,
pub(crate) napi_deferred,
PhantomData<L>,
PhantomData<R>,
);
impl<L: NapiValueT + Copy, R: NapiValueT + Copy> JsPromise<L, R> {
pub(crate) fn from_raw(value: JsValue, deferred: napi_deferred) -> JsPromise<L, R> {
JsPromise(value, deferred, PhantomData, PhantomData)
}
pub fn env(&self) -> NapiEnv {
self.0.env()
}
pub fn raw(&self) -> napi_value {
self.0.raw()
}
pub fn value(&self) -> JsValue {
self.0
}
/// This API creates a deferred object and a JavaScript promise.
pub fn new(env: NapiEnv) -> NapiResult<JsPromise<L, R>> {
let mut deferred = MaybeUninit::uninit();
let promise = napi_call!(
=napi_create_promise,
env,
deferred.as_mut_ptr(),
);
let deferred = unsafe { deferred.assume_init() };
Ok(Self::from_raw(JsValue(env, promise), deferred))
}
/// This API resolves a JavaScript promise by way of the deferred object with which it is
/// associated. Thus, it can only be used to resolve JavaScript promises for which the
/// corresponding deferred object is available. This effectively means that the promise must
/// have been created using napi_create_promise() and the deferred object returned from that
/// call must have been retained in order to be passed to this API.
///
/// The deferred object is freed upon successful completion.
pub fn resolve(&self, resolution: L) -> NapiResult<()> {
napi_call!(napi_resolve_deferred, self.env(), self.1, resolution.raw())
}
/// This API rejects a JavaScript promise by way of the deferred object with which it is
/// associated. Thus, it can only be used to reject JavaScript promises for which the
/// corresponding deferred object is available. This effectively means that the promise
/// must have been created using napi_create_promise() and the deferred object returned
/// from that call must have been retained in order to be passed to this API.
///
/// The deferred object is freed upon successful completion.
pub fn reject(&self, rejection: R) -> NapiResult<()> {
napi_call!(napi_reject_deferred, self.env(), self.1, rejection.raw())
}
}
impl<L: NapiValueT + Copy + 'static, R: NapiValueT + Copy + 'static> JsPromise<L, R> {
/// Spawn a busy task in the libuv pool.
pub fn spawn<T>(
env: NapiEnv,
mut work: impl FnMut(&mut T) + Send + 'static,
mut complete: impl FnMut(Self, NapiStatus, T) -> NapiResult<()> + 'static,
) -> NapiResult<JsPromise<L, R>>
where
T: Default,
{
let promise: JsPromise<L, R> = JsPromise::new(env)?;
env.async_work(
"napi-promise-task",
T::default(),
move |state| work(state),
// NB: execute in the main js thread.
move |_, status, state| complete(promise, status, state),
)?
.queue()?;
Ok(promise)
}
}
impl<L: NapiValueT + Copy, R: NapiValueT + Copy> NapiValueCheck for JsPromise<L, R> {
fn check(&self) -> NapiResult<bool> {
Ok(napi_call!(=napi_is_promise, self.env(), self.raw()))
}
}