hashira 0.0.2-alpha

A server side rendering framework build on top of Yew
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

#[cfg(target_arch = "wasm32")]
pub async fn fetch_json<S: serde::de::DeserializeOwned>(
    request: web_sys::Request,
) -> Result<S, crate::error::BoxError> {
    use crate::error::JsError;
    use wasm_bindgen::JsCast;
    use wasm_bindgen_futures::JsFuture;

    let window = web_sys::window().unwrap();
    let resp_value = JsFuture::from(window.fetch_with_request(&request))
        .await
        .map_err(JsError::new)?;

    let resp: web_sys::Response = resp_value.dyn_into().unwrap();

    if !resp.ok() {
        return Err(get_response_error(resp).await);
    }

    // Convert this other `Promise` into a rust `Future`.
    let json = resp.json().map_err(JsError::new)?;
    let json = JsFuture::from(json).await.map_err(JsError::new)?;

    match serde_wasm_bindgen::from_value(json) {
        Ok(x) => Ok(x),
        Err(err) => {
            let s = err.to_string();
            Err(s.into())
        }
    }
}

#[cfg(target_arch = "wasm32")]
async fn get_response_error(resp: web_sys::Response) -> crate::error::BoxError {
    use wasm_bindgen_futures::JsFuture;
    debug_assert!(!resp.ok());

    let content_type = resp
        .headers()
        .get("content-type")
        .ok()
        .flatten()
        .unwrap_or_default();

    let error_message = match content_type.as_str() {
        "application/json" => {
            let json = resp.json().unwrap();
            let json = JsFuture::from(json).await.unwrap();
            serde_wasm_bindgen::from_value::<String>(json).unwrap()
        }
        _ => {
            let text = resp.text().unwrap();
            let text = JsFuture::from(text).await.unwrap();
            text.as_string().unwrap()
        }
    };

    error_message.into()
}