feat(layout): impl grid layout

float-pigment-css/src/parser/property_value/grid.rs

@@ -0,0 +1,103 @@
+use cssparser::{ParseError, Parser, Token};
+
+use crate::{
+    parser::{property_value::custom_ident_repr, CustomError, ParseState},
+    sheet::PropertyMeta,
+    typing::GridAutoFlow,
+};
+
+#[inline(never)]
+pub(crate) fn line_names<'a, 't: 'a, 'i: 't>(
+    parser: &'a mut Parser<'i, 't>,
+    properties: &mut [PropertyMeta],
+    st: &mut ParseState,
+) -> Result<Vec<String>, ParseError<'i, CustomError>> {
+    let next = parser.next()?;
+    if let Token::SquareBracketBlock = next {
+        let line_names = parser.parse_nested_block(|parser| {
+            let mut line_names = Vec::with_capacity(1);
+            while !parser.is_exhausted() {
+                let line_name = custom_ident_repr(parser, properties, st)?;
+                line_names.push(line_name);
+            }
+            Ok(line_names)
+        })?;
+        return Ok(line_names);
+    }
+    let next = next.clone();
+    Err(parser.new_unexpected_token_error(next))
+}
+
+#[inline(never)]
+pub(crate) fn fr_repr<'a, 't: 'a, 'i: 't>(
+    parser: &'a mut Parser<'i, 't>,
+    _properties: &mut [PropertyMeta],
+    _st: &mut ParseState,
+) -> Result<f32, ParseError<'i, CustomError>> {
+    let next = parser.next()?;
+    match next {
+        Token::Dimension { value, unit, .. } => match unit as &str {
+            "fr" => return Ok(*value),
+            _ => {}
+        },
+        _ => {}
+    }
+    let next = next.clone();
+    Err(parser.new_unexpected_token_error(next))
+}
+
+#[inline(never)]
+pub(crate) fn grid_auto_flow_repr<'a, 't: 'a, 'i: 't>(
+    parser: &'a mut Parser<'i, 't>,
+    _properties: &mut [PropertyMeta],
+    _st: &mut ParseState,
+) -> Result<GridAutoFlow, ParseError<'i, CustomError>> {
+    #[derive(PartialEq, Clone, Copy)]
+    enum FlowDirection {
+        Row,
+        Column,
+    }
+    let mut flow_direction = None;
+    let mut dense = false;
+    let check_flow_direction = move |target: FlowDirection| {
+        if flow_direction.is_none() {
+            return true;
+        }
+        flow_direction.unwrap() != target
+    };
+    while !parser.is_exhausted() {
+        let next = parser.next()?;
+        match next {
+            Token::Ident(ident) => {
+                let ident: &str = ident;
+                match ident {
+                    "row" if check_flow_direction(FlowDirection::Row) => {
+                        flow_direction.replace(FlowDirection::Row);
+                    }
+                    "column" if check_flow_direction(FlowDirection::Column) => {
+                        flow_direction.replace(FlowDirection::Column);
+                    }
+                    "dense" if !dense => {
+                        dense = true;
+                    }
+                    _ => {
+                        let next = next.clone();
+                        return Err(parser.new_unexpected_token_error(next));
+                    }
+                }
+            }
+            _ => {
+                let next = next.clone();
+                return Err(parser.new_unexpected_token_error(next));
+            }
+        }
+    }
+    match (flow_direction, dense) {
+        (Some(FlowDirection::Row), true) => Ok(GridAutoFlow::RowDense),
+        (Some(FlowDirection::Column), true) => Ok(GridAutoFlow::ColumnDense),
+        (Some(FlowDirection::Row), false) => Ok(GridAutoFlow::Row),
+        (Some(FlowDirection::Column), false) => Ok(GridAutoFlow::Column),
+        (None, true) => Ok(GridAutoFlow::RowDense),
+        (None, _) => Err(parser.new_custom_error(CustomError::Unmatched)),
+    }
+}

float-pigment-css/src/parser/property_value/mod.rs

@@ -12,6 +12,9 @@ pub(crate) mod background;
 pub(crate) mod filter;
 pub(crate) mod font;
 pub(crate) mod gradient;
+pub(crate) mod grid;
+pub(crate) use grid::*;
+
 pub(crate) mod var;
 
 #[allow(unused_macros)]
@@ -866,22 +869,18 @@ pub(crate) fn element_func_repr<'a, 't: 'a, 'i: 't>(
     })
 }
 
