use std::fmt;
use crate::checked_value::impl_checked_value;
use crate::{
CssLength, CssValue, CssVariableReference, FiniteF64, InvalidCssNumber, number::try_finite,
serialization::CssWriteTo,
};
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub enum CssDimension {
Length(CssLength),
Percent(FiniteF64),
Zero,
}
macro_rules! dimension_constructor {
($(#[$meta:meta])* $name:ident, $try_name:ident, $variant:ident, $unit:literal) => {
$(#[$meta])*
#[track_caller]
pub const fn $name(v: f64) -> Self {
match Self::$try_name(v) {
Ok(value) => value,
Err(_) => panic!(concat!("CSS ", $unit, " value must be finite")),
}
}
#[doc = concat!("Attempt to construct a finite `", $unit, "` dimension.")]
pub const fn $try_name(v: f64) -> Result<Self, InvalidCssNumber> {
match try_finite(v, $unit) {
Ok(value) => Ok(Self::Length(CssLength::$variant(value))),
Err(error) => Err(error),
}
}
};
}
impl CssDimension {
dimension_constructor!( px, try_px, Px, "px");
dimension_constructor!( em, try_em, Em, "em");
dimension_constructor!( rem, try_rem, Rem, "rem");
dimension_constructor!( vw, try_vw, Vw, "vw");
dimension_constructor!( vh, try_vh, Vh, "vh");
dimension_constructor!( vmin, try_vmin, Vmin, "vmin");
dimension_constructor!( vmax, try_vmax, Vmax, "vmax");
dimension_constructor!( ch, try_ch, Ch, "ch");
dimension_constructor!( dvw, try_dvw, Dvw, "dvw");
dimension_constructor!( dvh, try_dvh, Dvh, "dvh");
dimension_constructor!( svw, try_svw, Svw, "svw");
dimension_constructor!( svh, try_svh, Svh, "svh");
dimension_constructor!( lvw, try_lvw, Lvw, "lvw");
dimension_constructor!( lvh, try_lvh, Lvh, "lvh");
dimension_constructor!( cqw, try_cqw, Cqw, "cqw");
dimension_constructor!( cqh, try_cqh, Cqh, "cqh");
#[track_caller]
pub const fn pct(v: f64) -> Self {
match Self::try_pct(v) {
Ok(value) => value,
Err(_) => panic!("CSS % value must be finite"),
}
}
pub const fn try_pct(v: f64) -> Result<Self, InvalidCssNumber> {
match try_finite(v, "%") {
Ok(value) => Ok(Self::Percent(value)),
Err(error) => Err(error),
}
}
}
impl CssWriteTo for CssDimension {
fn css_fmt<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
match self {
Self::Length(l) => l.css_fmt(w),
Self::Percent(v) => write!(w, "{v}%"),
Self::Zero => w.write_str("0px"),
}
}
}
impl From<CssDimension> for CssValue {
fn from(dim: CssDimension) -> Self {
match dim {
CssDimension::Length(l) => Self::Length(l),
CssDimension::Percent(v) => Self::Percent(v),
CssDimension::Zero => Self::Zero,
}
}
}
impl From<CssLength> for CssDimension {
fn from(l: CssLength) -> Self {
Self::Length(l)
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum LengthPercentageAuto {
LengthPercentage(CssDimension),
Calculation(CssDimensionExpr),
Auto,
}
impl From<CssDimension> for LengthPercentageAuto {
fn from(value: CssDimension) -> Self {
Self::LengthPercentage(value)
}
}
impl From<CssDimensionExpr> for LengthPercentageAuto {
fn from(value: CssDimensionExpr) -> Self {
Self::Calculation(value)
}
}
impl CssWriteTo for LengthPercentageAuto {
fn css_fmt<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
match self {
Self::LengthPercentage(value) => value.css_fmt(w),
Self::Calculation(value) => value.css_fmt(w),
Self::Auto => w.write_str("auto"),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CssEnvironmentVariable {
SafeAreaInsetTop,
SafeAreaInsetRight,
SafeAreaInsetBottom,
SafeAreaInsetLeft,
SafeAreaMaxInsetTop,
SafeAreaMaxInsetRight,
SafeAreaMaxInsetBottom,
SafeAreaMaxInsetLeft,
}
impl CssEnvironmentVariable {
const fn as_str(self) -> &'static str {
match self {
Self::SafeAreaInsetTop => "safe-area-inset-top",
Self::SafeAreaInsetRight => "safe-area-inset-right",
Self::SafeAreaInsetBottom => "safe-area-inset-bottom",
Self::SafeAreaInsetLeft => "safe-area-inset-left",
Self::SafeAreaMaxInsetTop => "safe-area-max-inset-top",
Self::SafeAreaMaxInsetRight => "safe-area-max-inset-right",
Self::SafeAreaMaxInsetBottom => "safe-area-max-inset-bottom",
Self::SafeAreaMaxInsetLeft => "safe-area-max-inset-left",
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct CssDimensionExpr(DimensionExpr);
#[derive(Clone, Debug, PartialEq)]
enum DimensionExpr {
Simple(CssDimension),
Variable(CssVariableReference<CssDimension>),
Add(Box<CssDimensionExpr>, Box<CssDimensionExpr>),
Subtract(Box<CssDimensionExpr>, Box<CssDimensionExpr>),
Min(Box<CssDimensionExpr>, Box<CssDimensionExpr>),
Max(Box<CssDimensionExpr>, Box<CssDimensionExpr>),
Clamp {
min: Box<CssDimensionExpr>,
preferred: Box<CssDimensionExpr>,
max: Box<CssDimensionExpr>,
},
Env(CssEnvironmentVariable),
}
impl CssDimensionExpr {
fn calc_fmt<W: fmt::Write>(&self, w: &mut W, nested: bool) -> fmt::Result {
match &self.0 {
DimensionExpr::Simple(value) => value.css_fmt(w),
DimensionExpr::Variable(value) => value.css_fmt(w),
DimensionExpr::Add(lhs, rhs) | DimensionExpr::Subtract(lhs, rhs) => {
if nested {
w.write_char('(')?;
}
lhs.calc_fmt(w, true)?;
if matches!(&self.0, DimensionExpr::Add(_, _)) {
w.write_str(" + ")?;
} else {
w.write_str(" - ")?;
}
rhs.calc_fmt(w, true)?;
if nested {
w.write_char(')')?;
}
Ok(())
}
DimensionExpr::Min(_, _)
| DimensionExpr::Max(_, _)
| DimensionExpr::Clamp { .. }
| DimensionExpr::Env(_) => self.css_fmt(w),
}
}
fn css_fmt_as_top_level_calculation<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
if matches!(
&self.0,
DimensionExpr::Simple(_) | DimensionExpr::Variable(_) | DimensionExpr::Env(_)
) {
w.write_str("calc(")?;
self.calc_fmt(w, false)?;
w.write_char(')')
} else {
self.css_fmt(w)
}
}
}
impl CssWriteTo for CssDimensionExpr {
fn css_fmt<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
match &self.0 {
DimensionExpr::Simple(value) => value.css_fmt(w),
DimensionExpr::Variable(value) => value.css_fmt(w),
DimensionExpr::Add(_, _) | DimensionExpr::Subtract(_, _) => {
w.write_str("calc(")?;
self.calc_fmt(w, false)?;
w.write_char(')')
}
DimensionExpr::Min(lhs, rhs) => {
w.write_str("min(")?;
lhs.css_fmt(w)?;
w.write_str(", ")?;
rhs.css_fmt(w)?;
w.write_char(')')
}
DimensionExpr::Max(lhs, rhs) => {
w.write_str("max(")?;
lhs.css_fmt(w)?;
w.write_str(", ")?;
rhs.css_fmt(w)?;
w.write_char(')')
}
DimensionExpr::Clamp {
min,
preferred,
max,
} => {
w.write_str("clamp(")?;
min.css_fmt(w)?;
w.write_str(", ")?;
preferred.css_fmt(w)?;
w.write_str(", ")?;
max.css_fmt(w)?;
w.write_char(')')
}
DimensionExpr::Env(variable) => write!(w, "env({})", variable.as_str()),
}
}
}
impl From<CssDimension> for CssDimensionExpr {
fn from(dim: CssDimension) -> Self {
Self(DimensionExpr::Simple(dim))
}
}
impl From<CssLength> for CssDimensionExpr {
fn from(length: CssLength) -> Self {
Self::from(CssDimension::Length(length))
}
}
impl From<CssVariableReference<CssDimension>> for CssDimensionExpr {
fn from(variable: CssVariableReference<CssDimension>) -> Self {
Self(DimensionExpr::Variable(variable))
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct LengthPercentageCalculation(CssDimensionExpr);
impl LengthPercentageCalculation {
pub fn new(expression: impl Into<CssDimensionExpr>) -> Self {
Self(expression.into())
}
}
impl CssWriteTo for LengthPercentageCalculation {
fn css_fmt<W: fmt::Write>(&self, w: &mut W) -> fmt::Result {
self.0.css_fmt_as_top_level_calculation(w)
}
}
impl From<CssDimension> for String {
fn from(dim: CssDimension) -> Self {
let mut s = Self::new();
dim.write_to(&mut s);
s
}
}
impl From<CssDimension> for std::borrow::Cow<'static, str> {
fn from(dim: CssDimension) -> Self {
Self::Owned(String::from(dim))
}
}
impl From<CssDimensionExpr> for String {
fn from(expr: CssDimensionExpr) -> Self {
let mut s = Self::new();
expr.write_to(&mut s);
s
}
}
impl From<CssDimensionExpr> for std::borrow::Cow<'static, str> {
fn from(expr: CssDimensionExpr) -> Self {
Self::Owned(String::from(expr))
}
}
impl std::ops::Neg for CssDimension {
type Output = Self;
fn neg(self) -> Self {
match self {
Self::Length(l) => Self::Length(-l),
Self::Percent(v) => Self::Percent(-v),
Self::Zero => Self::Zero,
}
}
}
fn same_unit(a: &CssLength, b: &CssLength) -> bool {
std::mem::discriminant(a) == std::mem::discriminant(b)
}
impl std::ops::Add for CssDimension {
type Output = CssDimensionExpr;
fn add(self, rhs: Self) -> CssDimensionExpr {
match (self, rhs) {
(Self::Zero, other) | (other, Self::Zero) => CssDimensionExpr::from(other),
(Self::Length(a), Self::Length(b)) if same_unit(&a, &b) => {
CssDimensionExpr::from(Self::Length(a.map_value(|v| v + b.value())))
}
(Self::Percent(a), Self::Percent(b)) => {
CssDimensionExpr::from(Self::Percent(FiniteF64::new(a.get() + b.get())))
}
(a, b) => CssDimensionExpr(DimensionExpr::Add(Box::new(a.into()), Box::new(b.into()))),
}
}
}
impl std::ops::Sub for CssDimension {
type Output = CssDimensionExpr;
fn sub(self, rhs: Self) -> CssDimensionExpr {
match (self, rhs) {
(lhs, Self::Zero) => CssDimensionExpr::from(lhs),
(Self::Zero, rhs) => CssDimensionExpr::from(-rhs),
(Self::Length(a), Self::Length(b)) if same_unit(&a, &b) => {
CssDimensionExpr::from(Self::Length(a.map_value(|v| v - b.value())))
}
(Self::Percent(a), Self::Percent(b)) => {
CssDimensionExpr::from(Self::Percent(FiniteF64::new(a.get() - b.get())))
}
(a, b) => CssDimensionExpr(DimensionExpr::Subtract(
Box::new(a.into()),
Box::new(b.into()),
)),
}
}
}
impl std::ops::Add<CssDimension> for CssDimensionExpr {
type Output = CssDimensionExpr;
fn add(self, rhs: CssDimension) -> CssDimensionExpr {
self + CssDimensionExpr::from(rhs)
}
}
impl std::ops::Sub<CssDimension> for CssDimensionExpr {
type Output = CssDimensionExpr;
fn sub(self, rhs: CssDimension) -> CssDimensionExpr {
self - CssDimensionExpr::from(rhs)
}
}
impl std::ops::Add for CssDimensionExpr {
type Output = CssDimensionExpr;
fn add(self, rhs: Self) -> Self {
match (self.0, rhs.0) {
(DimensionExpr::Simple(lhs), DimensionExpr::Simple(rhs)) => lhs + rhs,
(lhs, rhs) => Self(DimensionExpr::Add(Box::new(Self(lhs)), Box::new(Self(rhs)))),
}
}
}
impl std::ops::Sub for CssDimensionExpr {
type Output = CssDimensionExpr;
fn sub(self, rhs: Self) -> Self {
match (self.0, rhs.0) {
(DimensionExpr::Simple(lhs), DimensionExpr::Simple(rhs)) => lhs - rhs,
(lhs, rhs) => Self(DimensionExpr::Subtract(
Box::new(Self(lhs)),
Box::new(Self(rhs)),
)),
}
}
}
macro_rules! dim_fn {
($(#[$meta:meta])* $fn_name:ident, $try_fn_name:ident, $unit_str:literal) => {
$(#[$meta])*
#[track_caller]
pub fn $fn_name(v: impl Into<f64>) -> CssDimension {
CssDimension::$fn_name(v.into())
}
#[doc = concat!("Attempt to create a finite CSS `", $unit_str, "` value.")]
pub fn $try_fn_name(v: impl Into<f64>) -> Result<CssDimension, InvalidCssNumber> {
CssDimension::$try_fn_name(v.into())
}
};
}
dim_fn!( px, try_px, "px");
dim_fn!( em, try_em, "em");
dim_fn!(
#[allow(clippy::module_name_repetitions)]
rem,
try_rem,
"rem"
);
dim_fn!( vw, try_vw, "vw");
dim_fn!( vh, try_vh, "vh");
dim_fn!( vmin, try_vmin, "vmin");
dim_fn!( vmax, try_vmax, "vmax");
dim_fn!( ch, try_ch, "ch");
dim_fn!( dvw, try_dvw, "dvw");
dim_fn!( dvh, try_dvh, "dvh");
dim_fn!( svw, try_svw, "svw");
dim_fn!( svh, try_svh, "svh");
dim_fn!( lvw, try_lvw, "lvw");
dim_fn!( lvh, try_lvh, "lvh");
dim_fn!( cqw, try_cqw, "cqw");
dim_fn!( cqh, try_cqh, "cqh");
pub fn pct(v: impl Into<f64>) -> CssDimension {
CssDimension::pct(v.into())
}
pub fn try_pct(v: impl Into<f64>) -> Result<CssDimension, InvalidCssNumber> {
CssDimension::try_pct(v.into())
}
pub fn css_min(
lhs: impl Into<CssDimensionExpr>,
rhs: impl Into<CssDimensionExpr>,
) -> CssDimensionExpr {
let lhs = lhs.into();
let rhs = rhs.into();
CssDimensionExpr(DimensionExpr::Min(Box::new(lhs), Box::new(rhs)))
}
pub fn css_max(
lhs: impl Into<CssDimensionExpr>,
rhs: impl Into<CssDimensionExpr>,
) -> CssDimensionExpr {
let lhs = lhs.into();
let rhs = rhs.into();
CssDimensionExpr(DimensionExpr::Max(Box::new(lhs), Box::new(rhs)))
}
pub fn css_clamp(
min: impl Into<CssDimensionExpr>,
preferred: impl Into<CssDimensionExpr>,
max: impl Into<CssDimensionExpr>,
) -> CssDimensionExpr {
let min = min.into();
let preferred = preferred.into();
let max = max.into();
CssDimensionExpr(DimensionExpr::Clamp {
min: Box::new(min),
preferred: Box::new(preferred),
max: Box::new(max),
})
}
pub fn css_env(variable: CssEnvironmentVariable) -> CssDimensionExpr {
CssDimensionExpr(DimensionExpr::Env(variable))
}
impl_checked_value!(
CssDimension,
LengthPercentageAuto,
CssDimensionExpr,
LengthPercentageCalculation,
);