peacock-crest 0.1.0

A CSS library for parsing and applying styles to in-memory DOM structures
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

use std::collections::HashMap;

use super::prop_validation::{self, types, CssAttributeValue, CssStyleAttribute};
use crate::unit::Unit;

#[derive(Debug, Clone)]
pub enum CssStyleProperty {
    Color(CssAttributeValue<types::CssColor>),
    BackgroundColor(CssAttributeValue<types::CssBackgroundColor>),

    Width(CssAttributeValue<types::CssWidth>),
    Height(CssAttributeValue<types::CssHeight>),

    Padding(
        CssAttributeValue<types::CssPadding>,
        CssAttributeValue<types::CssPadding>,
        CssAttributeValue<types::CssPadding>,
        CssAttributeValue<types::CssPadding>,
    ),

    Spacing(
        CssAttributeValue<types::CssSpacing>,
        CssAttributeValue<types::CssSpacing>,
        CssAttributeValue<types::CssSpacing>,
        CssAttributeValue<types::CssSpacing>,
    ),

    FontFamily(CssAttributeValue<types::CssFontFamily>),
    FontSize(CssAttributeValue<types::CssFontSize>),
    // FontShaping(CssAttributeValue<types::CssFontShaping>),
    LineHeight(CssAttributeValue<types::CssLineHeight>),
    WordBreak(CssAttributeValue<types::CssWordBreak>),
    // TextAlign(CssAttributeValue<types::CssTextAlign>),
    MaxWidth(CssAttributeValue<types::CssMaxWidth>),
    MaxHeight(CssAttributeValue<types::CssMaxHeight>),

    JustifyContent(CssAttributeValue<types::CssJustifyContent>),
    VerticalAlign(CssAttributeValue<types::CssVerticalAlign>),

    OverflowX(CssAttributeValue<types::CssOverflowX>),
    OverflowY(CssAttributeValue<types::CssOverflowY>),

    ObjectFit(CssAttributeValue<types::CssObjectFit>),
    ImageRendering(CssAttributeValue<types::CssImageRendering>),
    // Rotation(CssAttributeValue<types::CssRotation>),
    Opacity(CssAttributeValue<types::CssOpacity>),

    UnknownProperty(String, Vec<Vec<Unit>>),
}

/// Whether the property is marked 'important!'
pub type IsImportant = bool;

#[derive(Debug, Clone, Default)]
pub struct CssStyleProperties(pub Vec<(CssStyleProperty, IsImportant)>);

impl CssStyleProperty {
    pub fn from_attribute_values(values: Box<[CssStyleAttribute]>) -> Self {
        match &*values {
            [CssStyleAttribute::Color(val)] => Self::Color(val.clone()),
            [CssStyleAttribute::BackgroundColor(val)] => Self::BackgroundColor(val.clone()),
            [CssStyleAttribute::Width(val)] => Self::Width(val.clone()),
            [CssStyleAttribute::Height(val)] => Self::Height(val.clone()),
            [CssStyleAttribute::MaxWidth(val)] => Self::MaxWidth(val.clone()),
            [CssStyleAttribute::MaxHeight(val)] => Self::MaxHeight(val.clone()),

            [CssStyleAttribute::LineHeight(val)] => Self::LineHeight(val.clone()),

            [CssStyleAttribute::VerticalAlign(val)] => Self::VerticalAlign(val.clone()),

            // BEGIN PADDING
            [CssStyleAttribute::Padding(val)] => {
                Self::Padding(val.clone(), val.clone(), val.clone(), val.clone())
            }
            [CssStyleAttribute::Padding(val1), CssStyleAttribute::Padding(val2)] => {
                Self::Padding(val1.clone(), val2.clone(), val1.clone(), val2.clone())
            }
            [CssStyleAttribute::Padding(val1), CssStyleAttribute::Padding(val2), CssStyleAttribute::Padding(val3)] => {
                Self::Padding(val1.clone(), val2.clone(), val3.clone(), val2.clone())
            }
            [CssStyleAttribute::Padding(val1), CssStyleAttribute::Padding(val2), CssStyleAttribute::Padding(val3), CssStyleAttribute::Padding(val4)] => {
                Self::Padding(val1.clone(), val2.clone(), val3.clone(), val4.clone())
            }

            // BEGIN SPACING
            [CssStyleAttribute::Spacing(val)] => {
                Self::Spacing(val.clone(), val.clone(), val.clone(), val.clone())
            }
            [CssStyleAttribute::Spacing(val1), CssStyleAttribute::Spacing(val2)] => {
                Self::Spacing(val1.clone(), val2.clone(), val1.clone(), val2.clone())
            }
            [CssStyleAttribute::Spacing(val1), CssStyleAttribute::Spacing(val2), CssStyleAttribute::Spacing(val3)] => {
                Self::Spacing(val1.clone(), val2.clone(), val3.clone(), val2.clone())
            }
            [CssStyleAttribute::Spacing(val1), CssStyleAttribute::Spacing(val2), CssStyleAttribute::Spacing(val3), CssStyleAttribute::Spacing(val4)] => {
                Self::Spacing(val1.clone(), val2.clone(), val3.clone(), val4.clone())
            }
            [CssStyleAttribute::FontFamily(val)] => Self::FontFamily(val.clone()),
            [CssStyleAttribute::FontSize(val)] => Self::FontSize(val.clone()),
            [CssStyleAttribute::UnknownProperty(prop_name, prop_values)] => {
                Self::UnknownProperty(prop_name.clone(), prop_values.clone())
            }

            _ => todo!("Update structure unknown: {values:?}"),
        }
    }
}

