fetsig 0.27.0

Web-sys based browser fetch library using futures-signals with optional MAC.
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

use futures_signals::{
    map_ref,
    signal::{Signal, SignalExt},
    signal_vec::{MutableVec, SignalVecExt},
};

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub enum CollectionState {
    #[default]
    Empty,
    Error,
    NotEmpty,
    Pending,
}

impl CollectionState {
    pub fn empty(&self) -> bool {
        matches!(*self, Self::Empty)
    }

    pub fn empty_pending(&self) -> bool {
        matches!(*self, Self::Empty | Self::Pending)
    }

    pub fn error(&self) -> bool {
        matches!(*self, Self::Error)
    }

    pub fn not_empty(&self) -> bool {
        matches!(*self, Self::NotEmpty)
    }

    pub fn not_empty_pending(&self) -> bool {
        matches!(*self, Self::NotEmpty | Self::Pending)
    }

    pub fn pending(&self) -> bool {
        matches!(*self, Self::Pending)
    }
}

pub fn combine_collection_states_2<S1, S2>(cs1: S1, cs2: S2) -> impl Signal<Item = CollectionState>
where
    S1: Signal<Item = CollectionState>,
    S2: Signal<Item = CollectionState>,
{
    map_ref!(
        cs1, cs2 => {
            match (cs1, cs2) {
                (CollectionState::Error, _) | (_, CollectionState::Error) => CollectionState::Error,
                (CollectionState::Pending, _) | (_, CollectionState::Pending) => CollectionState::Pending,
                (CollectionState::NotEmpty, _) | (_, CollectionState::NotEmpty) => CollectionState::NotEmpty,
                (CollectionState::Empty, CollectionState::Empty) => CollectionState::Empty,
            }
        }
    )
}

pub fn combine_collection_states_3<S1, S2, S3>(
    cs1: S1,
    cs2: S2,
    cs3: S3,
) -> impl Signal<Item = CollectionState>
where
    S1: Signal<Item = CollectionState>,
    S2: Signal<Item = CollectionState>,
    S3: Signal<Item = CollectionState>,
{
    map_ref!(
        cs1, cs2, cs3 => {
            match (cs1, cs2, cs3) {
                (CollectionState::Error, _, _)
                | (_, CollectionState::Error, _)
                | (_, _, CollectionState::Error) => CollectionState::Error,
                (CollectionState::Pending, _, _)
                | (_, CollectionState::Pending, _)
                | (_, _, CollectionState::Pending) => CollectionState::Pending,
                (CollectionState::NotEmpty, _, _)
                | (_, CollectionState::NotEmpty, _)
                | (_, _, CollectionState::NotEmpty) => CollectionState::NotEmpty,
                (CollectionState::Empty, CollectionState::Empty, CollectionState::Empty) => CollectionState::Empty,
            }
        }
    )
}

pub fn collection_state_from_vec<T, S>(
    vec: &MutableVec<T>,
    pending: S,
) -> impl Signal<Item = CollectionState> + use<T, S>
where
    T: Clone,
    S: Signal<Item = bool>,
{
    let empty = vec.signal_vec_cloned().is_empty();
    map_ref! {
        pending, empty => (*pending, *empty)
    }
    .map(|state| match state {
        (true, _) => CollectionState::Pending,
        (false, true) => CollectionState::Empty,
        (false, false) => CollectionState::NotEmpty,
    })
}