bun_css 0.1.0

A Rust-native programmable browser runtime built on Servo and SpiderMonkey
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

use crate::css_parser as css;
use crate::css_parser::{CssResult as Result, Maybe, Parser, PrintErr, Printer, Token};
use crate::values::number::CSSNumber;

/// A CSS `<resolution>` value.
#[derive(
    Clone,
    Copy,
    Debug,
    PartialEq,
    crate::generics::CssEql,
    crate::generics::CssHash,
    crate::generics::DeepClone,
)]
pub enum Resolution {
    /// A resolution in dots per inch.
    Dpi(CSSNumber),
    /// A resolution in dots per centimeter.
    Dpcm(CSSNumber),
    /// A resolution in dots per px.
    Dppx(CSSNumber),
}

// ~toCssImpl

impl Resolution {
    // css.implementHash / css.implementEql — provided by
    // `#[derive(CssHash, CssEql)]` above (f32-payload enum).

    pub(crate) fn parse(input: &mut Parser) -> Result<Resolution> {
        // TODO: calc?
        let location = input.current_source_location();
        let tok = input.next()?.clone();
        if let Token::Dimension(dim) = &tok {
            let value = dim.num.value;
            let unit = dim.unit;
            return crate::match_ignore_ascii_case! { unit, {
                b"dpi" => Ok(Resolution::Dpi(value)),
                b"dpcm" => Ok(Resolution::Dpcm(value)),
                b"dppx" | b"x" => Ok(Resolution::Dppx(value)),
                _ => Err(location.new_unexpected_token_error(Token::Ident(unit))),
            }};
        }
        Err(location.new_unexpected_token_error(tok))
    }

    pub(crate) fn try_from_token(token: &Token) -> Maybe<Resolution, ()> {
        match token {
            Token::Dimension(dim) => {
                let value = dim.num.value;
                let unit = dim.unit;
                crate::match_ignore_ascii_case! { unit, {
                    b"dpi" => Ok(Resolution::Dpi(value)),
                    b"dpcm" => Ok(Resolution::Dpcm(value)),
                    b"dppx" | b"x" => Ok(Resolution::Dppx(value)),
                    _ => Err(()),
                }}
            }
            _ => Err(()),
        }
    }

    pub(crate) fn to_css(self, dest: &mut Printer) -> core::result::Result<(), PrintErr> {
        let (value, unit): (CSSNumber, &'static [u8]) = match self {
            Resolution::Dpi(dpi) => (dpi, b"dpi".as_slice()),
            Resolution::Dpcm(dpcm) => (dpcm, b"dpcm".as_slice()),
            Resolution::Dppx(dppx) => {
                if dest
                    .targets
                    .is_compatible(crate::compat::Feature::XResolutionUnit)
                {
                    (dppx, b"x".as_slice())
                } else {
                    (dppx, b"dppx".as_slice())
                }
            }
        };

        css::serializer::serialize_dimension(value, unit, dest)
    }

    pub(crate) fn add_f32(self, other: f32) -> Resolution {
        match self {
            Resolution::Dpi(dpi) => Resolution::Dpi(dpi + other),
            Resolution::Dpcm(dpcm) => Resolution::Dpcm(dpcm + other),
            Resolution::Dppx(dppx) => Resolution::Dppx(dppx + other),
        }
    }
}

// ported from: src/css/values/resolution.zig