use std::fmt;
use crate::checked_value::impl_checked_value;
use crate::{
CssAngle, CssColor, CssLength, CssTime, FiniteF64, GlobalKeyword, InvalidCssNumber,
NonNegativeFiniteF64,
number::{assert_finite, try_finite},
serialization::CssWriteTo,
};
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum CssValue {
Number(FiniteF64),
Integer(i32),
Length(CssLength),
Percent(FiniteF64),
Angle(CssAngle),
Time(CssTime),
Color(CssColor),
Fr(NonNegativeFiniteF64),
Auto,
Zero,
Inherit,
Initial,
Unset,
Revert,
RevertLayer,
}
impl CssWriteTo for CssValue {
fn css_fmt<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
match self {
Self::Number(v) => write!(w, "{v}"),
Self::Integer(v) => write!(w, "{v}"),
Self::Length(l) => l.css_fmt(w),
Self::Percent(v) => write!(w, "{v}%"),
Self::Angle(a) => a.css_fmt(w),
Self::Time(t) => t.css_fmt(w),
Self::Color(c) => c.css_fmt(w),
Self::Fr(v) => write!(w, "{v}fr"),
Self::Auto => w.write_str("auto"),
Self::Zero => w.write_str("0px"),
Self::Inherit => w.write_str("inherit"),
Self::Initial => w.write_str("initial"),
Self::Unset => w.write_str("unset"),
Self::Revert => w.write_str("revert"),
Self::RevertLayer => w.write_str("revert-layer"),
}
}
}
impl From<CssLength> for CssValue {
fn from(l: CssLength) -> Self {
Self::Length(l)
}
}
impl From<CssAngle> for CssValue {
fn from(a: CssAngle) -> Self {
Self::Angle(a)
}
}
impl From<CssTime> for CssValue {
fn from(t: CssTime) -> Self {
Self::Time(t)
}
}
impl From<CssColor> for CssValue {
fn from(c: CssColor) -> Self {
Self::Color(c)
}
}
impl From<i32> for CssValue {
fn from(v: i32) -> Self {
Self::Integer(v)
}
}
impl From<FiniteF64> for CssValue {
fn from(v: FiniteF64) -> Self {
Self::Number(v)
}
}
impl From<GlobalKeyword> for CssValue {
fn from(keyword: GlobalKeyword) -> Self {
match keyword {
GlobalKeyword::Inherit => Self::Inherit,
GlobalKeyword::Initial => Self::Initial,
GlobalKeyword::Unset => Self::Unset,
GlobalKeyword::Revert => Self::Revert,
GlobalKeyword::RevertLayer => Self::RevertLayer,
}
}
}
impl TryFrom<f64> for CssValue {
type Error = InvalidCssNumber;
fn try_from(v: f64) -> Result<Self, Self::Error> {
FiniteF64::try_new(v).map(Self::Number)
}
}
impl From<CssValue> for String {
fn from(value: CssValue) -> Self {
let mut s = Self::new();
value.write_to(&mut s);
s
}
}
impl From<CssValue> for std::borrow::Cow<'static, str> {
fn from(value: CssValue) -> Self {
Self::Owned(String::from(value))
}
}
#[track_caller]
pub fn number(v: impl Into<f64>) -> CssValue {
CssValue::Number(assert_finite(v.into(), "number"))
}
pub fn try_number(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "number").map(CssValue::Number)
}
pub fn deg(v: impl Into<f64>) -> CssValue {
CssValue::Angle(CssAngle::Deg(assert_finite(v.into(), "deg")))
}
pub fn try_deg(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "deg").map(|v| CssValue::Angle(CssAngle::Deg(v)))
}
pub fn rad(v: impl Into<f64>) -> CssValue {
CssValue::Angle(CssAngle::Rad(assert_finite(v.into(), "rad")))
}
pub fn try_rad(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "rad").map(|v| CssValue::Angle(CssAngle::Rad(v)))
}
pub fn turn(v: impl Into<f64>) -> CssValue {
CssValue::Angle(CssAngle::Turn(assert_finite(v.into(), "turn")))
}
pub fn try_turn(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "turn").map(|v| CssValue::Angle(CssAngle::Turn(v)))
}
pub fn grad(v: impl Into<f64>) -> CssValue {
CssValue::Angle(CssAngle::Grad(assert_finite(v.into(), "grad")))
}
pub fn try_grad(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "grad").map(|v| CssValue::Angle(CssAngle::Grad(v)))
}
pub fn s(v: impl Into<f64>) -> CssValue {
CssValue::Time(CssTime::S(assert_finite(v.into(), "s")))
}
pub fn try_s(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "s").map(|v| CssValue::Time(CssTime::S(v)))
}
pub fn ms(v: impl Into<f64>) -> CssValue {
CssValue::Time(CssTime::Ms(assert_finite(v.into(), "ms")))
}
pub fn try_ms(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
try_finite(v.into(), "ms").map(|v| CssValue::Time(CssTime::Ms(v)))
}
pub fn fr(v: impl Into<f64>) -> CssValue {
CssValue::Fr(NonNegativeFiniteF64::new(v.into()))
}
pub fn try_fr(v: impl Into<f64>) -> Result<CssValue, InvalidCssNumber> {
NonNegativeFiniteF64::try_new(v.into()).map(CssValue::Fr)
}
impl_checked_value!(CssValue);