perseus 0.4.2

A lightning-fast frontend web dev platform with full support for SSR and SSG.
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

use super::{rx_result::RxResultRx, Freeze, MakeRx, MakeUnrx};
use futures::Future;
use serde::{de::DeserializeOwned, Serialize};
use sycamore::prelude::{RcSignal, Scope};
use sycamore_futures::spawn_local_scoped;

/// A utility function for calling suspense handlers and managing their errors.
/// This automatically implements the pattern of allowing suspense handlers to
/// return arbitrary errors that will be set, enabling the more convenient use
/// of `?` in those handlers.
///
/// Note that this function should only be used for suspense fields that are
/// also reactively nested, and therefore that use `RxResult`.
///
/// You shouldn't need to do this unless you're manually deriving the traits for
/// the reactive state platform.
///
/// Note that this will simply start an asynchronous call to run the suspense
/// handler, managing any errors.
///
/// The handler this takes is a future, so the asynchronous function handler
/// itself should be called without `.await` before being provided to this
/// function.
pub fn compute_nested_suspense<'a, T, E, F>(cx: Scope<'a>, state: RxResultRx<T, E>, handler: F)
where
    F: Future<Output = Result<(), E>> + 'a,
    T: MakeRx + Serialize + DeserializeOwned + Clone + 'static, /* Note this `Clone` bound!
                                                                 * (Otherwise cloning goes to
                                                                 * the undelrying `RcSignal`) */
    <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static,
    E: Serialize + DeserializeOwned + Clone + 'static,
{
    spawn_local_scoped(cx, async move {
        let res = handler.await;
        if let Err(err) = res {
            state.set(Err(err));
        }
    });
}

/// A utility function for calling suspense handlers and managing their errors.
/// This automatically implements the pattern of allowing suspense handlers to
/// return arbitrary errors that will be set, enabling the more convenient use
/// of `?` in those handlers.
///
/// Note that this function should only be used for suspense fields that are
/// *not* reactively nested, and that therefore use a standard `Result<T, E>`.
///
/// You shouldn't need to do this unless you're manually deriving the traits for
/// the reactive state platform.
///
/// Note that this will simply start an asynchronous call to run the suspense
/// handler, managing any errors.
///
/// The handler this takes is a future, so the asynchronous function handler
/// itself should be called without `.await` before being provided to this
/// function.
pub fn compute_suspense<'a, T, E, F>(cx: Scope<'a>, state: RcSignal<Result<T, E>>, handler: F)
where
    F: Future<Output = Result<(), E>> + 'a,
    T: Serialize + DeserializeOwned + Clone + 'static, /* Note this `Clone` bound! (Otherwise
                                                        * cloning goes to the undelrying
                                                        * `RcSignal`) */
    E: Serialize + DeserializeOwned + Clone + 'static,
{
    spawn_local_scoped(cx, async move {
        // let state_ref = create_ref(cx, state.clone());
        let res = handler.await;
        if let Err(err) = res {
            state.set(Err(err));
        }
    });
}