icons 0.7.2

Icons for Rust fullstack applications — Leptos and Dioxus.
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

use leptos::either::EitherOf7;
use leptos::prelude::*;

use crate::common::static_svg_element::StaticSvgElement;

impl StaticSvgElement {
    /// Convert StaticSvgElement to Leptos view with zero allocations
    ///
    /// All data is already static, so no runtime processing or allocation needed.
    pub fn to_leptos_view(&self) -> impl IntoView + use<> {
        match self {
            StaticSvgElement::Path { d } => EitherOf7::A(view! { <path d=*d /> }),
            StaticSvgElement::Circle { cx, cy, r } => EitherOf7::B(view! { <circle cx=*cx cy=*cy r=*r /> }),
            StaticSvgElement::Rect { x, y, width, height, rx, ry } => EitherOf7::C(match (rx, ry) {
                (Some(rx), Some(ry)) => view! { <rect x=*x y=*y width=*width height=*height rx=*rx ry=*ry /> },
                (Some(rx), None) => view! { <rect x=*x y=*y width=*width height=*height rx=*rx /> },
                (None, Some(ry)) => view! { <rect x=*x y=*y width=*width height=*height ry=*ry /> },
                (None, None) => view! { <rect x=*x y=*y width=*width height=*height /> },
            }),
            StaticSvgElement::Ellipse { cx, cy, rx, ry } => {
                EitherOf7::D(view! { <ellipse cx=*cx cy=*cy rx=*rx ry=*ry /> })
            }
            StaticSvgElement::Line { x1, y1, x2, y2 } => EitherOf7::E(view! { <line x1=*x1 y1=*y1 x2=*x2 y2=*y2 /> }),
            StaticSvgElement::Polyline { points } => EitherOf7::F(view! { <polyline points=*points /> }),
            StaticSvgElement::Polygon { points } => EitherOf7::G(view! { <polygon points=*points /> }),
        }
    }
}

/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/*                        🧪 TESTS 🧪                         */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_static_svg_element_path_creation() {
        let path = StaticSvgElement::Path { d: "M10 10 L20 20" };

        match path {
            StaticSvgElement::Path { d } => assert_eq!(d, "M10 10 L20 20"),
            _ => panic!("Expected Path variant"),
        }
    }

    #[test]
    fn test_static_svg_element_circle_creation() {
        let circle = StaticSvgElement::Circle { cx: "10", cy: "20", r: "5" };

        match circle {
            StaticSvgElement::Circle { cx, cy, r } => {
                assert_eq!(cx, "10");
                assert_eq!(cy, "20");
                assert_eq!(r, "5");
            }
            _ => panic!("Expected Circle variant"),
        }
    }

    #[test]
    fn test_static_svg_element_rect_with_rx_ry() {
        let rect = StaticSvgElement::Rect { x: "0", y: "0", width: "50", height: "50", rx: Some("5"), ry: Some("10") };

        match rect {
            StaticSvgElement::Rect { x, y, width, height, rx, ry } => {
                assert_eq!(x, "0");
                assert_eq!(y, "0");
                assert_eq!(width, "50");
                assert_eq!(height, "50");
                assert_eq!(rx, Some("5"));
                assert_eq!(ry, Some("10"));
            }
            _ => panic!("Expected Rect variant"),
        }
    }

    #[test]
    fn test_static_svg_element_zero_allocation() {
        // Verify that StaticSvgElement doesn't allocate
        let path = StaticSvgElement::Path { d: "M0 0 L10 10" };
        let circle = StaticSvgElement::Circle { cx: "5", cy: "5", r: "3" };

        // These should all be stack allocated with static string references
        match path {
            StaticSvgElement::Path { d } => {
                // Verify d is a static string reference
                assert_eq!(d, "M0 0 L10 10");
                // The pointer should be stable (pointing to static data)
                let ptr1 = d.as_ptr();
                let ptr2 = "M0 0 L10 10".as_ptr();
                assert_eq!(ptr1, ptr2);
            }
            _ => panic!("Expected Path"),
        }

        match circle {
            StaticSvgElement::Circle { cx, cy, r } => {
                assert_eq!(cx, "5");
                assert_eq!(cy, "5");
                assert_eq!(r, "3");
            }
            _ => panic!("Expected Circle"),
        }
    }

    #[test]
    fn test_static_svg_element_copy_trait() {
        let path = StaticSvgElement::Path { d: "M1 1 L2 2" };

        // Should be Copy (no allocation)
        let path_copy = path;

        match path_copy {
            StaticSvgElement::Path { d } => assert_eq!(d, "M1 1 L2 2"),
            _ => panic!("Expected Path"),
        }

        // Original should still be valid
        match path {
            StaticSvgElement::Path { d } => assert_eq!(d, "M1 1 L2 2"),
            _ => panic!("Expected Path"),
        }
    }
}