Skip to main content

rspack_lightningcss/properties/
border_image.rs

1//! CSS properties related to border images.
2
3use crate::context::PropertyHandlerContext;
4use crate::declaration::{DeclarationBlock, DeclarationList};
5use crate::error::{ParserError, PrinterError};
6use crate::prefixes::Feature;
7use crate::properties::{Property, PropertyId, VendorPrefix};
8use crate::targets::{Browsers, Targets};
9use crate::traits::{IsCompatible, Parse, PropertyHandler, Shorthand, ToCss};
10use crate::values::image::Image;
11use crate::values::number::CSSNumber;
12use crate::values::number::NonNegative;
13use crate::values::rect::Rect;
14#[cfg(feature = "visitor")]
15use crate::visitor::Visit;
16use crate::{compat, macros::*};
17use crate::{
18  traits::FallbackValues,
19  values::{
20    length::*,
21    percentage::{NumberOrPercentage, Percentage},
22  },
23};
24use cssparser::*;
25
26enum_property! {
27  /// A single [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) keyword.
28  pub enum BorderImageRepeatKeyword {
29    /// The image is stretched to fill the area.
30    Stretch,
31    /// The image is tiled (repeated) to fill the area.
32    Repeat,
33     /// The image is scaled so that it repeats an even number of times.
34    Round,
35    /// The image is repeated so that it fits, and then spaced apart evenly.
36    Space,
37  }
38}
39
40impl IsCompatible for BorderImageRepeatKeyword {
41  fn is_compatible(&self, browsers: Browsers) -> bool {
42    use BorderImageRepeatKeyword::*;
43    match self {
44      Round => compat::Feature::BorderImageRepeatRound.is_compatible(browsers),
45      Space => compat::Feature::BorderImageRepeatSpace.is_compatible(browsers),
46      Stretch | Repeat => true,
47    }
48  }
49}
50
51/// A value for the [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) property.
52#[derive(Debug, Clone, PartialEq)]
53#[cfg_attr(feature = "visitor", derive(Visit))]
54#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
55#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
56#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
57pub struct BorderImageRepeat {
58  /// The horizontal repeat value.
59  pub horizontal: BorderImageRepeatKeyword,
60  /// The vertical repeat value.
61  pub vertical: BorderImageRepeatKeyword,
62}
63
64impl Default for BorderImageRepeat {
65  fn default() -> BorderImageRepeat {
66    BorderImageRepeat {
67      horizontal: BorderImageRepeatKeyword::Stretch,
68      vertical: BorderImageRepeatKeyword::Stretch,
69    }
70  }
71}
72
73impl<'i> Parse<'i> for BorderImageRepeat {
74  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
75    let horizontal = BorderImageRepeatKeyword::parse(input)?;
76    let vertical = input.try_parse(BorderImageRepeatKeyword::parse).ok();
77    Ok(BorderImageRepeat {
78      horizontal,
79      vertical: vertical.unwrap_or(horizontal),
80    })
81  }
82}
83
84impl ToCss for BorderImageRepeat {
85  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
86    self.horizontal.to_css(dest)?;
87    if self.horizontal != self.vertical {
88      dest.write_str(" ")?;
89      self.vertical.to_css(dest)?;
90    }
91    Ok(())
92  }
93}
94
95impl IsCompatible for BorderImageRepeat {
96  fn is_compatible(&self, browsers: Browsers) -> bool {
97    self.horizontal.is_compatible(browsers) && self.vertical.is_compatible(browsers)
98  }
99}
100
101/// A value for the [border-image-width](https://www.w3.org/TR/css-backgrounds-3/#border-image-width) property.
102#[derive(Debug, Clone, PartialEq, Parse, ToCss)]
103#[cfg_attr(feature = "visitor", derive(Visit))]
104#[cfg_attr(
105  feature = "serde",
106  derive(serde::Serialize, serde::Deserialize),
107  serde(tag = "type", content = "value", rename_all = "kebab-case")
108)]
109#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
110#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
111pub enum BorderImageSideWidth {
112  /// A number representing a multiple of the border width.
113  Number(NonNegative<CSSNumber>),
114  /// An explicit length or percentage.
115  LengthPercentage(NonNegative<LengthPercentage>),
116  /// The `auto` keyword, representing the natural width of the image slice.
117  Auto,
118}
119
120impl Default for BorderImageSideWidth {
121  fn default() -> BorderImageSideWidth {
122    BorderImageSideWidth::Number(NonNegative(1.0))
123  }
124}
125
126impl IsCompatible for BorderImageSideWidth {
127  fn is_compatible(&self, browsers: Browsers) -> bool {
128    match self {
129      BorderImageSideWidth::LengthPercentage(l) => l.is_compatible(browsers),
130      _ => true,
131    }
132  }
133}
134
135/// A value for the [border-image-slice](https://www.w3.org/TR/css-backgrounds-3/#border-image-slice) property.
136#[derive(Debug, Clone, PartialEq)]
137#[cfg_attr(feature = "visitor", derive(Visit))]
138#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
139#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
140#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
141pub struct BorderImageSlice {
142  /// The offsets from the edges of the image.
143  pub offsets: Rect<NonNegative<NumberOrPercentage>>,
144  /// Whether the middle of the border image should be preserved.
145  pub fill: bool,
146}
147
148impl Default for BorderImageSlice {
149  fn default() -> BorderImageSlice {
150    BorderImageSlice {
151      offsets: Rect::all(NonNegative(NumberOrPercentage::Percentage(Percentage(1.0)))),
152      fill: false,
153    }
154  }
155}
156
157impl<'i> Parse<'i> for BorderImageSlice {
158  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
159    let mut fill = input.try_parse(|i| i.expect_ident_matching("fill")).is_ok();
160    let offsets = Rect::parse(input)?;
161    if !fill {
162      fill = input.try_parse(|i| i.expect_ident_matching("fill")).is_ok();
163    }
164    Ok(BorderImageSlice { offsets, fill })
165  }
166}
167
168impl ToCss for BorderImageSlice {
169  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
170    self.offsets.to_css(dest)?;
171    if self.fill {
172      dest.write_str(" fill")?;
173    }
174    Ok(())
175  }
176}
177
178impl IsCompatible for BorderImageSlice {
179  fn is_compatible(&self, _browsers: Browsers) -> bool {
180    true
181  }
182}
183
184define_shorthand! {
185  /// A value for the [border-image](https://www.w3.org/TR/css-backgrounds-3/#border-image) shorthand property.
186  #[derive(Default)]
187  pub struct BorderImage<'i>(VendorPrefix) {
188    /// The border image.
189    #[cfg_attr(feature = "serde", serde(borrow))]
190    source: BorderImageSource(Image<'i>),
191    /// The offsets that define where the image is sliced.
192    slice: BorderImageSlice(BorderImageSlice),
193    /// The width of the border image.
194    width: BorderImageWidth(Rect<BorderImageSideWidth>),
195    /// The amount that the image extends beyond the border box.
196    outset: BorderImageOutset(Rect<NonNegative<LengthOrNumber>>),
197    /// How the border image is scaled and tiled.
198    repeat: BorderImageRepeat(BorderImageRepeat),
199  }
200}
201
202impl<'i> Parse<'i> for BorderImage<'i> {
203  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
204    BorderImage::parse_with_callback(input, |_| false)
205  }
206}
207
208impl<'i> BorderImage<'i> {
209  pub(crate) fn parse_with_callback<'t, F>(
210    input: &mut Parser<'i, 't>,
211    mut callback: F,
212  ) -> Result<Self, ParseError<'i, ParserError<'i>>>
213  where
214    F: FnMut(&mut Parser<'i, 't>) -> bool,
215  {
216    let mut source: Option<Image> = None;
217    let mut slice: Option<BorderImageSlice> = None;
218    let mut width: Option<Rect<BorderImageSideWidth>> = None;
219    let mut outset: Option<Rect<NonNegative<LengthOrNumber>>> = None;
220    let mut repeat: Option<BorderImageRepeat> = None;
221    loop {
222      if slice.is_none() {
223        if let Ok(value) = input.try_parse(|input| BorderImageSlice::parse(input)) {
224          slice = Some(value);
225          // Parse border image width and outset, if applicable.
226          let maybe_width_outset: Result<_, cssparser::ParseError<'_, ParserError<'i>>> =
227            input.try_parse(|input| {
228              input.expect_delim('/')?;
229
230              // Parse border image width, if applicable.
231              let w = input.try_parse(|input| Rect::parse(input)).ok();
232
233              // Parse border image outset if applicable.
234              let o = input
235                .try_parse(|input| {
236                  input.expect_delim('/')?;
237                  Rect::parse(input)
238                })
239                .ok();
240              if w.is_none() && o.is_none() {
241                Err(input.new_custom_error(ParserError::InvalidDeclaration))
242              } else {
243                Ok((w, o))
244              }
245            });
246          if let Ok((w, o)) = maybe_width_outset {
247            width = w;
248            outset = o;
249          }
250          continue;
251        }
252      }
253
254      if source.is_none() {
255        if let Ok(value) = input.try_parse(|input| Image::parse(input)) {
256          source = Some(value);
257          continue;
258        }
259      }
260
261      if repeat.is_none() {
262        if let Ok(value) = input.try_parse(|input| BorderImageRepeat::parse(input)) {
263          repeat = Some(value);
264          continue;
265        }
266      }
267
268      if callback(input) {
269        continue;
270      }
271
272      break;
273    }
274
275    if source.is_some() || slice.is_some() || width.is_some() || outset.is_some() || repeat.is_some() {
276      Ok(BorderImage {
277        source: source.unwrap_or_default(),
278        slice: slice.unwrap_or_default(),
279        width: width.unwrap_or(Rect::all(BorderImageSideWidth::default())),
280        outset: outset.unwrap_or(Rect::all(NonNegative(LengthOrNumber::default()))),
281        repeat: repeat.unwrap_or_default(),
282      })
283    } else {
284      Err(input.new_custom_error(ParserError::InvalidDeclaration))
285    }
286  }
287
288  pub(crate) fn to_css_internal<PrinterT: crate::printer::PrinterTrait>(
289    source: &Image<'i>,
290    slice: &BorderImageSlice,
291    width: &Rect<BorderImageSideWidth>,
292    outset: &Rect<NonNegative<LengthOrNumber>>,
293    repeat: &BorderImageRepeat,
294    dest: &mut PrinterT,
295  ) -> Result<(), PrinterError> {
296    let has_source = *source != Image::default();
297    let has_slice = *slice != BorderImageSlice::default();
298    let has_width = *width != Rect::all(BorderImageSideWidth::default());
299    let has_outset = *outset != Rect::all(NonNegative(LengthOrNumber::Number(0.0)));
300    let has_repeat = *repeat != BorderImageRepeat::default();
301
302    // A shorthand with only initial components must still have a value.
303    if !has_source && !has_slice && !has_width && !has_outset && !has_repeat {
304      dest.write_str("none")?;
305      return Ok(());
306    }
307
308    if has_source {
309      source.to_css(dest)?;
310    }
311    if has_slice || has_width || has_outset {
312      dest.write_str(" ")?;
313      slice.to_css(dest)?;
314      if has_width || has_outset {
315        dest.delim('/', true)?;
316      }
317      if has_width {
318        width.to_css(dest)?;
319      }
320
321      if has_outset {
322        dest.delim('/', true)?;
323        outset.to_css(dest)?;
324      }
325    }
326
327    if has_repeat {
328      dest.write_str(" ")?;
329      repeat.to_css(dest)?;
330    }
331
332    Ok(())
333  }
334}
335
336impl<'i> ToCss for BorderImage<'i> {
337  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
338    BorderImage::to_css_internal(&self.source, &self.slice, &self.width, &self.outset, &self.repeat, dest)
339  }
340}
341
342impl<'i> FallbackValues for BorderImage<'i> {
343  fn get_fallbacks(&mut self, targets: Targets) -> Vec<Self> {
344    self
345      .source
346      .get_fallbacks(targets)
347      .into_iter()
348      .map(|source| BorderImage { source, ..self.clone() })
349      .collect()
350  }
351}
352
353property_bitflags! {
354  #[derive(Default, Debug)]
355  struct BorderImageProperty: u16 {
356    const BorderImageSource = 1 << 0;
357    const BorderImageSlice = 1 << 1;
358    const BorderImageWidth = 1 << 2;
359    const BorderImageOutset = 1 << 3;
360    const BorderImageRepeat = 1 << 4;
361    const BorderImage(_vp) = Self::BorderImageSource.bits() | Self::BorderImageSlice.bits() | Self::BorderImageWidth.bits() | Self::BorderImageOutset.bits() | Self::BorderImageRepeat.bits();
362  }
363}
364
365#[derive(Debug)]
366pub(crate) struct BorderImageHandler<'i> {
367  source: Option<Image<'i>>,
368  slice: Option<BorderImageSlice>,
369  width: Option<Rect<BorderImageSideWidth>>,
370  outset: Option<Rect<NonNegative<LengthOrNumber>>>,
371  repeat: Option<BorderImageRepeat>,
372  vendor_prefix: VendorPrefix,
373  flushed_properties: BorderImageProperty,
374  has_any: bool,
375}
376
377impl<'i> Default for BorderImageHandler<'i> {
378  fn default() -> Self {
379    BorderImageHandler {
380      vendor_prefix: VendorPrefix::empty(),
381      source: None,
382      slice: None,
383      width: None,
384      outset: None,
385      repeat: None,
386      flushed_properties: BorderImageProperty::empty(),
387      has_any: false,
388    }
389  }
390}
391
392impl<'i> PropertyHandler<'i> for BorderImageHandler<'i> {
393  fn handle_property(
394    &mut self,
395    property: &Property<'i>,
396    dest: &mut DeclarationList<'i>,
397    context: &mut PropertyHandlerContext<'i, '_>,
398  ) -> bool {
399    use Property::*;
400    macro_rules! property {
401      ($name: ident, $val: ident) => {{
402        if self.vendor_prefix != VendorPrefix::None {
403          self.flush(dest, context);
404        }
405        flush!($name, $val);
406        self.vendor_prefix = VendorPrefix::None;
407        self.$name = Some($val.clone());
408        self.has_any = true;
409      }};
410    }
411
412    macro_rules! flush {
413      ($name: ident, $val: expr) => {{
414        if self.$name.is_some() && self.$name.as_ref().unwrap() != $val && matches!(context.targets.browsers, Some(targets) if !$val.is_compatible(targets)) {
415          self.flush(dest, context);
416        }
417      }};
418    }
419
420    match property {
421      BorderImageSource(val) => property!(source, val),
422      BorderImageSlice(val) => property!(slice, val),
423      BorderImageWidth(val) => property!(width, val),
424      BorderImageOutset(val) => property!(outset, val),
425      BorderImageRepeat(val) => property!(repeat, val),
426      BorderImage(val, vp) => {
427        flush!(source, &val.source);
428        flush!(slice, &val.slice);
429        flush!(width, &val.width);
430        flush!(outset, &val.outset);
431        flush!(repeat, &val.repeat);
432        self.source = Some(val.source.clone());
433        self.slice = Some(val.slice.clone());
434        self.width = Some(val.width.clone());
435        self.outset = Some(val.outset.clone());
436        self.repeat = Some(val.repeat.clone());
437        self.vendor_prefix |= *vp;
438        self.has_any = true;
439      }
440      Unparsed(val) if is_border_image_property(&val.property_id) => {
441        self.flush(dest, context);
442
443        // Even if we weren't able to parse the value (e.g. due to var() references),
444        // we can still add vendor prefixes to the property itself.
445        let mut unparsed = if matches!(val.property_id, PropertyId::BorderImage(_)) {
446          val.get_prefixed(context.targets, Feature::BorderImage)
447        } else {
448          val.clone()
449        };
450
451        context.add_unparsed_fallbacks(&mut unparsed);
452        self
453          .flushed_properties
454          .insert(BorderImageProperty::try_from(&unparsed.property_id).unwrap());
455        dest.push(Property::Unparsed(unparsed));
456      }
457      _ => return false,
458    }
459
460    true
461  }
462
463  fn finalize(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
464    self.flush(dest, context);
465    self.flushed_properties = BorderImageProperty::empty();
466  }
467}
468
469impl<'i> BorderImageHandler<'i> {
470  pub fn reset(&mut self) {
471    self.source = None;
472    self.slice = None;
473    self.width = None;
474    self.outset = None;
475    self.repeat = None;
476  }
477
478  pub fn will_flush(&self, property: &Property<'i>) -> bool {
479    use Property::*;
480    match property {
481      BorderImageSource(_) | BorderImageSlice(_) | BorderImageWidth(_) | BorderImageOutset(_)
482      | BorderImageRepeat(_) => self.vendor_prefix != VendorPrefix::None,
483      Unparsed(val) => is_border_image_property(&val.property_id),
484      _ => false,
485    }
486  }
487
488  fn flush(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
489    if !self.has_any {
490      return;
491    }
492
493    self.has_any = false;
494
495    macro_rules! push {
496      ($prop: ident, $val: expr) => {
497        dest.push(Property::$prop($val));
498        self.flushed_properties.insert(BorderImageProperty::$prop);
499      };
500    }
501
502    let source = std::mem::take(&mut self.source);
503    let slice = std::mem::take(&mut self.slice);
504    let width = std::mem::take(&mut self.width);
505    let outset = std::mem::take(&mut self.outset);
506    let repeat = std::mem::take(&mut self.repeat);
507
508    if source.is_some() && slice.is_some() && width.is_some() && outset.is_some() && repeat.is_some() {
509      let mut border_image = BorderImage {
510        source: source.unwrap(),
511        slice: slice.unwrap(),
512        width: width.unwrap(),
513        outset: outset.unwrap(),
514        repeat: repeat.unwrap(),
515      };
516
517      let mut prefix = self.vendor_prefix;
518      if prefix.contains(VendorPrefix::None) && !border_image.slice.fill {
519        prefix = context.targets.prefixes(self.vendor_prefix, Feature::BorderImage);
520        if !self.flushed_properties.intersects(BorderImageProperty::BorderImage) {
521          let fallbacks = border_image.get_fallbacks(context.targets);
522          for fallback in fallbacks {
523            // Match prefix of fallback. e.g. -webkit-linear-gradient
524            // can only be used in -webkit-border-image, not -moz-border-image.
525            // However, if border-image is unprefixed, gradients can still be.
526            let mut p = fallback.source.get_vendor_prefix() & prefix;
527            if p.is_empty() {
528              p = prefix;
529            }
530            dest.push(Property::BorderImage(fallback, p));
531          }
532        }
533      }
534
535      let p = border_image.source.get_vendor_prefix() & prefix;
536      if !p.is_empty() {
537        prefix = p;
538      }
539
540      dest.push(Property::BorderImage(border_image, prefix));
541      self.flushed_properties.insert(BorderImageProperty::BorderImage);
542    } else {
543      if let Some(mut source) = source {
544        if !self.flushed_properties.contains(BorderImageProperty::BorderImageSource) {
545          let fallbacks = source.get_fallbacks(context.targets);
546          for fallback in fallbacks {
547            dest.push(Property::BorderImageSource(fallback));
548          }
549        }
550
551        push!(BorderImageSource, source);
552      }
553
554      if let Some(slice) = slice {
555        push!(BorderImageSlice, slice);
556      }
557
558      if let Some(width) = width {
559        push!(BorderImageWidth, width);
560      }
561
562      if let Some(outset) = outset {
563        push!(BorderImageOutset, outset);
564      }
565
566      if let Some(repeat) = repeat {
567        push!(BorderImageRepeat, repeat);
568      }
569    }
570
571    self.vendor_prefix = VendorPrefix::empty();
572  }
573}
574
575#[inline]
576fn is_border_image_property(property_id: &PropertyId) -> bool {
577  match property_id {
578    PropertyId::BorderImageSource
579    | PropertyId::BorderImageSlice
580    | PropertyId::BorderImageWidth
581    | PropertyId::BorderImageOutset
582    | PropertyId::BorderImageRepeat
583    | PropertyId::BorderImage(_) => true,
584    _ => false,
585  }
586}