use crate::math::{MathConstant, MathExpression};
use crate::numeric::{
Angle, Frequency, Integer, Length, Number, Percentage, Ratio, Resolution, Time,
};
use crate::textual::{CssString, CustomIdent, DashedIdent, Keyword, Url};
use crate::var::VarReference;
use muskitty_css::parser::ComponentValue;
use muskitty_css::tokenizer::Token;
pub trait ToCss {
fn to_css_string(&self) -> String;
}
impl ToCss for Length {
fn to_css_string(&self) -> String {
format!("{}{}", format_number(self.value), self.unit.to_str())
}
}
impl ToCss for Percentage {
fn to_css_string(&self) -> String {
format!("{}%", format_number(self.value))
}
}
impl ToCss for Number {
fn to_css_string(&self) -> String {
format_number(self.value)
}
}
impl ToCss for Integer {
fn to_css_string(&self) -> String {
self.value.to_string()
}
}
impl ToCss for Angle {
fn to_css_string(&self) -> String {
format!("{}{}", format_number(self.value), angle_unit_str(self.unit))
}
}
impl ToCss for Time {
fn to_css_string(&self) -> String {
format!("{}{}", format_number(self.value), time_unit_str(self.unit))
}
}
impl ToCss for Frequency {
fn to_css_string(&self) -> String {
format!(
"{}{}",
format_number(self.value),
frequency_unit_str(self.unit)
)
}
}
impl ToCss for Resolution {
fn to_css_string(&self) -> String {
format!(
"{}{}",
format_number(self.value),
resolution_unit_str(self.unit)
)
}
}
impl ToCss for Ratio {
fn to_css_string(&self) -> String {
if self.height == 1.0 {
format_number(self.width)
} else {
format!(
"{} / {}",
format_number(self.width),
format_number(self.height)
)
}
}
}
impl ToCss for Keyword {
fn to_css_string(&self) -> String {
self.value.clone()
}
}
impl ToCss for CustomIdent {
fn to_css_string(&self) -> String {
self.value.clone()
}
}
impl ToCss for DashedIdent {
fn to_css_string(&self) -> String {
self.value.clone()
}
}
impl ToCss for CssString {
fn to_css_string(&self) -> String {
let escaped = self.value.replace('\\', "\\\\").replace('"', "\\\"");
format!("\"{escaped}\"")
}
}
impl ToCss for Url {
fn to_css_string(&self) -> String {
let escaped = self.value.replace('\\', "\\\\").replace('"', "\\\"");
format!("url(\"{escaped}\")")
}
}
impl ToCss for MathExpression {
fn to_css_string(&self) -> String {
match self {
MathExpression::Length(l) => l.to_css_string(),
MathExpression::Percentage(p) => p.to_css_string(),
MathExpression::Number(n) => n.to_css_string(),
MathExpression::Constant(c) => c.to_str().to_string(),
MathExpression::Var(v) => v.to_css_string(),
MathExpression::Negate(e) => {
format!("(-1 * {})", e.to_css_string())
}
MathExpression::Sum(a, b) => {
format!("{} + {}", a.to_css_string(), b.to_css_string())
}
MathExpression::Product(a, b) => {
format!("{} * {}", a.to_css_string(), b.to_css_string())
}
MathExpression::Quotient(a, b) => {
format!("{} / {}", a.to_css_string(), b.to_css_string())
}
MathExpression::Min(args) => {
format!("min({})", serialize_args(args))
}
MathExpression::Max(args) => {
format!("max({})", serialize_args(args))
}
MathExpression::Clamp { min, val, max } => {
format!(
"clamp({}, {}, {})",
min.to_css_string(),
val.to_css_string(),
max.to_css_string()
)
}
}
}
}
impl ToCss for MathConstant {
fn to_css_string(&self) -> String {
self.to_str().to_string()
}
}
fn serialize_args(args: &[MathExpression]) -> String {
args.iter()
.map(|a| a.to_css_string())
.collect::<Vec<_>>()
.join(", ")
}
impl ToCss for VarReference {
fn to_css_string(&self) -> String {
match &self.fallback {
None => format!("var({})", self.name),
Some(fallback) => {
let s: String = fallback
.iter()
.map(cv_to_string)
.collect::<Vec<_>>()
.join("");
format!("var({}, {})", self.name, s.trim())
}
}
}
}
fn cv_to_string(cv: &ComponentValue) -> String {
match cv {
ComponentValue::PreservedToken(Token::Ident(s)) => s.clone(),
ComponentValue::PreservedToken(Token::String(s)) => format!("\"{s}\""),
ComponentValue::PreservedToken(Token::Number(n)) => format_number(n.value),
ComponentValue::PreservedToken(Token::Percentage(n)) => {
format!("{}%", format_number(n.value))
}
ComponentValue::PreservedToken(Token::Dimension(n, u)) => {
format!("{}{}", format_number(n.value), u)
}
ComponentValue::PreservedToken(Token::Whitespace) => " ".to_string(),
ComponentValue::PreservedToken(Token::Comma) => ",".to_string(),
ComponentValue::PreservedToken(Token::Colon) => ":".to_string(),
ComponentValue::PreservedToken(Token::Semicolon) => ";".to_string(),
ComponentValue::PreservedToken(Token::Delim(c)) => c.to_string(),
ComponentValue::PreservedToken(Token::Hash(s, _)) => format!("#{s}"),
ComponentValue::Function(f) => {
let args: String = f
.value
.iter()
.map(cv_to_string)
.collect::<Vec<_>>()
.join("");
format!("{}({})", f.name, args.trim())
}
_ => String::new(),
}
}
fn format_number(v: f64) -> String {
if v == v.trunc() && v.is_finite() {
format!("{:.0}", v)
} else {
format!("{}", v)
}
}
fn angle_unit_str(u: crate::numeric::AngleUnit) -> &'static str {
use crate::numeric::AngleUnit::*;
match u {
Deg => "deg",
Grad => "grad",
Rad => "rad",
Turn => "turn",
}
}
fn time_unit_str(u: crate::numeric::TimeUnit) -> &'static str {
use crate::numeric::TimeUnit::*;
match u {
S => "s",
Ms => "ms",
}
}
fn frequency_unit_str(u: crate::numeric::FrequencyUnit) -> &'static str {
use crate::numeric::FrequencyUnit::*;
match u {
Hz => "Hz",
KHz => "kHz",
}
}
fn resolution_unit_str(u: crate::numeric::ResolutionUnit) -> &'static str {
use crate::numeric::ResolutionUnit::*;
match u {
Dpi => "dpi",
Dpcm => "dpcm",
Dppx => "dppx",
}
}