gpui-component 0.5.1

UI components for building fantastic desktop application by using GPUI.
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

// @reference: https://d3js.org/d3-scale/ordinal

#[derive(Clone)]
pub struct ScaleOrdinal<D, R> {
    domain: Vec<D>,
    range: Vec<R>,
    unknown: Option<R>,
}

impl<D, R> Default for ScaleOrdinal<D, R> {
    fn default() -> Self {
        Self {
            domain: Vec::new(),
            range: Vec::new(),
            unknown: None,
        }
    }
}

impl<D, R> ScaleOrdinal<D, R> {
    pub fn new(domain: Vec<D>, range: Vec<R>) -> Self {
        Self {
            domain,
            range,
            unknown: None,
        }
    }

    /// Set the domain to the specified array of values.
    pub fn domain(mut self, domain: Vec<D>) -> Self {
        self.domain = domain;
        self
    }

    /// Set the range of the ordinal scale to the specified array of values.
    pub fn range(mut self, range: Vec<R>) -> Self {
        self.range = range;
        self
    }

    /// Set the output value of the scale for unknown input values and returns this scale.
    pub fn unknown(mut self, unknown: R) -> Self {
        self.unknown = Some(unknown);
        self
    }
}

impl<D, R> ScaleOrdinal<D, R>
where
    D: PartialEq,
    R: Clone,
{
    /// Given a value in the input domain, returns the corresponding value in the output range.
    pub fn map(&self, value: &D) -> Option<R> {
        if let Some(index) = self.domain.iter().position(|v| v == value) {
            if self.range.is_empty() {
                None
            } else {
                Some(self.range[index % self.range.len()].clone())
            }
        } else {
            self.unknown.clone()
        }
    }
}

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

    #[test]
    fn test_scale_ordinal() {
        let scale = ScaleOrdinal::new(vec!["a", "b", "c", "d", "e"], vec![10, 20, 30]);

        assert_eq!(scale.map(&"a"), Some(10));
        assert_eq!(scale.map(&"b"), Some(20));
        assert_eq!(scale.map(&"c"), Some(30));
        assert_eq!(scale.map(&"d"), Some(10));
        assert_eq!(scale.map(&"e"), Some(20));
        assert_eq!(scale.map(&"f"), None);
    }

    #[test]
    fn test_scale_ordinal_unknown() {
        let scale = ScaleOrdinal::new(vec!["a", "b", "c"], vec![10, 20, 30]).unknown(0);

        assert_eq!(scale.map(&"a"), Some(10));
        assert_eq!(scale.map(&"f"), Some(0));
    }

    #[test]
    fn test_scale_ordinal_colors() {
        let keys = vec!["a", "b", "c", "d"];
        let colors = vec!["#1f77b4", "#ff7f0e", "#2ca02c"];

        let scale = ScaleOrdinal::new(keys, colors);

        assert_eq!(scale.map(&"a"), Some("#1f77b4"));
        assert_eq!(scale.map(&"b"), Some("#ff7f0e"));
        assert_eq!(scale.map(&"c"), Some("#2ca02c"));
        // Should cycle back to the first color
        assert_eq!(scale.map(&"d"), Some("#1f77b4"));
    }
}