1use 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 pub enum BorderImageRepeatKeyword {
29 Stretch,
31 Repeat,
33 Round,
35 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#[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 pub horizontal: BorderImageRepeatKeyword,
60 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#[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 Number(NonNegative<CSSNumber>),
114 LengthPercentage(NonNegative<LengthPercentage>),
116 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#[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 pub offsets: Rect<NonNegative<NumberOrPercentage>>,
144 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 #[derive(Default)]
187 pub struct BorderImage<'i>(VendorPrefix) {
188 #[cfg_attr(feature = "serde", serde(borrow))]
190 source: BorderImageSource(Image<'i>),
191 slice: BorderImageSlice(BorderImageSlice),
193 width: BorderImageWidth(Rect<BorderImageSideWidth>),
195 outset: BorderImageOutset(Rect<NonNegative<LengthOrNumber>>),
197 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 let maybe_width_outset: Result<_, cssparser::ParseError<'_, ParserError<'i>>> =
227 input.try_parse(|input| {
228 input.expect_delim('/')?;
229
230 let w = input.try_parse(|input| Rect::parse(input)).ok();
232
233 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 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 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 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}