fetsig 0.25.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
105
106
107

use futures_signals::signal::{Mutable, Signal, SignalExt};
use futures_signals_ext::{MutableExt, MutableOption};
use log::debug;
use serde::de::DeserializeOwned;
use smol_str::SmolStr;

use crate::{Messages, NoMac, StatusCode};

use super::{fetch, request::Request, transferstate::TransferState};

#[derive(Default)]
pub struct UploadStore {
    transfer_state: Mutable<TransferState>,
}

impl UploadStore {
    pub fn new() -> Self {
        Self {
            transfer_state: Mutable::new(TransferState::Empty),
        }
    }

    pub fn invalidate(&self) {
        self.transfer_state.set(TransferState::Empty);
    }

    pub fn transfer_state(&self) -> &Mutable<TransferState> {
        &self.transfer_state
    }

    pub fn set_transfer_state(&self, transfer_state: TransferState) {
        self.transfer_state.set_neq(transfer_state);
    }

    pub fn stored(&self) -> bool {
        self.transfer_state.map(TransferState::stored)
    }

    pub fn stored_signal(&self) -> impl Signal<Item = bool> + use<> {
        self.transfer_state.signal_ref(|state| state.stored())
    }

    pub fn stored_status(&self) -> Option<StatusCode> {
        self.transfer_state.map(TransferState::stored_status)
    }

    pub fn stored_status_signal(&self) -> impl Signal<Item = Option<StatusCode>> + use<> {
        self.transfer_state
            .signal_ref(TransferState::stored_status)
            .dedupe()
    }

    pub fn pending(&self) -> bool {
        self.transfer_state.map(TransferState::pending)
    }

    pub fn pending_signal(&self) -> impl Signal<Item = bool> + use<> {
        self.transfer_state.signal_ref(|state| state.pending())
    }

    pub fn store<C>(&self, request: Request<'_>, response_messages: Messages, result_callback: C)
    where
        C: FnOnce(StatusCode) + 'static,
    {
        self.do_store::<SmolStr, _>(request, None, response_messages, result_callback)
    }

    pub fn store_with_response<R, C>(
        &self,
        request: Request<'_>,
        response_entity: MutableOption<R>,
        response_messages: Messages,
        result_callback: C,
    ) where
        R: DeserializeOwned + 'static,
        C: FnOnce(StatusCode) + 'static,
    {
        self.do_store::<_, _>(
            request,
            Some(response_entity),
            response_messages,
            result_callback,
        );
    }

    fn do_store<R, C>(
        &self,
        request: Request<'_>,
        response_entity: Option<MutableOption<R>>,
        response_messages: Messages,
        result_callback: C,
    ) where
        C: FnOnce(StatusCode) + 'static,
        R: DeserializeOwned + 'static,
    {
        if request.logging() {
            debug!("Request to store {}", request.url());
        }
        fetch::<_, _, NoMac>(
            request,
            self.transfer_state.clone(),
            response_messages,
            response_entity,
            result_callback,
        );
    }
}