impl std::ops::Deref for CssStyleProperties {
    type Target = Vec<(CssStyleProperty, bool)>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl std::ops::DerefMut for CssStyleProperties {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl std::fmt::Display for CssStyleProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for (item, important) in self.iter() {
            write!(f, "    ");
            match item {
                CssStyleProperty::UnknownProperty(prop_name, prop_values) => {
                    // [[a, b, c], [d, e, f]] => "a b c, d e f"
                    let prop_string = prop_values.iter()
                        .map(|group| {
                            // [a, b, c] => "a b c"
                            group.iter()
                                .map(|values| values.to_string())
                                .collect::<Vec<_>>()
                                .join(" ")
                        })
                        .collect::<Vec<_>>()
                        .join(", ")
                        ;
                    write!(f, "{prop_name}: {prop_string} /* this prop is unknown and has no validation or guarantees */")
                },
                CssStyleProperty::Color(css_attribute_value)
                    => write!(f, "color: {css_attribute_value}"),
                CssStyleProperty::BackgroundColor(css_attribute_value)
                    => write!(f, "background-color: {css_attribute_value}"),
                CssStyleProperty::Width(css_attribute_value)
                    => write!(f, "width: {css_attribute_value}"),
                CssStyleProperty::Height(css_attribute_value)
                    => write!(f, "height: {css_attribute_value}"),
                CssStyleProperty::Padding(css_attribute_value1, css_attribute_value2, css_attribute_value3, css_attribute_value4)
                    => write!(f, "padding: {css_attribute_value1} {css_attribute_value2} {css_attribute_value3} {css_attribute_value4}"),
                CssStyleProperty::Spacing(css_attribute_value1, css_attribute_value2, css_attribute_value3, css_attribute_value4)
                    => write!(f, "spacing: {css_attribute_value1} {css_attribute_value2} {css_attribute_value3} {css_attribute_value4}"),
                CssStyleProperty::FontFamily(css_attribute_value)
                    => write!(f, "font-family: {css_attribute_value}"),
                CssStyleProperty::FontSize(css_attribute_value)
                    => write!(f, "font-size: {css_attribute_value}"),
                CssStyleProperty::LineHeight(css_attribute_value)
                    => write!(f, "line-height: {css_attribute_value}"),
                CssStyleProperty::WordBreak(css_attribute_value)
                    => write!(f, "word-break: {css_attribute_value}"),
                CssStyleProperty::MaxWidth(css_attribute_value)
                    => write!(f, "max-width: {css_attribute_value}"),
                CssStyleProperty::MaxHeight(css_attribute_value)
                    => write!(f, "max-height: {css_attribute_value}"),
                CssStyleProperty::JustifyContent(css_attribute_value)
                    => write!(f, "justify-content: {css_attribute_value}"),
                CssStyleProperty::VerticalAlign(css_attribute_value)
                    => write!(f, "vertical-align: {css_attribute_value}"),
                CssStyleProperty::OverflowX(css_attribute_value)
                    => write!(f, "overflow-x: {css_attribute_value}"),
                CssStyleProperty::OverflowY(css_attribute_value)
                    => write!(f, "overflow-y: {css_attribute_value}"),
                CssStyleProperty::ObjectFit(css_attribute_value)
                    => write!(f, "object-fit: {css_attribute_value}"),
                CssStyleProperty::ImageRendering(css_attribute_value)
                    => write!(f, "image-rendering: {css_attribute_value}"),
                CssStyleProperty::Opacity(css_attribute_value)
                    => write!(f, "opacity: {css_attribute_value}"),
            };

            if *important {
                write!(f, " !important");
            }

            writeln!(f, ";");
        }

        Ok(())
    }
}