leptos_reactive 0.0.7

Reactive system for the Leptos web framework.
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

use std::{
    cell::{Cell, RefCell},
    collections::HashSet,
    rc::Rc,
};

use crate::{
    create_effect, create_signal, runtime::Runtime, spawn::queue_microtask, EffectId, ReadSignal,
    Scope, ScopeId, SignalId, WriteSignal,
};

pub fn use_transition(cx: Scope) -> Transition {
    let (pending, set_pending) = create_signal(cx, false);
    Transition {
        runtime: cx.runtime,
        scope: cx,
        pending,
        set_pending,
    }
}

#[derive(Copy, Clone)]
pub struct Transition {
    runtime: &'static Runtime,
    scope: Scope,
    pending: ReadSignal<bool>,
    set_pending: WriteSignal<bool>,
}

impl Transition {
    pub fn start(&self, f: impl FnOnce()) {
        if self.runtime.running_transition().is_some() {
            f();
        } else {
            {
                self.set_pending.update(|n| *n = true);
                *self.runtime.transition.borrow_mut() = Some(Rc::new(TransitionState {
                    running: Cell::new(true),
                    resources: Default::default(),
                    signals: Default::default(),
                    effects: Default::default(),
                }));
            }

            f();

            if let Some(running_transition) = self.runtime.running_transition() {
                running_transition.running.set(false);

                let runtime = self.runtime;
                let scope = self.scope;
                let resources = running_transition.resources.clone();
                let signals = running_transition.signals.clone();
                let effects = running_transition.effects.clone();
                let set_pending = self.set_pending;

                // place this at end of task queue so it doesn't start at 0
                queue_microtask(move || {
                    create_effect(scope, move |_| {
                        let pending = resources.borrow().iter().map(|p| p.get()).sum::<usize>();

                        if pending == 0 {
                            log::debug!("[Transition] transition complete");
                            for signal in signals.borrow().iter() {
                                log::debug!("[Transition] deferred signal");
                                runtime.any_signal(*signal, |signal| {
                                    signal.end_transition(runtime);
                                });
                            }
                            for effect in effects.borrow().iter() {
                                log::debug!("[Transition] running deferred effect");
                                runtime.any_effect(*effect, |any_effect| {
                                    any_effect.run(*effect);
                                });
                            }
                            log::debug!("[Transition] setting pending to false");
                            set_pending.update(|n| *n = false);
                        }
                    });
                });
            }
        }
    }

    pub fn pending(&self) -> bool {
        self.pending.get()
    }
}

#[derive(Debug)]
pub(crate) struct TransitionState {
    pub running: Cell<bool>,
    pub resources: Rc<RefCell<HashSet<ReadSignal<usize>>>>,
    pub signals: Rc<RefCell<HashSet<(ScopeId, SignalId)>>>,
    pub effects: Rc<RefCell<Vec<(ScopeId, EffectId)>>>,
}