Merge pull request #25 from NervJS/feat/flat-structure

Feat/flat structure

Author: heiazu

__test__/index.spec.mjs.md

@@ -6,23 +6,20 @@ use lightningcss::{
   values::color::CssColor,
 };
 use smallvec::SmallVec;
-use swc_common::DUMMY_SP;
-use swc_ecma_ast::{Expr, Ident, KeyValueProp, ObjectLit, Prop, PropName, PropOrSpread};
-
-use crate::style_transform::traits::ToExpr;
 
 use super::{
-  background_color::BackgroundColor,
   background_image::{parse_background_image_item, BackgroundImage},
-  background_position::{parse_background_position_item, BackgroundImagePosition},
-  background_size::{parse_background_size_item, BackgroundImageSize},
+  background_position::{parse_background_position_item, BackgroundPosition},
+  background_size::{parse_background_size_item, BackgroundSize}, background_color::BackgroundColor, background_repeat::{parse_background_repeat_item, BackgroundRepeat},
 };
 
 fn parse_background(background: &SmallVec<[LNBackground<'_>; 1]>) -> Background {
   let mut background_image = vec![];
   let mut background_position = vec![];
   let mut background_size = vec![];
   let mut background_color = None;
+  let mut background_repeat = vec![];
+
   for item in background.iter() {
     if let Some(image) = parse_background_image_item(&item.image, &item.repeat) {
       background_image.push(image);
@@ -31,6 +28,7 @@ fn parse_background(background: &SmallVec<[LNBackground<'_>; 1]>) -> Background
     if let Some(size) = parse_background_size_item(&item.size) {
       background_size.push(size);
     }
+    background_repeat.push(parse_background_repeat_item(&item.repeat));
     if item.color != CssColor::default() {
       background_color = Some(
         item
@@ -47,75 +45,49 @@ fn parse_background(background: &SmallVec<[LNBackground<'_>; 1]>) -> Background
       );
     }
   }
-  Background {
-    image: BackgroundImage(background_image),
-    position: BackgroundImagePosition(background_position),
-    size: BackgroundImageSize(background_size),
-    color: BackgroundColor(background_color.unwrap_or("".to_string())),
+  let mut bg = Background::new();
+  if background_image.len() > 0 {
+    bg.image = Some(BackgroundImage(background_image));
+  }
+  if background_position.len() > 0 {
+    bg.position = Some(BackgroundPosition(background_position));
+  }
+  if background_size.len() > 0 {
+    bg.size = Some(BackgroundSize(background_size));
   }
+  if background_repeat.len() > 0 {
+    bg.repeat = Some(BackgroundRepeat(background_repeat));
+  }
+  if let Some(color) = background_color {
+    bg.color = Some(BackgroundColor(color));
+  }
+  bg
 }
 
 #[derive(Debug, Clone)]
 pub struct Background {
-  pub image: BackgroundImage,
-  pub color: BackgroundColor,
-  pub size: BackgroundImageSize,
-  pub position: BackgroundImagePosition,
+  pub image: Option<BackgroundImage>,
+  pub color: Option<BackgroundColor>,
+  pub size: Option<BackgroundSize>,
+  pub position: Option<BackgroundPosition>,
+  pub repeat: Option<BackgroundRepeat>
 }
 
 impl Background {
   pub fn new() -> Self {
     Background {
-      image: BackgroundImage(vec![]),
-      color: BackgroundColor("".to_string()),
-      size: BackgroundImageSize(vec![]),
-      position: BackgroundImagePosition(vec![]),
-    }
-  }
-}
-
-impl ToExpr for Background {
-  fn to_expr(&self) -> Expr {
-    let mut arr = vec![];
-    if self.image.0.len() > 0 {
-      arr.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-        key: PropName::Ident(Ident::new("image".into(), DUMMY_SP)),
-        value: self.image.to_expr().into(),
-      }))))
-    }
-    if self.color.to_string() != "" {
-      arr.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-        key: PropName::Ident(Ident::new("color".into(), DUMMY_SP)),
-        value: self.color.to_expr().into(),
-      }))))
-    }
-    if self.size.0.len() > 0 {
-      arr.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-        key: PropName::Ident(Ident::new("size".into(), DUMMY_SP)),
-        value: self.size.to_expr().into(),
-      }))))
-    }
-    if self.position.0.len() > 0 {
-      arr.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-        key: PropName::Ident(Ident::new("position".into(), DUMMY_SP)),
-        value: self.position.to_expr().into(),
-      }))))
+      image: None,
+      color: None,
+      size: None,
+      position: None,
+      repeat: None
     }
