1use 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#[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 Deg(CSSNumber),
35 Rad(CSSNumber),
37 Grad(CSSNumber),
39 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 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 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 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 let value = if value == 0.0 { 0.0 } else { value };
133
134 serialize_dimension(value, unit, dest)
135 }
136}
137
138impl Angle {
139 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 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 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
287pub 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;