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

use leptos::*;
use std::cmp::Ordering;
use std::ops::DerefMut;

/// Reactive sort of iterable
///
/// ## Demo
///
/// [Link to Demo](https://github.com/Synphonyte/leptos-use/tree/main/examples/use_sorted)
///
/// ## Usage
///
/// ```
/// # use leptos::*;
/// # use leptos_use::use_sorted;
/// #
/// # #[component]
/// # fn Demo() -> impl IntoView {
/// let source = vec![10, 3, 5, 7, 2, 1, 8, 6, 9, 4];
/// let sorted = use_sorted(source); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
/// #
/// # view! { }
/// # }
/// ```
///
/// You can also sort by key or with a compare function.
///
/// ```
/// # use leptos::*;
/// # use leptos_use::{use_sorted_by, use_sorted_by_key};
/// #
/// #[derive(Clone, PartialEq)]
/// pub struct Person {
///     pub name: String,
///     pub age: u16,
/// }
///
/// # #[component]
/// # fn Demo() -> impl IntoView {
/// let source = vec![
///     Person {
///         name: "John".to_string(),
///         age: 40,
///     },
///     Person {
///         name: "Jane".to_string(),
///         age: 20,
///     },
///     Person {
///         name: "Joe".to_string(),
///         age: 30,
///     },
///     Person {
///         name: "Jenny".to_string(),
///         age: 22,
///     },
/// ];
///
/// // sort by key
/// let sorted = use_sorted_by_key(
///     source.clone(),
///     |person| person.age,
/// );
///
/// // sort with compare function
/// let sorted = use_sorted_by(
///     source,
///     |p1, p2| p1.age.cmp(&p2.age),
/// );
/// #
/// # view! { }
/// # }
/// ```
///
/// Please note that these two ways of sorting are equivalent.
pub fn use_sorted<S, I, T>(iterable: S) -> Signal<I>
where
    S: Into<MaybeSignal<I>>,
    T: Ord,
    I: DerefMut<Target = [T]> + Clone + PartialEq,
{
    let iterable = iterable.into();

    Signal::derive(move || {
        let mut iterable = iterable.get();
        iterable.sort();
        iterable
    })
}

/// Version of [`use_sorted`] with a compare function.
pub fn use_sorted_by<S, I, T, F>(iterable: S, cmp_fn: F) -> Signal<I>
where
    S: Into<MaybeSignal<I>>,
    I: DerefMut<Target = [T]> + Clone + PartialEq,
    F: FnMut(&T, &T) -> Ordering + Clone + 'static,
{
    let iterable = iterable.into();

    Signal::derive(move || {
        let mut iterable = iterable.get();
        iterable.sort_by(cmp_fn.clone());
        iterable
    })
}

/// Version of [`use_sorted`] by key.
pub fn use_sorted_by_key<S, I, T, K, F>(iterable: S, key_fn: F) -> Signal<I>
where
    S: Into<MaybeSignal<I>>,
    I: DerefMut<Target = [T]> + Clone + PartialEq,
    K: Ord,
    F: FnMut(&T) -> K + Clone + 'static,
{
    let iterable = iterable.into();

    Signal::derive(move || {
        let mut iterable = iterable.get();
        iterable.sort_by_key(key_fn.clone());
        iterable
    })
}