use-type-rhythm 0.0.1

Primitive type-rhythm helpers
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

#![forbid(unsafe_code)]
//! Primitive vertical rhythm helpers.
//!
//! These helpers expose a small baseline grid model for deterministic layout
//! calculations.
//!
//! # Examples
//!
//! ```rust
//! use use_type_rhythm::{TypeRhythm, baseline_grid, snap_to_baseline};
//!
//! let rhythm = TypeRhythm::new(16.0, 24.0).unwrap();
//!
//! assert_eq!(rhythm.baseline_unit(), 24.0);
//! assert_eq!(rhythm.snap_to_baseline(37.0).unwrap(), 48.0);
//! assert_eq!(rhythm.lines_for_height(72.0).unwrap(), 3.0);
//! assert_eq!(baseline_grid(24.0, 3).unwrap(), vec![24.0, 48.0, 72.0]);
//! assert_eq!(snap_to_baseline(37.0, 24.0).unwrap(), 48.0);
//! ```

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TypeRhythm {
    base_font_size_px: f64,
    base_line_height_px: f64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TypeRhythmError {
    InvalidFontSize,
    InvalidLineHeight,
    InvalidValue,
}

fn validate_positive(value: f64, error: TypeRhythmError) -> Result<f64, TypeRhythmError> {
    if !value.is_finite() || value <= 0.0 {
        Err(error)
    } else {
        Ok(value)
    }
}

fn validate_non_negative(value: f64, error: TypeRhythmError) -> Result<f64, TypeRhythmError> {
    if !value.is_finite() || value < 0.0 {
        Err(error)
    } else {
        Ok(value)
    }
}

impl TypeRhythm {
    pub fn new(base_font_size_px: f64, base_line_height_px: f64) -> Result<Self, TypeRhythmError> {
        Ok(Self {
            base_font_size_px: validate_positive(
                base_font_size_px,
                TypeRhythmError::InvalidFontSize,
            )?,
            base_line_height_px: validate_positive(
                base_line_height_px,
                TypeRhythmError::InvalidLineHeight,
            )?,
        })
    }

    #[must_use]
    pub fn baseline_unit(&self) -> f64 {
        let _ = self.base_font_size_px;
        self.base_line_height_px
    }

    pub fn snap_to_baseline(&self, value_px: f64) -> Result<f64, TypeRhythmError> {
        snap_to_baseline(value_px, self.base_line_height_px)
    }

    pub fn lines_for_height(&self, height_px: f64) -> Result<f64, TypeRhythmError> {
        Ok(
            validate_non_negative(height_px, TypeRhythmError::InvalidValue)?
                / self.base_line_height_px,
        )
    }
}

pub fn baseline_grid(base_line_height_px: f64, lines: usize) -> Result<Vec<f64>, TypeRhythmError> {
    let base_line_height_px =
        validate_positive(base_line_height_px, TypeRhythmError::InvalidLineHeight)?;

    Ok((1..=lines)
        .map(|line| (line as f64) * base_line_height_px)
        .collect())
}

pub fn snap_to_baseline(value_px: f64, base_line_height_px: f64) -> Result<f64, TypeRhythmError> {
    let value_px = validate_non_negative(value_px, TypeRhythmError::InvalidValue)?;
    let base_line_height_px =
        validate_positive(base_line_height_px, TypeRhythmError::InvalidLineHeight)?;

    Ok((value_px / base_line_height_px).round() * base_line_height_px)
}

#[cfg(test)]
mod tests {
    use super::{TypeRhythm, TypeRhythmError, baseline_grid, snap_to_baseline};

    #[test]
    fn generates_baseline_grid_values() {
        let rhythm = TypeRhythm::new(16.0, 24.0).unwrap();

        assert_eq!(rhythm.baseline_unit(), 24.0);
        assert_eq!(rhythm.snap_to_baseline(37.0).unwrap(), 48.0);
        assert_eq!(rhythm.lines_for_height(72.0).unwrap(), 3.0);
        assert_eq!(baseline_grid(24.0, 3).unwrap(), vec![24.0, 48.0, 72.0]);
        assert_eq!(snap_to_baseline(37.0, 24.0).unwrap(), 48.0);
    }

    #[test]
    fn rejects_invalid_rhythm_inputs() {
        assert_eq!(
            TypeRhythm::new(0.0, 24.0),
            Err(TypeRhythmError::InvalidFontSize)
        );
        assert_eq!(
            baseline_grid(0.0, 3),
            Err(TypeRhythmError::InvalidLineHeight)
        );
        assert_eq!(
            snap_to_baseline(-1.0, 24.0),
            Err(TypeRhythmError::InvalidValue)
        );
        assert_eq!(
            TypeRhythm::new(16.0, 24.0)
                .unwrap()
                .lines_for_height(f64::NAN),
            Err(TypeRhythmError::InvalidValue)
        );
    }
}