consecuit 0.2.0

A functional web UI framework that uses the type system for hooks and more
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

use std::cell::RefCell;

use crate::stores::{StoreCons, StoreConsEnd, StoresList};

use super::{
    component::{ComponentBuilder, ComponentConstruction},
    hole::{MaybeHoleNode, NoHoleNode, YesHoleNode},
    hook::HookConstruction,
    subtree::Subtree,
};

/// Use `impl ComponentReturn` as return type for components.
/// See the docs at [crate] for more information on how to write components.
/// This trait is sealed.
#[sealed::sealed]
pub trait ComponentReturn: 'static {
    type StoresList: StoresList;
    type HoleNode: MaybeHoleNode;
    fn get_node(self) -> Self::HoleNode;
}

/// Use `impl ContainerReturn` as return type for components with hole.
/// See the docs at [crate] for more information on how to write components.
/// This trait is sealed.
#[sealed::sealed]
pub trait ContainerReturn: ComponentReturn<HoleNode = YesHoleNode> {}

#[sealed::sealed]
impl<Stores: StoresList, LastNode: MaybeHoleNode, HoleNode: MaybeHoleNode> ComponentReturn
    for ComponentConstruction<StoreConsEnd, Stores, LastNode, HoleNode>
{
    type StoresList = Stores;
    type HoleNode = HoleNode;
    fn get_node(self) -> Self::HoleNode {
        self.ret_node
    }
}
#[sealed::sealed]
impl<T: ComponentReturn<HoleNode = YesHoleNode>> ContainerReturn for T {}

/// An alias for [PartialEq] + [Clone] + `'static`. Sealed.
#[sealed::sealed]
pub trait ComponentProps: PartialEq + Clone + 'static {}
#[sealed::sealed]
impl<T: PartialEq + Clone + 'static> ComponentProps for T {}

pub type ComponentFunc<Ret, Props> = fn(ComponentBuilder, Props) -> Ret;

/** An alias for when you really need to name the concrete return type of your component.

See [.dyn_comp()] in [ComponentConstruction] for how to create a component with concrete return type.

 */
pub type DynComponentReturn<Props> = ComponentConstruction<
    StoreConsEnd,
    StoreCons<RefCell<Option<Box<dyn Subtree<Props = Props>>>>, StoreConsEnd>,
    NoHoleNode,
    NoHoleNode,
>;

/// Use `impl HookReturn<the value>` as return type for hooks.
/// See the docs at [crate] for more information on how to write hooks.
/// This trait is sealed.
#[sealed::sealed]
pub trait HookReturn<Value> {
    type StoresList: StoresList;
    fn get_val(self) -> Value;
}

#[sealed::sealed]
impl<UsedStores, Value> HookReturn<Value> for (HookConstruction<StoreConsEnd, UsedStores>, Value)
where
    UsedStores: StoresList,
{
    type StoresList = UsedStores;
    fn get_val(self) -> Value {
        self.1
    }
}