freya-core 0.4.0-rc.7

Reactivity runtime, tree management, accessibility integration, rendering pipeline and more, for Freya
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

use std::{
    cell::RefCell,
    rc::Rc,
};

use crate::{
    prelude::{
        State,
        spawn,
        use_hook,
        use_reactive,
    },
    reactive_context::ReactiveContext,
};

pub struct Effect;

impl Effect {
    pub fn create(mut callback: impl FnMut() + 'static) {
        let (rx, rc) = ReactiveContext::new_for_task();
        spawn(async move {
            loop {
                ReactiveContext::run(rc.clone(), &mut callback);
                rx.notified().await;
            }
        });
    }

    // TODO: This should probably not be sync but instead Freya should prioritize effect tasks
    pub fn create_sync_with_gen(mut callback: impl FnMut(usize) + 'static) {
        let (rx, rc) = ReactiveContext::new_for_task();
        ReactiveContext::run(rc.clone(), || callback(0));
        spawn(async move {
            let mut current_gen = 1;
            loop {
                rx.notified().await;
                ReactiveContext::run(rc.clone(), || callback(current_gen));
                current_gen += 1;
            }
        });
    }

    pub fn create_sync(mut callback: impl FnMut() + 'static) {
        let (rx, rc) = ReactiveContext::new_for_task();
        ReactiveContext::run(rc.clone(), &mut callback);
        spawn(async move {
            loop {
                rx.notified().await;
                ReactiveContext::run(rc.clone(), &mut callback);
            }
        });
    }

    pub fn create_after(callback: impl FnMut() + 'static) {
        let (rx, rc) = ReactiveContext::new_for_task();
        let callback = Rc::new(RefCell::new(callback));
        spawn(async move {
            loop {
                let callback = callback.clone();
                let rc = rc.clone();
                spawn(async move {
                    ReactiveContext::run(rc, &mut *callback.borrow_mut());
                });
                rx.notified().await;
            }
        });
    }

    pub fn create_value<T: 'static>(mut callback: impl FnMut() -> T + 'static) -> State<T> {
        let (rx, rc) = ReactiveContext::new_for_task();
        let mut state = State::create(ReactiveContext::run(rc.clone(), &mut callback));
        spawn(async move {
            let mut current_gen = 0;
            loop {
                if current_gen > 0 {
                    state.set(ReactiveContext::run(rc.clone(), &mut callback));
                }
                rx.notified().await;
                current_gen += 1;
            }
        });
        state
    }
}

/// Registers a callback that will run every time a [State] which was [.read()](State::read) inside, changes.
/// ```rust, no_run
/// # use freya::prelude::*;
/// let state = use_state(|| 0);
///
/// use_side_effect(move || {
///     // The moment `.read()` is called this side effect callback gets subscribed to it
///     let value = *state.read();
///     println!("{value}");
/// });
/// ```
pub fn use_side_effect(callback: impl FnMut() + 'static) {
    use_hook(|| Effect::create(callback));
}

pub fn use_after_side_effect(callback: impl FnMut() + 'static) {
    use_hook(|| Effect::create_after(callback));
}

pub fn use_side_effect_value<T: 'static>(callback: impl FnMut() -> T + 'static) -> State<T> {
    use_hook(|| Effect::create_value(callback))
}

pub fn use_side_effect_with_deps<D: 'static + Clone + PartialEq>(
    deps: &D,
    mut callback: impl FnMut(&D) + 'static,
) {
    let deps = use_reactive(deps);
    use_hook(move || {
        Effect::create(move || {
            let deps = deps.read();
            callback(&deps)
        })
    });
}