hooks 3.0.0-alpha.15

Compile-time, async hooks
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

#![cfg(all(feature = "futures-core", feature = "all"))]

use futures_lite::StreamExt;
use hooks::ShareValue;
use hooks_core::{prelude::*, HookExt};

mod utils;
use utils::test_many_async;

test_many_async!(use_1_hook(
    {
        hook_fn!(
            fn use_shared_state() -> u32 {
                let state = h![hooks::use_shared_signal(3)];
                state.get()
            }
        );

        let values = use_shared_state()
            .into_hook_values()
            .collect::<Vec<_>>()
            .await;
        assert_eq!(values, [3]);
    },
    {
        hook_fn!(
            fn use_shared_state_borrowing<'a>(
                initial_value: &'a str,
            ) -> &'hook hooks::SharedSignal<&'a str> {
                let state = h!(hooks::use_shared_signal(initial_value));
                state
            }
        );

        let hello = "hello".to_owned();
        let msg = hello + " world!";
        let initial_value: &str = &msg;
        let mut hook = use_shared_state_borrowing(initial_value).into_hook();

        assert_eq!(hook.next_value().await.unwrap().get(), "hello world!");
        assert!(hook.next_value().await.is_none());
    },
    {
        hook_fn!(
            type Bounds = impl 'a;
            fn use_borrow_mut<'a, T: Default>(values: &'a mut Vec<T>) {
                values.push(T::default())
            }
        );

        let mut values = vec![];

        let results = use_borrow_mut::<String>(&mut values)
            .into_hook_values()
            .collect::<Vec<_>>()
            .await;

        assert_eq!(results, [()]);
        assert_eq!(values, [""]);
    },
));