alef 0.82.0

Opinionated polyglot binding generator for Rust libraries
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

    fn {{ method_name }}({{ signature }}) -> {{ return_type }} {
        // self.env is the napi_env that owned the persistent reference; it is stable for
        // the lifetime of the Node process. Env::from_raw is a safe constructor that
        // gives us a live Env handle for the current scope.
        let __env = napi::Env::from_raw(self.env);
        let obj_ref = match self.obj_ref.as_ref() {
            Some(r) => r,
            None => return {{ default_result_expr }},
        };
        let obj = match obj_ref.get_value(&__env) {
            Ok(o) => o,
            Err(_) => return {{ default_result_expr }},
        };

        // Try to get the JS function from the object
        let func: napi::bindgen_prelude::Function<{{ args_tuple_ty }}, napi::bindgen_prelude::Unknown> = match obj.get_named_property("{{ js_method_name }}") {
            Ok(f) => f,
            Err(_) => return {{ default_result_expr }},
        };

{% if empty_args %}
        let result = func.call(());
{% else %}
{% for arg_expr in arg_exprs %}
        let arg_{{ loop.index0 }}: napi::bindgen_prelude::Unknown = {{ arg_expr }};
{% endfor %}
        let result = func.call(napi::bindgen_prelude::FnArgs::from({{ tuple_args }}));
{% endif %}

        match result {
            Err(_) => {{ default_result_expr }},
            Ok(val) => {
                if val.get_type().ok() == Some(napi::bindgen_prelude::ValueType::Object)
                    && let Ok(obj) = val.coerce_to_object()
                {
{%- for variant in payload_result_variants %}
    {%- if variant.cfg %}
                    #[cfg({{ variant.cfg }})]
    {%- endif %}
                    {
                    let prop_name = "{{ variant.wire_name }}";
                    if let Ok(cv) = obj.get_named_property::<napi::bindgen_prelude::Unknown>(prop_name)
                        && !matches!(cv.get_type().unwrap_or(napi::bindgen_prelude::ValueType::Undefined), napi::bindgen_prelude::ValueType::Undefined | napi::bindgen_prelude::ValueType::Null)
                        && let Ok(s) = cv.coerce_to_string().and_then(|s| s.into_utf8()).and_then(|s| s.into_owned())
                    {
                        return {{ return_type }}::{{ variant.name }}(s);
                    }
                    }
{%- endfor %}
                }
                if let Ok(s) = val.coerce_to_string().and_then(|s| s.into_utf8()).and_then(|s| s.into_owned()) {
                    match s.as_str() {
{%- for variant in unit_result_variants %}
    {%- if variant.cfg %}
                        #[cfg({{ variant.cfg }})]
    {%- endif %}
                        "{{ variant.wire_name }}" => {{ return_type }}::{{ variant.name }},
{%- endfor %}
                        _ => {{ unknown_string_result_expr }},
                    }
                } else {
                    {{ default_result_expr }}
                }
            }
        }
    }