daisy_rsx 0.1.37

Daisy UI components for the Dioxus Rust library.
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
134
135
136
137
138
139
140

#![allow(non_snake_case)]
use std::fmt::Display;

use dioxus::prelude::*;

#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
pub enum SelectSize {
    #[default]
    Default,
    Small,
    ExtraSmall,
    Large,
    Medium,
}

impl Display for SelectSize {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SelectSize::Default => write!(f, ""),
            SelectSize::Small => write!(f, "select-sm"),
            SelectSize::ExtraSmall => write!(f, "select-xs"),
            SelectSize::Large => write!(f, "select-lg"),
            SelectSize::Medium => write!(f, "select-md"),
        }
    }
}

#[derive(Props, Clone, PartialEq)]
pub struct SelectProps {
    children: Element,
    select_size: Option<SelectSize>,
    pub name: String,
    pub id: Option<String>,
    pub value: Option<String>,
    pub label: Option<String>,
    pub label_class: Option<String>,
    pub help_text: Option<String>,
    pub required: Option<bool>,
    pub disabled: Option<bool>,
    pub multiple: Option<bool>,
}

#[component]
pub fn Select(props: SelectProps) -> Element {
    let select_size = props.select_size.unwrap_or_default();
    let value = props.value.unwrap_or_default();
    let disabled = props.disabled.filter(|&d| d);

    rsx!(
        match props.label {
            Some(l) => rsx! {
                label { class: props.label_class, "{l}" }
            },
            None => rsx! {},
        }
        select {
            id: props.id,
            required: props.required,
            disabled,
            multiple: props.multiple,
            class: "select select-bordered {select_size}",
            value: "{value}",
            name: "{props.name}",
            {props.children}
        }
        match props.help_text {
            Some(l) => rsx! {
                label { class: "label-text-alt",
                    span { "{l}" }
                }
            },
            None => rsx! {},
        }
    )
}

#[derive(Props, Clone, PartialEq)]
pub struct OptionProps {
    children: Element,
    pub value: String,
    pub selected_value: Option<String>,
}

#[component]
pub fn SelectOption(props: OptionProps) -> Element {
    rsx!(
        option {
            value: props.value.clone(),
            selected: props.selected_value.as_ref().map_or(false, |s| s == &props.value),
            {props.children}
        }
    )
}

#[test]
fn test_select_option() {
    let props = OptionProps {
        value: "test".to_string(),
        selected_value: Some("test".to_string()),
        children: rsx!( "Hello" ),
    };

    let expected = r#"<option value="test" selected=true>Hello</option>"#;
    let result = dioxus_ssr::render_element(SelectOption(props));
    // println!("{}", result);
    assert_eq!(expected, result);
}

#[test]
fn test_select() {
    let props = SelectProps {
        children: rsx! {
            SelectOption {
                value: "test".to_string(),
                selected_value: Some("test".to_string()),
                children: rsx! { "Hello" },
            }
            SelectOption {
                value: "test2".to_string(),
                selected_value: Some("test".to_string()),
                children: rsx! { "Hello2" },
            }
        },
        select_size: Some(SelectSize::Large),
        name: "test".to_string(),
        id: Some("test".to_string()),
        value: Some("test".to_string()),
        label: Some("test".to_string()),
        label_class: Some("test".to_string()),
        help_text: Some("test".to_string()),
        required: Some(true),
        disabled: Some(false),
        multiple: Some(false),
    };

    let expected = r#"<label class="test">test</label><select id="test" required=true class="select select-bordered select-lg" value="test" name="test"><option value="test" selected=true>Hello</option><option value="test2">Hello2</option></select><label class="label-text-alt"><span>test</span></label>"#;
    let result = dioxus_ssr::render_element(Select(props));
    // println!("{}", result);
    assert_eq!(expected, result);
}