-// pub(crate) fn custom_ident_repr<'a, 't: 'a, 'i: 't>(
-//     parser: &'a mut Parser<'i, 't>,
-//     _properties: &mut Vec<PropertyMeta>,
-//     _st: &mut ParseState,
-// ) -> Result<String, ParseError<'i, CustomError>> {
-//     let next = parser.next()?.clone();
-//     match &next {
-//         Token::Ident(name) => {
-//             return Ok(name.to_string());
-//         }
-//         Token::QuotedString(name) => {
-//             return Ok(name.to_string());
-//         }
-//         _ => return Err(parser.new_unexpected_token_error::<CustomError>(next.clone())),
-//     }
-// }
+pub(crate) fn custom_ident_repr<'a, 't: 'a, 'i: 't>(
+    parser: &'a mut Parser<'i, 't>,
+    _properties: &mut [PropertyMeta],
+    _st: &mut ParseState,
+) -> Result<String, ParseError<'i, CustomError>> {
+    let next = parser.next()?.clone();
+    match &next {
+        Token::Ident(name) => Ok(name.to_string()),
+        Token::QuotedString(name) => Ok(name.to_string()),
+        _ => Err(parser.new_unexpected_token_error::<CustomError>(next.clone())),
+    }
+}
 
 #[inline(never)]
 pub(crate) fn image_func_repr<'a, 't: 'a, 'i: 't>(

float-pigment-css/src/property.rs

@@ -16,7 +16,7 @@ use cssparser::{ParseError, Parser, SourcePosition};
 use super::parser::{property_value::*, CustomError, ParseState};
 use super::resolve_font_size::ResolveFontSize;
 use super::sheet::borrow::Array;
-pub use super::sheet::PropertyMeta;
+pub use super::sheet::{str_store::StrRef, PropertyMeta};
 use super::typing::*;
 use float_pigment_css_macro::*;
 
