rustyle_css/css/

grid.rs

//! CSS Grid utilities
//!
//! Provides type-safe CSS Grid definitions including templates, areas, and subgrid support.

use super::units::Length;

/// Grid template definition
#[derive(Clone, Debug)]
pub struct GridTemplate {
    columns: Vec<GridTrack>,
    rows: Vec<GridTrack>,
    areas: Option<Vec<Vec<String>>>,
}

/// Grid track (column or row) definition
#[derive(Clone, Debug)]
pub enum GridTrack {
    /// Fixed size (e.g., "200px")
    Fixed(Length),
    /// Flexible size (e.g., "1fr")
    Flexible(f32),
    /// Minmax function
    MinMax(Length, Length),
    /// Repeat function
    Repeat(u32, Vec<GridTrack>),
    /// Auto
    Auto,
    /// Named line
    Named(String),
}

impl GridTrack {
    /// Convert to CSS string
    pub fn to_css(&self) -> String {
        match self {
            GridTrack::Fixed(len) => len.to_css(),
            GridTrack::Flexible(fr) => format!("{}fr", fr),
            GridTrack::MinMax(min, max) => format!("minmax({}, {})", min.to_css(), max.to_css()),
            GridTrack::Repeat(count, tracks) => {
                let tracks_str = tracks
                    .iter()
                    .map(|t| t.to_css())
                    .collect::<Vec<_>>()
                    .join(" ");
                format!("repeat({}, {})", count, tracks_str)
            }
            GridTrack::Auto => "auto".to_string(),
            GridTrack::Named(name) => format!("[{}]", name),
        }
    }
}

impl GridTemplate {
    /// Create a new grid template
    pub fn new() -> Self {
        Self {
            columns: Vec::new(),
            rows: Vec::new(),
            areas: None,
        }
    }

    /// Add columns
    pub fn columns(mut self, cols: Vec<GridTrack>) -> Self {
        self.columns = cols;
        self
    }

    /// Add rows
    pub fn rows(mut self, rows: Vec<GridTrack>) -> Self {
        self.rows = rows;
        self
    }

    /// Set grid areas
    pub fn areas(mut self, areas: Vec<Vec<String>>) -> Self {
        self.areas = Some(areas);
        self
    }

    /// Convert to CSS string
    pub fn to_css(&self) -> String {
        let mut css = String::new();

        if !self.columns.is_empty() {
            let cols_str = self
                .columns
                .iter()
                .map(|t| t.to_css())
                .collect::<Vec<_>>()
                .join(" ");
            css.push_str(&format!("grid-template-columns: {}; ", cols_str));
        }

        if !self.rows.is_empty() {
            let rows_str = self
                .rows
                .iter()
                .map(|t| t.to_css())
                .collect::<Vec<_>>()
                .join(" ");
            css.push_str(&format!("grid-template-rows: {}; ", rows_str));
        }

        if let Some(ref areas) = self.areas {
            let areas_str = areas
                .iter()
                .map(|row| format!("\"{}\"", row.join(" ")))
                .collect::<Vec<_>>()
                .join(" ");
            css.push_str(&format!("grid-template-areas: {}; ", areas_str));
        }

        css
    }
}

impl Default for GridTemplate {
    fn default() -> Self {
        Self::new()
    }
}

/// Grid area definition
#[derive(Clone, Debug)]
pub struct GridArea {
    pub name: String,
    pub row_start: Option<String>,
    pub column_start: Option<String>,
    pub row_end: Option<String>,
    pub column_end: Option<String>,
}

impl GridArea {
    /// Create a new grid area
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            row_start: None,
            column_start: None,
            row_end: None,
            column_end: None,
        }
    }

    /// Set row start
    pub fn row_start(mut self, start: &str) -> Self {
        self.row_start = Some(start.to_string());
        self
    }

    /// Set column start
    pub fn column_start(mut self, start: &str) -> Self {
        self.column_start = Some(start.to_string());
        self
    }

    /// Set row end
    pub fn row_end(mut self, end: &str) -> Self {
        self.row_end = Some(end.to_string());
        self
    }

    /// Set column end
    pub fn column_end(mut self, end: &str) -> Self {
        self.column_end = Some(end.to_string());
        self
    }

    /// Convert to CSS string
    pub fn to_css(&self) -> String {
        let mut props = Vec::new();

        props.push(format!("grid-area: {};", self.name));

        if let Some(ref start) = self.row_start {
            props.push(format!("grid-row-start: {};", start));
        }

        if let Some(ref start) = self.column_start {
            props.push(format!("grid-column-start: {};", start));
        }

        if let Some(ref end) = self.row_end {
            props.push(format!("grid-row-end: {};", end));
        }

        if let Some(ref end) = self.column_end {
            props.push(format!("grid-column-end: {};", end));
        }

        props.join(" ")
    }
}

/// Subgrid support
#[derive(Clone, Debug)]
pub struct Subgrid {
    pub columns: bool,
    pub rows: bool,
}

impl Subgrid {
    /// Create subgrid for both columns and rows
    pub fn both() -> Self {
        Self {
            columns: true,
            rows: true,
        }
    }

    /// Create subgrid for columns only
    pub fn columns() -> Self {
        Self {
            columns: true,
            rows: false,
        }
    }

    /// Create subgrid for rows only
    pub fn rows() -> Self {
        Self {
            columns: false,
            rows: true,
        }
    }

    /// Convert to CSS string
    pub fn to_css(&self) -> String {
        match (self.columns, self.rows) {
            (true, true) => "subgrid".to_string(),
            (true, false) => "subgrid / none".to_string(),
            (false, true) => "none / subgrid".to_string(),
            (false, false) => "none".to_string(),
        }
    }
}