use super::*;
use crate::css::component_values::split_css_component_values;
#[derive(Debug, Clone)]
pub(crate) struct ParsedGapRuleShorthand {
pub(crate) widths: GapRuleList<ComputedLengthPercentage>,
pub(crate) styles: GapRuleList<BorderStyle>,
pub(crate) colors: GapRuleList<CssColor>,
}
pub(crate) fn parse_gap_rule_width_list(
value: &str,
font_size: f32,
) -> Option<GapRuleList<ComputedLengthPercentage>> {
parse_gap_rule_list(value, |token| parse_computed_border_width(token, font_size))
}
pub(crate) fn parse_gap_rule_style_list(value: &str) -> Option<GapRuleList<BorderStyle>> {
parse_gap_rule_list(value, parse_border_style)
}
pub(crate) fn parse_gap_rule_color_list(
value: &str,
current_color: CssColor,
) -> Option<GapRuleList<CssColor>> {
parse_gap_rule_list(value, |token| {
parse_border_color(token).map(|color| color.resolve(current_color))
})
}
pub(crate) fn parse_gap_rule_break(value: &str) -> Option<GapRuleBreak> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"none" => Some(GapRuleBreak::None),
"normal" => Some(GapRuleBreak::Normal),
"intersection" => Some(GapRuleBreak::Intersection),
_ => None,
}
}
pub(crate) fn parse_gap_rule_visibility_items(value: &str) -> Option<GapRuleVisibilityItems> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"normal" => Some(GapRuleVisibilityItems::Normal),
"all" => Some(GapRuleVisibilityItems::All),
"around" => Some(GapRuleVisibilityItems::Around),
"between" => Some(GapRuleVisibilityItems::Between),
_ => None,
}
}
pub(crate) fn parse_gap_rule_overlap(value: &str) -> Option<GapRuleOverlap> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"row-over-column" => Some(GapRuleOverlap::RowOverColumn),
"column-over-row" => Some(GapRuleOverlap::ColumnOverRow),
_ => None,
}
}
pub(crate) fn parse_gap_rule_inset_value(value: &str, font_size: f32) -> Option<GapRuleInsetValue> {
let value = trim_css_value(value);
if value.eq_ignore_ascii_case("overlap-join") {
Some(GapRuleInsetValue::OverlapJoin)
} else {
parse_computed_length_percentage(value, font_size).map(GapRuleInsetValue::LengthPercentage)
}
}
pub(crate) fn parse_gap_rule_shorthand(
value: &str,
font_size: f32,
current_color: CssColor,
) -> Option<ParsedGapRuleShorthand> {
let rule_components = parse_gap_rule_list(value, |token| {
parse_single_gap_rule(token, font_size, current_color)
})?;
let widths = map_gap_rule_list(&rule_components, |rule| {
rule.width
.clone()
.unwrap_or_else(|| ComputedLengthPercentage::from_points(3.0 * CSS_PX_TO_PT))
});
let styles = map_gap_rule_list(&rule_components, |rule| {
rule.style.unwrap_or(BorderStyle::None)
});
let colors = map_gap_rule_list(&rule_components, |rule| rule.color.unwrap_or(current_color));
Some(ParsedGapRuleShorthand {
widths,
styles,
colors,
})
}
#[derive(Debug, Clone)]
struct SingleGapRule {
width: Option<ComputedLengthPercentage>,
style: Option<BorderStyle>,
color: Option<CssColor>,
}
fn parse_single_gap_rule(
value: &str,
font_size: f32,
current_color: CssColor,
) -> Option<SingleGapRule> {
let mut width = None;
let mut style = None;
let mut color = None;
let mut saw_component = false;
for part in split_css_component_values(value) {
if width.is_none()
&& let Some(parsed) = parse_computed_border_width(part, font_size)
{
width = Some(parsed);
saw_component = true;
continue;
}
if style.is_none()
&& let Some(parsed) = parse_border_style(part)
{
style = Some(parsed);
saw_component = true;
continue;
}
if color.is_none()
&& let Some(parsed) = parse_border_color(part).map(|color| color.resolve(current_color))
{
color = Some(parsed);
saw_component = true;
continue;
}
return None;
}
saw_component.then_some(SingleGapRule {
width,
style,
color,
})
}
fn parse_gap_rule_list<T>(
value: &str,
parse_item: impl Fn(&str) -> Option<T> + Copy,
) -> Option<GapRuleList<T>> {
let parts = split_top_level_commas(trim_css_value(value));
if parts.is_empty() {
return None;
}
let mut leading = Vec::new();
let mut trailing = Vec::new();
let mut auto = None;
let mut after_auto = false;
for part in parts {
if let Some(repeat) = parse_gap_rule_repeat(part, parse_item) {
match repeat {
ParsedGapRepeat::Fixed { count, values } => {
let component = GapRuleListComponent::Repeat { count, values };
if after_auto {
trailing.push(component);
} else {
leading.push(component);
}
}
ParsedGapRepeat::Auto(values) => {
if auto.is_some() {
return None;
}
auto = Some(values);
after_auto = true;
}
}
continue;
}
let value = parse_item(part)?;
let component = GapRuleListComponent::Value(value);
if after_auto {
trailing.push(component);
} else {
leading.push(component);
}
}
if auto.is_none() && leading.is_empty() {
return None;
}
Some(GapRuleList::from_parts(leading, auto, trailing))
}
enum ParsedGapRepeat<T> {
Fixed { count: usize, values: Vec<T> },
Auto(Vec<T>),
}
fn parse_gap_rule_repeat<T>(
value: &str,
parse_item: impl Fn(&str) -> Option<T> + Copy,
) -> Option<ParsedGapRepeat<T>> {
let value = trim_css_value(value);
let inner = strip_gap_repeat_function(value)?;
let (count, repeated) = split_top_level_once(inner, ',')?;
let repeated_values = split_top_level_commas(repeated)
.into_iter()
.map(parse_item)
.collect::<Option<Vec<_>>>()?;
if repeated_values.is_empty() {
return None;
}
let count = trim_css_value(count);
if count.eq_ignore_ascii_case("auto") {
return Some(ParsedGapRepeat::Auto(repeated_values));
}
let count = count.parse::<usize>().ok().filter(|count| *count > 0)?;
Some(ParsedGapRepeat::Fixed {
count,
values: repeated_values,
})
}
fn strip_gap_repeat_function(value: &str) -> Option<&str> {
let value = trim_css_value(value);
let open = "repeat".len();
if !value
.get(..open)
.is_some_and(|name| name.eq_ignore_ascii_case("repeat"))
{
return None;
}
value
.get(open..)?
.strip_prefix('(')?
.strip_suffix(')')
.map(trim_css_value)
}
fn map_gap_rule_list<T, U>(list: &GapRuleList<T>, map: impl Fn(&T) -> U + Copy) -> GapRuleList<U> {
list.map(map)
}
fn split_top_level_commas(value: &str) -> Vec<&str> {
crate::css::component_values::split_css_top_level_delimiter(value, ',')
.into_iter()
.map(trim_css_value)
.filter(|part| !part.is_empty())
.collect()
}
fn split_top_level_once(value: &str, delimiter: char) -> Option<(&str, &str)> {
crate::css::component_values::split_css_top_level_once(value, delimiter)
}