@@ -166,6 +166,13 @@ property_list! (PropertyValueWithGlobal, {
     0xa3 TextDecorationThickness: TextDecorationThicknessType as Initial default TextDecorationThickness::Auto;
     0xa4 FontFeatureSettings: FontFeatureSettingsType as Inherit default FontFeatureSettings::Normal;
 
+    // grid
+    0xa5 GridTemplateRows: GridTemplateType as Initial default GridTemplate::None;
+    0xa6 GridTemplateColumns: GridTemplateType as Initial default GridTemplate::None;
+    0xa7 GridAutoFlow: GridAutoFlowType as Initial default GridAutoFlow::Row;
+    0xa8 JustifySelf: JustifySelfType as Initial default JustifySelf::Auto;
+
+
     0xd0 ListStyleType: ListStyleTypeType as Inherit default ListStyleType::Disc;
     0xd1 ListStyleImage: ListStyleImageType as Inherit default ListStyleImage::None;
     0xd2 ListStylePosition: ListStylePositionType as Inherit default ListStylePosition::Outside;
@@ -198,6 +205,7 @@ property_value_format! (PropertyValueWithGlobal, {
         | "grid" => DisplayType::Grid
         | "flow-root" => DisplayType::FlowRoot
         | "inline-flex" => DisplayType::InlineFlex
+        | "inline-grid" => DisplayType::InlineGrid
     }};
     position: {{ Position
         = "static" => PositionType::Static
@@ -330,6 +338,21 @@ property_value_format! (PropertyValueWithGlobal, {
         | "self-end" => JustifyItems::SelfEnd
         | "left" => JustifyItems::Left
         | "right" => JustifyItems::Right
+        | "normal" => JustifyItems::Normal
+    }};
+    justify_self: {{JustifySelf
+        = "auto" => JustifySelf::Auto
+        | "normal" => JustifySelf::Normal
+        | "stretch" => JustifySelf::Stretch
+        | "center" => JustifySelf::Center
+        | "flex-start" => JustifySelf::FlexStart
+        | "flex-end" => JustifySelf::FlexEnd
+        | "start" => JustifySelf::Start
+        | "end" => JustifySelf::End
+        | "self-start" => JustifySelf::SelfStart
+        | "self-end" => JustifySelf::SelfEnd
+        | "left" => JustifySelf::Left
+        | "right" => JustifySelf::Right
     }};
     order: {{ Order = <number> -> |x: Number| Number::I32(x.to_i32()); }};
     <gap_repr: Gap>:
@@ -1657,6 +1680,49 @@ property_value_format! (PropertyValueWithGlobal, {
                 )
         };
     }};
+
+    <track_breadth: TrackSize>:
+        <length> -> |x: Length| TrackSize::Length(x);
+        | "min-content" -> |_| TrackSize::MinContent;
+        | "max-content" -> |_| TrackSize::MaxContent;
+        | <fr_repr> -> |x: f32| TrackSize::Fr(x);
+    ;
+
+    <track_size: TrackSize>:
+        <track_breadth> -> |x: TrackSize| x;
+    ;
+
+    <track_list: Vec<TrackListItem>>:
+        [ [ <line_names>? [ <track_size> ] ]+ <line_names>? ] -> |x: (Vec<(Option<Vec<String>>, TrackSize)>, Option<Vec<String>>)| {
+            let mut ret = vec![];
+            for item in x.0.into_iter() {
+                if let Some(line_names) = item.0 {
+                    ret.push(TrackListItem::LineNames(line_names.iter().map(|x| x.into()).collect::<Vec<StrRef>>().into()));
+                }
+                ret.push(TrackListItem::TrackSize(item.1));
+            }
+            if let Some(line_names) = x.1 {
+                ret.push(TrackListItem::LineNames(line_names.iter().map(|x| x.into()).collect::<Vec<StrRef>>().into()));
+            }
+            ret
+        };
+    ;
+    grid_template_rows: {{ GridTemplateRows
+        = "none" => GridTemplate::None
+        | <track_list> -> |x: Vec<TrackListItem>| {
+            GridTemplate::TrackList(x.into())
+        };
+    }};
+
+    grid_template_columns: {{ GridTemplateColumns
+        = "none" => GridTemplate::None
+        | <track_list> -> |x: Vec<TrackListItem>| {
+            GridTemplate::TrackList(x.into())
+        };
+    }};
+
+    grid_auto_flow: {{ GridAutoFlow = <grid_auto_flow_repr> }};
+
 });
 
 pub(crate) fn split_hv<T: Clone>(x: Vec<T>) -> (T, T) {

float-pigment-css/src/typing.rs

@@ -134,7 +134,7 @@ pub enum Color {
     Specified(u8, u8, u8, u8),
 }
 
-/// A length value or an expression that evaluates to a langth value.
+/// A length value or an expression that evaluates to a length value.
 #[allow(missing_docs)]
 #[repr(C)]
 #[property_value_type(PropertyValueWithGlobal for LengthType)]
@@ -445,6 +445,7 @@ pub enum Display {
     Grid,
     FlowRoot,
     InlineFlex,
+    InlineGrid,
 }
 
 #[allow(missing_docs)]
@@ -654,6 +655,27 @@ pub enum JustifyItems {
     SelfEnd,
     Left,
     Right,
+    Normal,
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[property_value_type(PropertyValueWithGlobal for JustifySelfType)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ResolveFontSize)]
+#[cfg_attr(debug_assertions, derive(CompatibilityEnumCheck))]
+pub enum JustifySelf {
+    Auto,
+    Normal,
+    Stretch,
+    Center,
+    Start,
+    End,
+    FlexStart,
+    FlexEnd,
+    SelfStart,
+    SelfEnd,
+    Left,
+    Right,
 }
 
 #[allow(missing_docs)]
@@ -1813,3 +1835,48 @@ pub enum Gap {
     #[resolve_font_size(Length::resolve_em)]
     Length(Length),
 }
+
+/// The `grid-template-rows` property defines the line names and track sizing functions of the grid rows.
+#[allow(missing_docs)]
+#[repr(C)]
+#[property_value_type(PropertyValueWithGlobal for GridTemplateType)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ResolveFontSize)]
+#[cfg_attr(debug_assertions, derive(CompatibilityEnumCheck))]
+pub enum GridTemplate {
+    /// A keyword meaning that there is no explicit grid
+    None,
+    TrackList(Array<TrackListItem>),
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ResolveFontSize)]
+#[cfg_attr(debug_assertions, derive(CompatibilityEnumCheck))]
+pub enum TrackListItem {
+    LineNames(Array<StrRef>),
+    TrackSize(TrackSize),
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ResolveFontSize)]
+#[cfg_attr(debug_assertions, derive(CompatibilityEnumCheck))]
+pub enum TrackSize {
+    MinContent,
+    MaxContent,
+    Fr(f32),
+    #[resolve_font_size(Length::resolve_em)]
+    Length(Length),
+}
+
+#[allow(missing_docs)]
+#[repr(C)]
+#[property_value_type(PropertyValueWithGlobal for GridAutoFlowType)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, ResolveFontSize)]
+#[cfg_attr(debug_assertions, derive(CompatibilityEnumCheck))]
+pub enum GridAutoFlow {
+    Row,
+    Column,
+    RowDense,
+    ColumnDense,
+}