use crate::theme::color::ThemeColor;
use crate::theme::css::ast::CssValue;
use crate::theme::css::tokenizer::Token;
pub fn named_color(name: &str) -> Option<ThemeColor> {
let (r, g, b) = match name {
"black" => (0, 0, 0),
"white" => (255, 255, 255),
"red" => (255, 0, 0),
"green" => (0, 128, 0),
"blue" => (0, 0, 255),
"yellow" => (255, 255, 0),
"cyan" | "aqua" => (0, 255, 255),
"magenta" | "fuchsia" => (255, 0, 255),
"orange" => (255, 165, 0),
"gray" | "grey" => (128, 128, 128),
"darkgray" | "darkgrey" => (169, 169, 169),
"lightgray" | "lightgrey" => (211, 211, 211),
"silver" => (192, 192, 192),
"maroon" => (128, 0, 0),
"olive" => (128, 128, 0),
"lime" => (0, 255, 0),
"teal" => (0, 128, 128),
"navy" => (0, 0, 128),
"purple" => (128, 0, 128),
"indigo" => (75, 0, 130),
"coral" => (255, 127, 80),
"salmon" => (250, 128, 114),
"tomato" => (255, 99, 71),
"crimson" => (220, 20, 60),
"gold" => (255, 215, 0),
"khaki" => (240, 230, 140),
"skyblue" => (135, 206, 235),
"steelblue" => (70, 130, 180),
"slategray" | "slategrey" => (112, 128, 144),
_ => return None,
};
Some(ThemeColor::from_rgba8(r, g, b, 255))
}
pub fn parse_value(tokens: &[Token]) -> CssValue {
if tokens.is_empty() {
return CssValue::Keyword("none".into());
}
if tokens.len() == 1 {
return parse_single_token(&tokens[0]);
}
if matches!(&tokens[0], Token::Ident(name) if name == "var")
&& matches!(&tokens[1], Token::ParenOpen)
{
return parse_var(tokens);
}
if matches!(&tokens[0], Token::Ident(name) if name == "rgb" || name == "rgba")
&& matches!(&tokens[1], Token::ParenOpen)
{
return parse_rgb_rgba(tokens);
}
if let Some(shadow) = try_parse_shadow(tokens) {
return shadow;
}
let raw: String = tokens
.iter()
.map(|t| t.to_string())
.collect::<Vec<_>>()
.join(" ");
CssValue::Raw(raw)
}
fn parse_single_token(token: &Token) -> CssValue {
match token {
Token::Hash(hex) => {
if let Some(color) = ThemeColor::from_hex(&format!("#{hex}")) {
CssValue::Color(color)
} else {
CssValue::Raw(format!("#{hex}"))
}
}
Token::Number(n) => CssValue::Number(*n),
Token::Dimension(n, unit) => {
if unit == "px" {
CssValue::Length(*n)
} else {
CssValue::Length(*n)
}
}
Token::Ident(name) => {
if name == "transparent" {
CssValue::Color(ThemeColor::from_rgba8(0, 0, 0, 0))
} else if name == "none" {
CssValue::Keyword("none".into())
} else if let Some(color) = named_color(name) {
CssValue::Color(color)
} else {
CssValue::Keyword(name.clone())
}
}
Token::StringLit(s) => CssValue::Raw(s.clone()),
_ => CssValue::Raw(token.to_string()),
}
}
fn parse_var(tokens: &[Token]) -> CssValue {
let mut i = 2;
let name = match tokens.get(i) {
Some(Token::CustomProperty(name)) => name.clone(),
_ => return CssValue::Raw(tokens_to_string(tokens)),
};
i += 1;
let fallback = if matches!(tokens.get(i), Some(Token::Comma)) {
i += 1;
let mut fb_tokens = Vec::new();
while i < tokens.len() && !matches!(tokens.get(i), Some(Token::ParenClose)) {
fb_tokens.push(tokens[i].clone());
i += 1;
}
if fb_tokens.is_empty() {
None
} else {
Some(Box::new(parse_value(&fb_tokens)))
}
} else {
None
};
CssValue::Var { name, fallback }
}
fn parse_rgb_rgba(tokens: &[Token]) -> CssValue {
let nums: Vec<f32> = tokens
.iter()
.filter_map(|t| match t {
Token::Number(n) => Some(*n),
Token::Dimension(n, _) => Some(*n),
_ => None,
})
.collect();
match nums.len() {
3 => {
let color = ThemeColor::from_rgba8(nums[0] as u8, nums[1] as u8, nums[2] as u8, 255);
CssValue::Color(color)
}
4 => {
let a = if nums[3] <= 1.0 {
(nums[3] * 255.0) as u8
} else {
nums[3] as u8
};
let color = ThemeColor::from_rgba8(nums[0] as u8, nums[1] as u8, nums[2] as u8, a);
CssValue::Color(color)
}
_ => CssValue::Raw(tokens_to_string(tokens)),
}
}
fn try_parse_shadow(tokens: &[Token]) -> Option<CssValue> {
let mut nums = Vec::new();
let mut color_tokens = Vec::new();
let mut in_color = false;
let mut paren_depth = 0;
for token in tokens {
if in_color {
color_tokens.push(token.clone());
match token {
Token::ParenOpen => paren_depth += 1,
Token::ParenClose => {
paren_depth -= 1;
if paren_depth == 0 {
}
}
_ => {}
}
continue;
}
match token {
Token::Number(n) | Token::Dimension(n, _) if nums.len() < 3 => {
nums.push(*n);
}
_ if nums.len() == 3 => {
in_color = true;
color_tokens.push(token.clone());
if matches!(token, Token::ParenOpen) {
paren_depth += 1;
}
}
_ => return None,
}
}
if nums.len() != 3 || color_tokens.is_empty() {
return None;
}
let color_value = parse_value(&color_tokens);
let color = match color_value {
CssValue::Color(c) => c,
_ => return None,
};
Some(CssValue::Shadow {
x: nums[0],
y: nums[1],
blur: nums[2],
color,
})
}
fn tokens_to_string(tokens: &[Token]) -> String {
tokens
.iter()
.map(|t| t.to_string())
.collect::<Vec<_>>()
.join(" ")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::theme::css::tokenizer::Tokenizer;
fn parse(src: &str) -> CssValue {
let mut tok = Tokenizer::new(src);
let tokens: Vec<Token> = tok
.tokenize_all()
.unwrap()
.into_iter()
.map(|s| s.token)
.filter(|t| !matches!(t, Token::Eof))
.collect();
parse_value(&tokens)
}
#[test]
fn hex_color() {
let val = parse("#ff0000");
assert!(matches!(val, CssValue::Color(c) if c.r > 0.99));
}
#[test]
fn hex_color_with_alpha() {
let val = parse("#00000080");
assert!(matches!(val, CssValue::Color(c) if c.r < 0.01 && (c.a - 0.502).abs() < 0.01));
}
#[test]
fn rgba_function() {
let val = parse("rgba(255, 0, 0, 0.5)");
assert!(matches!(val, CssValue::Color(c) if c.r > 0.99 && (c.a - 0.502).abs() < 0.01));
}
#[test]
fn rgb_function() {
let val = parse("rgb(0, 128, 255)");
assert!(matches!(val, CssValue::Color(_)));
}
#[test]
fn var_reference() {
let val = parse("var(--primary)");
assert!(matches!(val, CssValue::Var { name, fallback: None } if name == "--primary"));
}
#[test]
fn var_with_fallback() {
let val = parse("var(--primary, #ff0000)");
assert!(matches!(val, CssValue::Var { name, fallback: Some(_) } if name == "--primary"));
}
#[test]
fn length_px() {
let val = parse("8px");
assert!(matches!(val, CssValue::Length(v) if (v - 8.0).abs() < 0.001));
}
#[test]
fn unitless_number() {
let val = parse("0.5");
assert!(matches!(val, CssValue::Number(v) if (v - 0.5).abs() < 0.001));
}
#[test]
fn keyword_transparent() {
let val = parse("transparent");
assert!(matches!(val, CssValue::Color(c) if c.a < 0.01));
}
#[test]
fn keyword_none() {
let val = parse("none");
assert!(val.is_none());
}
#[test]
fn named_color_red() {
let val = parse("red");
assert!(matches!(val, CssValue::Color(c) if c.r > 0.99 && c.g < 0.01));
}
#[test]
fn shadow_value() {
let val = parse("0 2px 8px #00000040");
assert!(matches!(val, CssValue::Shadow { .. }));
}
#[test]
fn shadow_with_rgba() {
let val = parse("0 2px 8px rgba(0, 0, 0, 0.25)");
assert!(matches!(val, CssValue::Shadow { .. }));
}
}