euv-ui 0.32.6

Reusable UI component library for the euv framework, providing buttons, cards, modals, inputs, 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
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

use super::*;

/// A toast stack pinned to the top centre of the viewport.
///
/// The component is purely presentational: it renders the messages it is
/// given and reports the clicks through the item callbacks. It owns no
/// queue and starts no timers, so the auto-dismiss timing stays with the
/// caller — `use_timer` or `App::use_interval` — and the rendered tree
/// stays deterministic and testable. The stack container is always
/// mounted, even when `items` is empty, so a caller can push messages in
/// without remounting the component.
///
/// # Arguments
///
/// - `VirtualNode<EuvMessageProps>` - The props node containing the messages.
///
/// # Returns
///
/// - `VirtualNode` - The message stack virtual DOM tree.
#[component]
pub fn euv_message(node: VirtualNode<EuvMessageProps>) -> VirtualNode {
    let EuvMessageProps { items }: EuvMessageProps = node.try_get_props().unwrap_or_default();
    let messages: Vec<VirtualNode> = items
        .into_iter()
        .enumerate()
        .map(
            |(index, item): (usize, message::view::r#struct::EuvMessageItem)| {
                euv_message_item(index, item)
            },
        )
        .collect();
    html! {
        div {
            class: c_euv_message_stack()
            messages
        }
    }
}

/// Renders one message: its text, the optional action and the optional close button.
///
/// # Arguments
///
/// - `usize` - The index of the message in the stack, used as the diff key.
/// - `EuvMessageItem` - The message to render, consumed.
///
/// # Returns
///
/// - `VirtualNode` - The message virtual DOM tree.
fn euv_message_item(index: usize, item: EuvMessageItem) -> VirtualNode {
    let EuvMessageItem {
        text,
        action_label,
        on_action,
        on_close,
        dismissible,
    }: EuvMessageItem = item;
    let has_action: bool = !action_label.is_empty();
    let is_dismissible: bool = dismissible || on_close.is_some();
    let action_handler: Option<Rc<dyn Fn(Event)>> = message_callback_handler(on_action);
    let close_handler: Option<Rc<dyn Fn(Event)>> = message_callback_handler(on_close);
    html! {
        div {
            key: index.to_string()
            class: c_euv_message()
            div {
                class: c_euv_message_text()
                text
            }
            if has_action {
                button {
                    class: c_euv_message_action()
                    onclick: action_handler
                    action_label
                }
            }
            if is_dismissible {
                button {
                    class: c_euv_message_close()
                    onclick: close_handler
                    "×"
                }
            }
        }
    }
}

/// Builds the click handler that fires a caller's message callback.
///
/// The event type is a parameter so the DOM-free test suite can drive the
/// handler with a stand-in event; the component always instantiates it
/// with [`Event`].
///
/// # Arguments
///
/// - `Option<Rc<dyn Fn()>>` - The callback fired by the handler.
///
/// # Returns
///
/// - `Option<Rc<dyn Fn(E)>>` - The click handler, or `None` when there is no callback.
pub fn message_callback_handler<E: 'static>(
    callback: Option<Rc<dyn Fn()>>,
) -> Option<Rc<dyn Fn(E)>> {
    callback.map(|handler: Rc<dyn Fn()>| -> Rc<dyn Fn(E)> {
        Rc::new(move |_: E| {
            handler();
        })
    })
}