alef 0.23.39

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
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

let key = wasm_bindgen::JsValue::from_str("{{ js_name }}");
let has_method = js_sys::Reflect::has(&self.inner, &key).unwrap_or(false);
if !has_method {
{% if has_error %}
    return Err({{ error_expr }});
{% else %}
    return Default::default();
{% endif %}
}

{% if has_error %}
let func_val = js_sys::Reflect::get(&self.inner, &key)
    .map_err(|_| {{ error_get_method }})?;
{% else %}
let func_val = match js_sys::Reflect::get(&self.inner, &key) {
    Ok(f) => f,
    Err(_) => return Default::default(),
};
{% endif %}

{% if has_error %}
let func: js_sys::Function = func_val.dyn_into()
    .map_err(|_| {{ error_dyn_into }})?;
{% else %}
let func: js_sys::Function = match func_val.dyn_into() {
    Ok(f) => f,
    Err(_) => return Default::default(),
};
{% endif %}

let args = js_sys::Array::new();
{% for param in params %}
args.push(&{{ param }});
{% endfor %}

{% if has_error %}
let promise_val = func.apply(&self.inner, &args)
    .map_err(|_| {{ error_apply }})?;
let promise: js_sys::Promise = promise_val.dyn_into()
    .map_err(|_| {{ error_promise }})?;
let result = wasm_bindgen_futures::JsFuture::from(promise)
    .await
    .map_err(|e| {{ error_promise_rejected }})?;
{% else %}
let result = match func.apply(&self.inner, &args) {
    Ok(v) => match wasm_bindgen_futures::JsFuture::from(js_sys::Promise::from(v)).await {
        Ok(r) => r,
        Err(_) => return Default::default(),
    },
    Err(_) => return Default::default(),
};
{% endif %}

// Convert result
{% if return_unit %}
{% if has_error %}
Ok(())
{% else %}
()
{% endif %}
{% elif return_string %}
{% if has_error %}
result.as_string()
    .ok_or_else(|| {{ error_string_conv }})
{% else %}
result.as_string().unwrap_or_default()
{% endif %}
{% elif return_bool %}
// Convert JS boolean to Rust bool
{% if has_error %}
result.as_bool()
    .ok_or_else(|| {{ error_result_conv }})
{% else %}
result.as_bool().unwrap_or_default()
{% endif %}
{% elif return_enum %}
// Convert bare enum string (non-JSON) to {{ ret_ty }}
{% if has_error %}
result.as_string()
    .ok_or_else(|| {{ error_result_conv }})
    .and_then(|s| serde_json::from_str::<{{ ret_ty }}>(&format!("\"{}\"", s)).map_err(|e| {{ error_deser }}))
{% else %}
result.as_string().and_then(|s| serde_json::from_str::<{{ ret_ty }}>(&format!("\"{}\"", s)).map_err(|_| {{ error_deser }})).unwrap_or_default()
{% endif %}
{% else %}
{% if has_error %}
result.as_string()
    .ok_or_else(|| {{ error_result_conv }})
    .and_then(|s| serde_json::from_str::<{{ ret_ty }}>(&s).map_err(|e| {{ error_deser }}))
{% else %}
result.as_string().and_then(|s| serde_json::from_str::<{{ ret_ty }}>(&s).map_err(|_| {{ error_deser }})).unwrap_or_default()
{% endif %}
{% endif %}