alef 0.32.11

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

{% if not has_error %}
// This method's Rust signature is infallible, so a host failure cannot
// propagate. eprintln! is invisible in browsers, so log to the JS console
// before substituting the default — a silent default is indistinguishable
// from a real result to the caller.
fn __log_host_failure(msg: &str) {
    let global = js_sys::global();
    if let Ok(console) = js_sys::Reflect::get(&global, &wasm_bindgen::JsValue::from_str("console")) {
        if let Ok(error_fn) = js_sys::Reflect::get(&console, &wasm_bindgen::JsValue::from_str("error")) {
            if let Ok(error_fn) = error_fn.dyn_into::<js_sys::Function>() {
                let _ = error_fn.call1(&console, &wasm_bindgen::JsValue::from_str(msg));
            }
        }
    }
}
{% endif %}
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 %}
    __log_host_failure("[{{ wrapper }}] host method '{{ js_name }}' is missing; returning default");
    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(e) => {
        __log_host_failure(&format!("[{{ wrapper }}] failed to get host method '{{ js_name }}'; returning default: {e:?}"));
        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(_) => {
        __log_host_failure("[{{ wrapper }}] host '{{ js_name }}' is not a function; returning default");
        return Default::default();
    }
};
{% endif %}

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

// Call the function
{% if has_error %}
let result = func.apply(&self.inner, &args)
    .map_err(|_| {{ error_apply }})?;
{% else %}
let result = match func.apply(&self.inner, &args) {
    Ok(r) => r,
    Err(e) => {
        __log_host_failure(&format!("[{{ wrapper }}] host '{{ js_name }}' threw; returning default: {e:?}"));
        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 %}
match result.as_string() {
    Some(s) => s,
    None => {
        __log_host_failure("[{{ wrapper }}] host '{{ js_name }}' returned a non-string value; returning default");
        Default::default()
    }
}
{% endif %}
{% elif return_bool %}
// Convert JS boolean to Rust bool
{% if has_error %}
result.as_bool()
    .ok_or_else(|| {{ error_result_conv }})
{% else %}
match result.as_bool() {
    Some(b) => b,
    None => {
        __log_host_failure("[{{ wrapper }}] host '{{ js_name }}' returned a non-boolean value; returning default");
        Default::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 %}
match result.as_string() {
    Some(s) => match serde_json::from_str::<{{ ret_ty }}>(&format!("\"{}\"", s)) {
        Ok(v) => v,
        Err(e) => {
            __log_host_failure(&format!("[{{ wrapper }}] host '{{ js_name }}' returned an unparseable value; returning default: {e}"));
            Default::default()
        }
    },
    None => {
        __log_host_failure("[{{ wrapper }}] host '{{ js_name }}' returned a non-string value; returning default");
        Default::default()
    }
}
{% endif %}
{% else %}
// Convert JS result to {{ ret_ty }}
{% 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 %}
match result.as_string() {
    Some(s) => match serde_json::from_str::<{{ ret_ty }}>(&s) {
        Ok(v) => v,
        Err(e) => {
            __log_host_failure(&format!("[{{ wrapper }}] host '{{ js_name }}' returned an unparseable value; returning default: {e}"));
            Default::default()
        }
    },
    None => {
        __log_host_failure("[{{ wrapper }}] host '{{ js_name }}' returned a non-string value; returning default");
        Default::default()
    }
}
{% endif %}
{% endif %}