leptos_reactive 0.6.15

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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use leptos_reactive::{
    batch, create_isomorphic_effect, create_memo, create_runtime,
    create_rw_signal, create_signal, untrack, SignalGet, SignalSet,
};

#[test]
fn effect_runs() {
    use std::{cell::RefCell, rc::Rc};

    let runtime = create_runtime();

    let (a, set_a) = create_signal(-1);

    // simulate an arbitrary side effect
    let b = Rc::new(RefCell::new(String::new()));

    create_isomorphic_effect({
        let b = b.clone();
        move |_| {
            let formatted = format!("Value is {}", a.get());
            *b.borrow_mut() = formatted;
        }
    });

    assert_eq!(b.borrow().as_str(), "Value is -1");

    set_a.set(1);

    assert_eq!(b.borrow().as_str(), "Value is 1");

    runtime.dispose();
}

#[test]
fn effect_tracks_memo() {
    use std::{cell::RefCell, rc::Rc};

    let runtime = create_runtime();
    let (a, set_a) = create_signal(-1);
    let b = create_memo(move |_| format!("Value is {}", a.get()));

    // simulate an arbitrary side effect
    let c = Rc::new(RefCell::new(String::new()));

    create_isomorphic_effect({
        let c = c.clone();
        move |_| {
            *c.borrow_mut() = b.get();
        }
    });

    assert_eq!(b.get().as_str(), "Value is -1");
    assert_eq!(c.borrow().as_str(), "Value is -1");

    set_a.set(1);

    assert_eq!(b.get().as_str(), "Value is 1");
    assert_eq!(c.borrow().as_str(), "Value is 1");

    runtime.dispose();
}

#[test]
fn untrack_mutes_effect() {
    use std::{cell::RefCell, rc::Rc};

    let runtime = create_runtime();

    let (a, set_a) = create_signal(-1);

    // simulate an arbitrary side effect
    let b = Rc::new(RefCell::new(String::new()));

    create_isomorphic_effect({
        let b = b.clone();
        move |_| {
            let formatted = format!("Value is {}", untrack(move || a.get()));
            *b.borrow_mut() = formatted;
        }
    });

    assert_eq!(a.get(), -1);
    assert_eq!(b.borrow().as_str(), "Value is -1");

    set_a.set(1);

    assert_eq!(a.get(), 1);
    assert_eq!(b.borrow().as_str(), "Value is -1");

    runtime.dispose();
}

#[test]
fn batching_actually_batches() {
    use std::{cell::Cell, rc::Rc};

    let runtime = create_runtime();

    let first_name = create_rw_signal("Greg".to_string());
    let last_name = create_rw_signal("Johnston".to_string());

    // simulate an arbitrary side effect
    let count = Rc::new(Cell::new(0));

    create_isomorphic_effect({
        let count = count.clone();
        move |_| {
            _ = first_name.get();
            _ = last_name.get();

            count.set(count.get() + 1);
        }
    });

    // runs once initially
    assert_eq!(count.get(), 1);

    // individual updates run effect once each
    first_name.set("Alice".to_string());
    assert_eq!(count.get(), 2);

    last_name.set("Smith".to_string());
    assert_eq!(count.get(), 3);

    // batched effect only runs twice
    batch(move || {
        first_name.set("Bob".to_string());
        last_name.set("Williams".to_string());
    });
    assert_eq!(count.get(), 4);

    runtime.dispose();
}