Skip to main content

rspack_lightningcss/values/
angle.rs

1//! CSS angle values.
2
3use super::calc::Calc;
4use super::length::serialize_dimension;
5use super::number::{CSSNumber, NumericRange};
6use super::percentage::DimensionPercentage;
7use crate::error::{ParserError, PrinterError};
8use crate::traits::{
9  impl_op,
10  private::{AddInternal, TryAdd},
11  Map, Op, Parse, ParseNumeric, Sign, ToCss, Zero,
12};
13#[cfg(feature = "visitor")]
14use crate::visitor::Visit;
15use cssparser::*;
16use std::f32::consts::PI;
17
18/// A CSS [`<angle>`](https://www.w3.org/TR/css-values-4/#angles) value.
19///
20/// Angles may be explicit or computed by `calc()`, but are always stored and serialized
21/// as their computed value.
22#[derive(Debug, Clone)]
23#[cfg_attr(feature = "visitor", derive(Visit))]
24#[cfg_attr(feature = "visitor", visit(visit_angle, ANGLES))]
25#[cfg_attr(
26  feature = "serde",
27  derive(serde::Serialize, serde::Deserialize),
28  serde(tag = "type", content = "value", rename_all = "kebab-case")
29)]
30#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
31#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
32pub enum Angle {
33  /// An angle in degrees. There are 360 degrees in a full circle.
34  Deg(CSSNumber),
35  /// An angle in radians. There are 2π radians in a full circle.
36  Rad(CSSNumber),
37  /// An angle in gradians. There are 400 gradians in a full circle.
38  Grad(CSSNumber),
39  /// An angle in turns. There is 1 turn in a full circle.
40  Turn(CSSNumber),
41}
42
43impl<'i> Parse<'i> for Angle {
44  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
45    Self::parse_with_range(input, NumericRange::All)
46  }
47}
48
49impl<'i> ParseNumeric<'i> for Angle {
50  fn parse_with_range<'t>(
51    input: &mut Parser<'i, 't>,
52    range: NumericRange,
53  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
54    Self::parse_internal(input, false, range)
55  }
56}
57
58impl Angle {
59  /// Parses an angle, allowing unitless zero values.
60  pub fn parse_with_unitless_zero<'i, 't>(
61    input: &mut Parser<'i, 't>,
62  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
63    Self::parse_internal(input, true, NumericRange::All)
64  }
65
66  fn parse_internal<'i, 't>(
67    input: &mut Parser<'i, 't>,
68    allow_unitless_zero: bool,
69    range: NumericRange,
70  ) -> Result<Self, ParseError<'i, ParserError<'i>>> {
71    match input.try_parse(Calc::<Self>::parse) {
72      Ok(Calc::Value(v)) => return Ok(v.map(|value| range.clamp(value))),
73      // Angles are always compatible, so they will always compute to a value.
74      Ok(_) => return Err(input.new_custom_error(ParserError::InvalidValue)),
75      _ => {}
76    }
77
78    let location = input.current_source_location();
79    let token = input.next()?;
80    match *token {
81      Token::Dimension { value, ref unit, .. } => {
82        let value = range.check(value, location)?;
83        match_ignore_ascii_case! { unit,
84          "deg" => Ok(Angle::Deg(value)),
85          "grad" => Ok(Angle::Grad(value)),
86          "turn" => Ok(Angle::Turn(value)),
87          "rad" => Ok(Angle::Rad(value)),
88          _ => return Err(location.new_unexpected_token_error(token.clone())),
89        }
90      }
91      Token::Number { value, .. } if value == 0.0 && allow_unitless_zero => Ok(Angle::zero()),
92      ref token => return Err(location.new_unexpected_token_error(token.clone())),
93    }
94  }
95}
96
97impl<'i> TryFrom<&Token<'i>> for Angle {
98  type Error = ();
99
100  fn try_from(token: &Token) -> Result<Self, Self::Error> {
101    match token {
102      Token::Dimension { value, ref unit, .. } => match_ignore_ascii_case! { unit,
103        "deg" => Ok(Angle::Deg(*value)),
104        "grad" => Ok(Angle::Grad(*value)),
105        "turn" => Ok(Angle::Turn(*value)),
106        "rad" => Ok(Angle::Rad(*value)),
107        _ => Err(()),
108      },
109      _ => Err(()),
110    }
111  }
112}
113
114impl ToCss for Angle {
115  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
116    let (value, unit) = match self {
117      Angle::Deg(val) => (*val, "deg"),
118      Angle::Grad(val) => (*val, "grad"),
119      Angle::Rad(val) => {
120        let deg = self.to_degrees();
121        // We print 5 digits of precision by default.
122        // Switch to degrees if there are an even number of them.
123        if (deg * 100000.0).round().fract() == 0.0 {
124          (deg, "deg")
125        } else {
126          (*val, "rad")
127        }
128      }
129      Angle::Turn(val) => (*val, "turn"),
130    };
131    // Canonicalize negative zero so serialization is stable (`0deg` instead of `-0deg`).
132    let value = if value == 0.0 { 0.0 } else { value };
133
134    serialize_dimension(value, unit, dest)
135  }
136}
137
138impl Angle {
139  /// Prints the angle, allowing unitless zero values.
140  pub fn to_css_with_unitless_zero<PrinterT: crate::printer::PrinterTrait>(
141    &self,
142    dest: &mut PrinterT,
143  ) -> Result<(), PrinterError> {
144    if self.is_zero() {
145      (0.0).to_css(dest)
146    } else {
147      self.to_css(dest)
148    }
149  }
150}
151
152impl Angle {
153  /// Returns the angle in radians.
154  pub fn to_radians(&self) -> CSSNumber {
155    const RAD_PER_DEG: f32 = PI / 180.0;
156    match self {
157      Angle::Deg(deg) => deg * RAD_PER_DEG,
158      Angle::Rad(rad) => *rad,
159      Angle::Grad(grad) => grad * 180.0 / 200.0 * RAD_PER_DEG,
160      Angle::Turn(turn) => turn * 360.0 * RAD_PER_DEG,
161    }
162  }
163
164  /// Returns the angle in degrees.
165  pub fn to_degrees(&self) -> CSSNumber {
166    const DEG_PER_RAD: f32 = 180.0 / PI;
167    match self {
168      Angle::Deg(deg) => *deg,
169      Angle::Rad(rad) => rad * DEG_PER_RAD,
170      Angle::Grad(grad) => grad * 180.0 / 200.0,
171      Angle::Turn(turn) => turn * 360.0,
172    }
173  }
174}
175
176impl Zero for Angle {
177  fn is_zero(&self) -> bool {
178    use Angle::*;
179    match self {
180      Deg(v) | Rad(v) | Grad(v) | Turn(v) => *v == 0.0,
181    }
182  }
183
184  fn zero() -> Self {
185    Angle::Deg(0.0)
186  }
187}
188
189impl Into<Calc<Angle>> for Angle {
190  fn into(self) -> Calc<Angle> {
191    Calc::Value(Box::new(self))
192  }
193}
194
195impl TryFrom<Calc<Angle>> for Angle {
196  type Error = ();
197
198  fn try_from(calc: Calc<Angle>) -> Result<Angle, ()> {
199    match calc {
200      Calc::Value(v) => Ok(*v),
201      _ => Err(()),
202    }
203  }
204}
205
206impl std::ops::Mul<CSSNumber> for Angle {
207  type Output = Self;
208
209  fn mul(self, other: CSSNumber) -> Angle {
210    match self {
211      Angle::Deg(v) => Angle::Deg(v * other),
212      Angle::Rad(v) => Angle::Rad(v * other),
213      Angle::Grad(v) => Angle::Grad(v * other),
214      Angle::Turn(v) => Angle::Turn(v * other),
215    }
216  }
217}
218
219impl AddInternal for Angle {
220  fn add(self, other: Self) -> Self {
221    self + other
222  }
223}
224
225impl TryAdd<Angle> for Angle {
226  fn try_add(&self, other: &Angle) -> Option<Angle> {
227    Some(Angle::Deg(self.to_degrees() + other.to_degrees()))
228  }
229}
230
231impl std::cmp::PartialEq<Angle> for Angle {
232  fn eq(&self, other: &Angle) -> bool {
233    self.to_degrees() == other.to_degrees()
234  }
235}
236
237impl std::cmp::PartialOrd<Angle> for Angle {
238  fn partial_cmp(&self, other: &Angle) -> Option<std::cmp::Ordering> {
239    self.to_degrees().partial_cmp(&other.to_degrees())
240  }
241}
242
243impl Op for Angle {
244  fn op<F: FnOnce(f32, f32) -> f32>(&self, other: &Self, op: F) -> Self {
245    match (self, other) {
246      (Angle::Deg(a), Angle::Deg(b)) => Angle::Deg(op(*a, *b)),
247      (Angle::Rad(a), Angle::Rad(b)) => Angle::Rad(op(*a, *b)),
248      (Angle::Grad(a), Angle::Grad(b)) => Angle::Grad(op(*a, *b)),
249      (Angle::Turn(a), Angle::Turn(b)) => Angle::Turn(op(*a, *b)),
250      (a, b) => Angle::Deg(op(a.to_degrees(), b.to_degrees())),
251    }
252  }
253
254  fn op_to<T, F: FnOnce(f32, f32) -> T>(&self, other: &Self, op: F) -> T {
255    match (self, other) {
256      (Angle::Deg(a), Angle::Deg(b)) => op(*a, *b),
257      (Angle::Rad(a), Angle::Rad(b)) => op(*a, *b),
258      (Angle::Grad(a), Angle::Grad(b)) => op(*a, *b),
259      (Angle::Turn(a), Angle::Turn(b)) => op(*a, *b),
260      (a, b) => op(a.to_degrees(), b.to_degrees()),
261    }
262  }
263}
264
265impl Map for Angle {
266  fn map<F: FnOnce(f32) -> f32>(&self, op: F) -> Self {
267    match self {
268      Angle::Deg(deg) => Angle::Deg(op(*deg)),
269      Angle::Rad(rad) => Angle::Rad(op(*rad)),
270      Angle::Grad(grad) => Angle::Grad(op(*grad)),
271      Angle::Turn(turn) => Angle::Turn(op(*turn)),
272    }
273  }
274}
275
276impl Sign for Angle {
277  fn sign(&self) -> f32 {
278    match self {
279      Angle::Deg(v) | Angle::Rad(v) | Angle::Grad(v) | Angle::Turn(v) => v.sign(),
280    }
281  }
282}
283
284impl_op!(Angle, std::ops::Rem, rem);
285impl_op!(Angle, std::ops::Add, add);
286
287/// A CSS [`<angle-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-angle-percentage) value.
288/// May be specified as either an angle or a percentage that resolves to an angle.
289pub type AnglePercentage = DimensionPercentage<Angle>;
290
291macro_rules! impl_try_from_angle {
292  ($t: ty) => {
293    impl TryFrom<crate::values::angle::Angle> for $t {
294      type Error = ();
295      fn try_from(_: crate::values::angle::Angle) -> Result<Self, Self::Error> {
296        Err(())
297      }
298    }
299
300    impl TryInto<crate::values::angle::Angle> for $t {
301      type Error = ();
302      fn try_into(self) -> Result<crate::values::angle::Angle, Self::Error> {
303        Err(())
304      }
305    }
306  };
307}
308
309pub(crate) use impl_try_from_angle;