-    Expr::Object(ObjectLit {
-      span: DUMMY_SP,
-      props: arr.into(),
-    })
   }
 }
 
 impl From<&Property<'_>> for Background {
   fn from(value: &Property<'_>) -> Self {
-    let mut background = Background {
-      image: BackgroundImage(vec![]),
-      color: BackgroundColor("".to_string()),
-      size: BackgroundImageSize(vec![]),
-      position: BackgroundImagePosition(vec![]),
-    };
+    let mut background = Background::new();
     if let Property::Background(value) = value {
       background = parse_background(&value);
     }

__test__/index.spec.mjs.snap

@@ -200,23 +200,15 @@ impl ToExpr for BackgroundImage {
         .0
         .iter()
         .enumerate()
-        .map(|(index, item)| match &item.image {
+        .map(|(_, item)| match &item.image {
           BackgroundImageKind::String(src) => Some(
             Expr::Object(ObjectLit {
               span: DUMMY_SP,
               props: vec![
                 PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
                   key: PropName::Ident(Ident::new("src".into(), DUMMY_SP)),
                   value: Expr::Lit(Lit::Str(Str::from(src.to_string()))).into(),
-                }))),
-                PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-                  key: PropName::Ident(Ident::new("repeat".into(), DUMMY_SP)),
-                  value: if let Some(repeat) = &self.0[index].repeat {
-                    repeat.to_expr().into()
-                  } else {
-                    Expr::Lit(Lit::Str(Str::from("NoRepeat"))).into()
-                  },
-                }))),
+                })))
               ]
               .into(),
             })
@@ -250,4 +242,4 @@ impl From<(&Property<'_>, Option<&Property<'_>>)> for BackgroundImage {
     }
     background_image_res
   }
-}
+}

src/style_parser.rs

