blinc_cn 0.6.0

Blinc Component Library - shadcn-style themed components built on blinc_layout primitives
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

//! Charts: data drawn on a canvas, with the axes, legend and tooltip as
//! ordinary elements over and under it.
//!
//! Line, area and bar charts, sparklines, threshold charts, histograms and
//! comparisons share one plot; pies have their own. Moving the pointer
//! across a chart marks the category under it and shows its values there; data given as a
//! Signal or Computed is followed, the drawing easing from the old values to
//! the new. Series take `--chart-1` to `--chart-5` in turn; the grid, cursor
//! and dot rings take `--cn-chart-grid`, `--cn-chart-cursor` and
//! `--cn-chart-surface`; the parts are `.cn-chart*` rules.
//!
//! ```ignore
//! cn::line_chart()
//!     .series("CPU", &[30.0, 45.0, 40.0, 60.0])
//!     .series("Memory", &[20.0, 25.0, 30.0, 35.0])
//!     .labels(vec!["1".into(), "2".into(), "3".into(), "4".into()])
//!     .dots()
//!
//! cn::area_chart().data(visitors).stacked()
//! ```

mod ease;
mod extras;
mod math;
mod pie;
mod plot;
mod view;

pub use extras::{
    ComparisonBuilder, ComparisonItem, HistogramBuilder, comparison_bar_chart, histogram,
    spark_line, threshold_line_chart,
};
pub use pie::{PieBuilder, PieSlice, pie_chart};
pub use view::{ChartBuilder, area_chart, bar_chart, line_chart};

/// A named series with one value per category label.
#[derive(Clone, Debug, PartialEq)]
pub struct ChartSeries {
    pub name: String,
    pub values: Vec<f64>,
    /// Any CSS colour, `var(..)` included; the next palette colour if unset.
    pub color: Option<String>,
}

impl ChartSeries {
    pub fn new(name: impl Into<String>, values: impl Into<Vec<f64>>) -> Self {
        Self {
            name: name.into(),
            values: values.into(),
            color: None,
        }
    }

    /// Its own colour, any CSS colour, in place of the palette's.
    pub fn color(mut self, css: impl Into<String>) -> Self {
        self.color = Some(css.into());
        self
    }
}

/// A value range shaded behind a chart, such as a budget.
#[derive(Clone, Debug, PartialEq)]
pub struct ChartBand {
    pub from: f64,
    pub to: f64,
    /// Any CSS colour; good, warning and bad in turn if unset.
    pub color: Option<String>,
    /// Written at the band's top right.
    pub label: Option<String>,
}

impl ChartBand {
    pub fn new(from: f64, to: f64) -> Self {
        Self {
            from,
            to,
            color: None,
            label: None,
        }
    }

    pub fn label(mut self, label: impl Into<String>) -> Self {
        self.label = Some(label.into());
        self
    }

    pub fn color(mut self, css: impl Into<String>) -> Self {
        self.color = Some(css.into());
        self
    }
}

/// A dashed reference line at a value, such as a target or a noise floor.
#[derive(Clone, Debug, PartialEq)]
pub struct ChartMarker {
    pub value: f64,
    /// Any CSS colour; the cursor's if unset.
    pub color: Option<String>,
}

impl ChartMarker {
    pub fn new(value: f64) -> Self {
        Self { value, color: None }
    }

    pub fn color(mut self, css: impl Into<String>) -> Self {
        self.color = Some(css.into());
        self
    }
}

/// How a line goes from one value to the next.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ChartCurve {
    /// Straight segments.
    Linear,
    /// A smooth curve that never overshoots a value.
    #[default]
    Smooth,
    /// Level, stepping at each value.
    Step,
}