thaw 0.4.8

An easy to use leptos component 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

use leptos::{either::Either, prelude::*};
use thaw_utils::{class_list, mount_style};

#[component]
pub fn Badge(
    #[prop(optional, into)] class: MaybeProp<String>,
    /// A Badge can be filled, outline, ghost, inverted.
    #[prop(optional, into)]
    appearance: Signal<BadgeAppearance>,
    /// A Badge can be on of several preset sizes.
    #[prop(optional, into)]
    size: Signal<BadgeSize>,
    /// A Badge can be one of preset colors.
    #[prop(optional, into)]
    color: Signal<BadgeColor>,
    #[prop(optional)] children: Option<Children>,
) -> impl IntoView {
    mount_style("badge", include_str!("./badge.css"));

    view! {
        <div class=class_list![
            "thaw-badge",
            move || format!("thaw-badge--{}", appearance.get().as_str()),
            move || format!("thaw-badge--{}", size.get().as_str()),
            move || format!("thaw-badge--{}", color.get().as_str()),
            class
        ]>
            {if let Some(children) = children {
                Either::Left(children())
            } else {
                Either::Right(())
            }}
        </div>
    }
}

#[derive(Default, Clone)]
pub enum BadgeAppearance {
    #[default]
    Filled,
    Ghost,
    Outline,
    Tint,
}

impl BadgeAppearance {
    pub fn as_str(&self) -> &'static str {
        match self {
            BadgeAppearance::Filled => "filled",
            BadgeAppearance::Ghost => "ghost",
            BadgeAppearance::Outline => "outline",
            BadgeAppearance::Tint => "tint",
        }
    }
}

#[derive(Default, Clone)]
pub enum BadgeSize {
    Tiny,
    ExtraSmall,
    Small,
    #[default]
    Medium,
    Large,
    ExtraLarge,
}

impl BadgeSize {
    pub fn as_str(&self) -> &'static str {
        match self {
            BadgeSize::Tiny => "tiny",
            BadgeSize::ExtraSmall => "extra-small",
            BadgeSize::Small => "small",
            BadgeSize::Medium => "medium",
            BadgeSize::Large => "large",
            BadgeSize::ExtraLarge => "extra-large",
        }
    }
}

#[derive(Default, Clone)]
pub enum BadgeColor {
    #[default]
    Brand,
    Danger,
    Important,
    Informative,
    Severe,
    Subtle,
    Success,
    Warning,
}

impl BadgeColor {
    pub fn as_str(&self) -> &'static str {
        match self {
            BadgeColor::Brand => "brand",
            BadgeColor::Danger => "danger",
            BadgeColor::Important => "important",
            BadgeColor::Informative => "informative",
            BadgeColor::Severe => "severe",
            BadgeColor::Subtle => "subtle",
            BadgeColor::Success => "success",
            BadgeColor::Warning => "warning",
        }
    }
}