pinar 0.1.0

Library to write node native modules with N-API
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


use std::hash::Hash;
use std::collections::HashMap;
use std::sync::Arc;
use std::rc::Rc;
use std::hash::BuildHasher;
use crate::prelude::*;
use crate::Result;

pub trait ToJs<'e> {
    type Value: JsValue;
    fn to_js(self, _: Env) -> Result<Self::Value>;
}

macro_rules! impl_tojs {
    (
        $( $jstype:ident ),*
    ) => {
        $(
            impl<'e, 'v> ToJs<'e> for $jstype<'v> {
                type Value = Self;
                fn to_js(self, _: Env) -> Result<Self> {
                    Ok(self)
                }
            }
        )*
    }
}

impl_tojs!(
    JsString,
    JsObject,
    JsArray,
    JsNumber,
    JsSymbol,
    JsUndefined,
    JsFunction,
    JsExternal,
    JsNull,
    JsBoolean,
    JsBigInt
);

impl<'e> ToJs<'e> for Value {
    type Value = Self;
    fn to_js(self, _: Env) -> Result<Self> {
        Ok(self)
    }
}

impl<'e> ToJs<'e> for i64 {
    type Value = JsNumber<'e>;
    fn to_js(self, env: Env) -> Result<JsNumber<'e>> {
        env.number(self)
    }
}

impl<'e> ToJs<'e> for String {
    type Value = JsString<'e>;
    fn to_js(self, env: Env) -> Result<JsString<'e>> {
        env.string(self)
    }
}

impl<'e, K, V, S> ToJs<'e> for HashMap<K, V, S>
where
    K: Hash + Eq + KeyProperty + ToJs<'e>,
    V: ToJs<'e>,
    S: BuildHasher
{
    type Value = JsObject<'e>;
    fn to_js(self, env: Env) -> Result<JsObject<'e>> {
        let object = env.object()?;
        for (key, value) in self.into_iter() {
            object.set(key, value)?;
        }
        Ok(object)
    }
}

impl<'e, T> ToJs<'e> for std::vec::Vec<T>
where
    T: ToJs<'e>
{
    type Value = JsArray<'e>;
    fn to_js(self, env: Env) -> Result<JsArray<'e>> {
        let array = env.array_with_capacity(self.len())?;
        for (index, value) in self.into_iter().enumerate() {
            array.set(index as u32, value)?;
        }
        Ok(array)
    }
}

impl<'e, 's> ToJs<'e> for &'s str {
    type Value = JsString<'e>;
    fn to_js(self, env: Env) -> Result<JsString<'e>> {
        env.string(self)
    }
}

impl<'e, T: 'static> ToJs<'e> for Box<T> {
    type Value = JsExternal<'e>;
    fn to_js(self, env: Env) -> Result<JsExternal<'e>> {
        env.external_box(self)
    }
}

impl<'e, T: 'static> ToJs<'e> for Rc<T> {
    type Value = JsExternal<'e>;
    fn to_js(self, env: Env) -> Result<JsExternal<'e>> {
        env.external_rc(self)
    }
}

impl<'e, T: 'static> ToJs<'e> for Arc<T> {
    type Value = JsExternal<'e>;
    fn to_js(self, env: Env) -> Result<JsExternal<'e>> {
        env.external_arc(self)
    }
}