leptos_forge_utils_leptos 0.6.3

Little utilities to use together with Leptos
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
141
142
143
144
145
146
147
148

//! Contains some useful utilities not covered by `use_leptos`
//!

use std::fmt::Debug;

use leptos::leptos_dom::logging::console_log;
use leptos_use::core::ElementMaybeSignal;
use leptos_use::core::IntoElementMaybeSignal;
use reactive_graph::traits::GetUntracked;
use web_sys::DomTokenList;
use web_sys::Element;

/// Trait which allows a various types to be treated as a CSS class
///
/// Mostly for convenience so we can add and remove multiple classes in single step
pub trait ToClassDef: Debug {
    /// remove the classes from the element class list
    fn remove(self, class_list: &DomTokenList);
    /// add the classes to the element class list
    fn add(self, class_list: &DomTokenList);
}

impl ToClassDef for () {
    fn add(self, _class_list: &DomTokenList) {}
    fn remove(self, _class_list: &DomTokenList) {}
}

impl ToClassDef for &str {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_1(self);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_1(self);
    }
}

impl ToClassDef for String {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_1(&self);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_1(&self);
    }
}

impl ToClassDef for (&str,) {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_1(self.0);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_1(self.0);
    }
}

impl ToClassDef for (&str, &str) {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_2(self.0, self.1);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_2(self.0, self.1);
    }
}

impl ToClassDef for (&str, &str, &str) {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_3(self.0, self.1, self.2);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_3(self.0, self.1, self.2);
    }
}

impl ToClassDef for (&str, &str, &str, &str) {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_4(self.0, self.1, self.2, self.3);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_4(self.0, self.1, self.2, self.3);
    }
}

impl ToClassDef for (&str, &str, &str, &str, &str) {
    fn add(self, class_list: &DomTokenList) {
        let _ = class_list.add_5(self.0, self.1, self.2, self.3, self.4);
    }

    fn remove(self, class_list: &DomTokenList) {
        let _ = class_list.remove_5(self.0, self.1, self.2, self.3, self.4);
    }
}

/// Switches a class/classes for an element
///
/// To be exact it adds one class while removing the other.
pub fn use_swap_class<E, M, C1, C2>(target: E, remove_class: C1, add_class: C2)
where
    E: IntoElementMaybeSignal<Element, M>,
    M: ?Sized,
    C1: ToClassDef,
    C2: ToClassDef,
{
    let target: ElementMaybeSignal<Element> = target.into_element_maybe_signal();
    if let Some(node) = target.get_untracked() {
        let class_list = node.class_list();
        remove_class.remove(&class_list);
        add_class.add(&class_list);
    }
}

/// Adds class/classes to the class list
pub fn use_add_class<E, M, C>(target: E, add_class: C)
where
    E: IntoElementMaybeSignal<Element, M>,
    M: ?Sized,
    C: ToClassDef,
{
    let target = target.into_element_maybe_signal();
    if let Some(node) = target.get_untracked() {
        console_log(&format!("Adding classes {add_class:#?} to the element"));
        let class_list = node.class_list();
        add_class.add(&class_list);
    } else {
        console_log("Adding class skipped, no element in reference");
    }
}

/// Removes class/classes from the class list
pub fn use_remove_class<E, M, C>(target: E, remove_class: C)
where
    E: IntoElementMaybeSignal<Element, M>,
    M: ?Sized,
    C: ToClassDef,
{
    let target = target.into_element_maybe_signal();
    if let Some(node) = target.get_untracked() {
        console_log(&format!(
            "Removing classes {remove_class:#?} to the element"
        ));
        let class_list = node.class_list();
        remove_class.remove(&class_list);
    }
}