@@ -1,5 +1,5 @@
 use lightningcss::{
-  properties::{background::BackgroundPosition, Property},
+  properties::{background::BackgroundPosition as LNBackgroundPosition, Property},
   stylesheet::PrinterOptions,
   traits::ToCss,
   values::position::{
@@ -17,7 +17,7 @@ use swc_ecma_ast::{
 
 use crate::{style_transform::traits::ToExpr, utils::convert_px_to_units};
 
-pub fn parse_background_position_item(position: &BackgroundPosition) -> ImagePosition {
+pub fn parse_background_position_item(position: &LNBackgroundPosition) -> ImagePosition {
   match &position.x {
     Center => match &position.y {
       Center => ImagePosition::Center,
@@ -94,13 +94,13 @@ pub fn parse_background_position_item(position: &BackgroundPosition) -> ImagePos
 }
 
 pub fn parse_background_position(
-  position: &SmallVec<[BackgroundPosition; 1]>,
-) -> BackgroundImagePosition {
+  position: &SmallVec<[LNBackgroundPosition; 1]>,
+) -> BackgroundPosition {
   let mut background_position = vec![];
   for item in position {
     background_position.push(parse_background_position_item(item));
   }
-  BackgroundImagePosition(background_position)
+  BackgroundPosition(background_position)
 }
 
 #[derive(Debug, Clone)]
@@ -118,9 +118,9 @@ pub enum ImagePosition {
 }
 
 #[derive(Debug, Clone)]
-pub struct BackgroundImagePosition(pub Vec<ImagePosition>);
+pub struct BackgroundPosition(pub Vec<ImagePosition>);
 
-impl ToExpr for BackgroundImagePosition {
+impl ToExpr for BackgroundPosition {
   fn to_expr(&self) -> Expr {
     Expr::Array(ArrayLit {
       span: DUMMY_SP,
@@ -241,9 +241,9 @@ impl ToExpr for BackgroundImagePosition {
   }
 }
 
-impl From<&Property<'_>> for BackgroundImagePosition {
+impl From<&Property<'_>> for BackgroundPosition {
   fn from(value: &Property<'_>) -> Self {
-    let mut background_image_position = BackgroundImagePosition(vec![]);
+    let mut background_image_position = BackgroundPosition(vec![]);
     match value {
       Property::BackgroundPosition(value) => {
         background_image_position = parse_background_position(&value);

src/style_transform/background/background.rs

@@ -1,12 +1,24 @@
 use lightningcss::properties::{
-  background::{BackgroundRepeat, BackgroundRepeatKeyword},
+  background::{BackgroundRepeat as LNBackgroundRepeat, BackgroundRepeatKeyword},
   Property,
 };
 use swc_common::DUMMY_SP;
 use swc_ecma_ast::{ArrayLit, Expr, Ident, MemberExpr, MemberProp};
 
 use crate::style_transform::traits::ToExpr;
 
+pub fn parse_background_repeat_item(value: &LNBackgroundRepeat) -> ImageRepeatItem {
+  if value.x == BackgroundRepeatKeyword::Repeat && value.y == BackgroundRepeatKeyword::Repeat {
+    ImageRepeatItem::XY
+  } else if value.x == BackgroundRepeatKeyword::Repeat {
+    ImageRepeatItem::X
+  } else if value.y == BackgroundRepeatKeyword::Repeat {
+    ImageRepeatItem::Y
+  } else {
+    ImageRepeatItem::NoRepeat
+  }
+}
+
 #[derive(Debug, Clone)]
 pub enum ImageRepeatItem {
   XY,
@@ -15,17 +27,9 @@ pub enum ImageRepeatItem {
   NoRepeat,
 }
 
-impl From<&BackgroundRepeat> for ImageRepeatItem {
-  fn from(value: &BackgroundRepeat) -> Self {
-    if value.x == BackgroundRepeatKeyword::Repeat && value.y == BackgroundRepeatKeyword::Repeat {
-      Self::XY
-    } else if value.x == BackgroundRepeatKeyword::Repeat {
-      Self::X
-    } else if value.y == BackgroundRepeatKeyword::Repeat {
-      Self::Y
-    } else {
-      Self::NoRepeat
-    }
+impl From<&LNBackgroundRepeat> for ImageRepeatItem {
+  fn from(value: &LNBackgroundRepeat) -> Self {
+    parse_background_repeat_item(value)
   }
 }
 
@@ -49,9 +53,9 @@ impl ToExpr for ImageRepeatItem {
 }
 
 #[derive(Debug, Clone)]
-pub struct ImageRepeat(pub Vec<ImageRepeatItem>);
+pub struct BackgroundRepeat(pub Vec<ImageRepeatItem>);
 
-impl From<&Property<'_>> for ImageRepeat {
+impl From<&Property<'_>> for BackgroundRepeat {
   fn from(value: &Property<'_>) -> Self {
     let mut image_repeat = vec![];
     match value {
@@ -62,11 +66,11 @@ impl From<&Property<'_>> for ImageRepeat {
       }
       _ => {}
     }
-    ImageRepeat(image_repeat)
+    BackgroundRepeat(image_repeat)
   }
 }
 
-impl ToExpr for ImageRepeat {
+impl ToExpr for BackgroundRepeat {
   fn to_expr(&self) -> Expr {
     Expr::Array(ArrayLit {
       span: DUMMY_SP,

src/style_transform/background/background_image.rs

@@ -1,5 +1,5 @@
 use lightningcss::{
-  properties::{background::BackgroundSize, Property},
+  properties::{background::BackgroundSize as LNBackgroundSize, Property},
   stylesheet::PrinterOptions,
   traits::ToCss,
   values::length::LengthPercentageOrAuto,
@@ -13,32 +13,34 @@ use swc_ecma_ast::{
 
 use crate::{style_transform::traits::ToExpr, utils::convert_px_to_units};
 
-pub fn parse_background_size_item(size_item: &BackgroundSize) -> Option<ImageSize> {
+pub fn parse_background_size_item(size_item: &LNBackgroundSize) -> Option<ImageSize> {
   match size_item {
-    BackgroundSize::Contain => Some(ImageSize::Contain),
-    BackgroundSize::Cover => Some(ImageSize::Cover),
-    BackgroundSize::Explicit { width, height } => match width {
-      LengthPercentageOrAuto::Auto => match height {
-        LengthPercentageOrAuto::Auto => Some(ImageSize::Auto),
-        _ => None,
-      },
-      LengthPercentageOrAuto::LengthPercentage(x) => {
-        let x_str = x.to_css_string(PrinterOptions::default()).unwrap();
-        match height {
-          LengthPercentageOrAuto::LengthPercentage(y) => {
-            let y_str = y.to_css_string(PrinterOptions::default()).unwrap();
-            Some(ImageSize::ImageSizeWH(x_str, Some(y_str)))
-          },
-          LengthPercentageOrAuto::Auto => {
-              Some(ImageSize::ImageSizeWH(x_str, None))
+    LNBackgroundSize::Contain => Some(ImageSize::Contain),
+    LNBackgroundSize::Cover => Some(ImageSize::Cover),
+    LNBackgroundSize::Explicit { width, height } => {
+      match width {
+        LengthPercentageOrAuto::Auto => match height {
+          LengthPercentageOrAuto::Auto => Some(ImageSize::Auto),
+          _ => None,
+        },
+        LengthPercentageOrAuto::LengthPercentage(x) => {
+          let x_str = x.to_css_string(PrinterOptions::default()).unwrap();
+          match height {
+            LengthPercentageOrAuto::LengthPercentage(y) => {
+              let y_str = y.to_css_string(PrinterOptions::default()).unwrap();
+              Some(ImageSize::ImageSizeWH(x_str, Some(y_str)))
+            },
+            LengthPercentageOrAuto::Auto => {
+                Some(ImageSize::ImageSizeWH(x_str, None))
+            }
           }
-        }
-      },
-    },
+        },
+      }
+    }
   }
 }
 
-pub fn parse_background_size(size: &SmallVec<[BackgroundSize; 1]>) -> BackgroundImageSize {
+pub fn parse_background_size(size: &SmallVec<[LNBackgroundSize; 1]>) -> BackgroundSize {
   let mut background_size = vec![];
   for item in size {
     let item_size = parse_background_size_item(item);
@@ -47,7 +49,7 @@ pub fn parse_background_size(size: &SmallVec<[BackgroundSize; 1]>) -> Background
     }
   }
 
-  BackgroundImageSize(background_size)
+  BackgroundSize(background_size)
 }
 
 #[derive(Debug, Clone)]
@@ -59,9 +61,9 @@ pub enum ImageSize {
 }
 
 #[derive(Debug, Clone)]
-pub struct BackgroundImageSize(pub Vec<ImageSize>);
+pub struct BackgroundSize(pub Vec<ImageSize>);
 
-impl ToExpr for BackgroundImageSize {
+impl ToExpr for BackgroundSize {
   fn to_expr(&self) -> Expr {
     Expr::Array(ArrayLit {
       span: DUMMY_SP,
@@ -130,9 +132,9 @@ impl ToExpr for BackgroundImageSize {
   }
 }
 
-impl From<&Property<'_>> for BackgroundImageSize {
+impl From<&Property<'_>> for BackgroundSize {
   fn from(value: &Property<'_>) -> Self {
-    let mut background_image_size = BackgroundImageSize(vec![]);
+    let mut background_image_size = BackgroundSize(vec![]);
     match value {
       Property::BackgroundSize(value) => {
         background_image_size = parse_background_size(&value);