Refactor selector

Author: owjs3901

libs/css/src/constant.rs

@@ -128,14 +128,15 @@ pub(super) static INNER_TRIM_RE: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"\(\s*([^)]*?)\s*\)").unwrap());
 
 pub(super) static RM_MINUS_ZERO_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"-0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|\)|,)").unwrap()
+    Regex::new(r"-0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg|\)|,)").unwrap()
 });
 
 pub(super) static NUM_TRIM_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(\d(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic)?)\s+(\d)").unwrap()
+    Regex::new(r"(\d(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)?)\s+(\d)")
+        .unwrap()
 });
 pub(super) static ZERO_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(r"(\b|,|\(|^|\s)-?0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic)")
+    Regex::new(r"(\b|,|\(|^|\s)-?0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)")
         .unwrap()
 });
 

libs/css/src/optimize_value.rs

@@ -221,6 +221,17 @@ mod tests {
     #[case("max(10px, calc(0", "max(10px,calc(0%))")]
     #[case("max(10px, any(0", "max(10px,any(0))")]
     #[case("10px, any(0))", "(10px,any(0))")]
+    #[case("scale(0deg, 0deg)", "scale(0,0)")]
+    #[case(
+        "scaleX(0deg) scaleY(0deg) scaleZ(0deg)",
+        "scaleX(0) scaleY(0) scaleZ(0)"
+    )]
+    #[case("scaleX(0deg)", "scaleX(0)")]
+    #[case("scaleY(0deg)", "scaleY(0)")]
+    #[case("scaleZ(0deg)", "scaleZ(0)")]
+    #[case("translate(0px) scale(0deg)", "translate(0) scale(0)")]
+    #[case("translate(-0px) scale(-0deg)", "translate(0) scale(0)")]
+    #[case("translate(-10px) scale(-10deg)", "translate(-10px) scale(-10deg)")]
     fn test_optimize_value(#[case] input: &str, #[case] expected: &str) {
         assert_eq!(optimize_value(input), expected);
     }

libs/css/src/style_selector.rs

@@ -93,6 +93,12 @@ impl Ord for StyleSelector {
 
 impl From<&str> for StyleSelector {
     fn from(value: &str) -> Self {
+        let value = value
+            .trim()
+            .split_whitespace()
+            .collect::<Vec<_>>()
+            .join(" ")
+            .replace(", ", ",");
         if value.contains("&") {
             StyleSelector::Selector(value.to_string())
         } else if let Some(s) = value.strip_prefix("group") {
@@ -116,7 +122,7 @@ impl From<&str> for StyleSelector {
                 selector: None,
             }
         } else {
-            let post = to_kebab_case(value);
+            let post = to_kebab_case(&value);
 
             StyleSelector::Selector(format!(
                 "&{}{}",
@@ -129,7 +135,11 @@ impl From<&str> for StyleSelector {
 
 impl From<[&str; 2]> for StyleSelector {
     fn from(value: [&str; 2]) -> Self {
-        let post = to_kebab_case(value[1]);
+        let post = if value[1].contains("&:") {
+            to_kebab_case(value[1].split(":").last().unwrap())
+        } else {
+            to_kebab_case(value[1])
+        };
         StyleSelector::Selector(format!(
             "{}{}{}",
             StyleSelector::from(value[0]),

libs/extractor/src/extractor/extract_style_from_expression.rs

@@ -173,22 +173,63 @@ pub fn extract_style_from_expression<'a>(
             let mut props = vec![];
             for p in obj.properties.iter_mut() {
                 if let ObjectPropertyKind::ObjectProperty(o) = p {
-                    let name = o.key.name().unwrap().to_string();
+                    let key_name = o.key.name().unwrap().to_string();
+                    let name = key_name.trim();
+                    let mut part_of_selector = vec![];
+
+                    let mut level = 0;
+                    let mut last_idx = 0;
+                    for (idx, c) in name.chars().enumerate() {
+                        if c == '(' {
+                            level += 1;
+                        }
+                        if c == ')' {
+                            level -= 1;
+                        }
+                        if c == ',' && level == 0 {
+                            part_of_selector.push(&name[last_idx..idx]);
+                            last_idx = idx + 1;
+                        }
+                        if idx == name.len() - 1 {
+                            part_of_selector.push(&name[last_idx..]);
+                        }
+                    }
+
+                    let sel = part_of_selector
+                        .iter()
+                        .map(|name| {
+                            let name = name.trim();
+                            if let Some(selector) = selector {
+                                if name.starts_with("_theme") {
+                                    StyleSelector::from([
+                                        name.replace("_theme", "theme").as_str(),
+                                        &selector.to_string(),
+                                    ])
+                                    .to_string()
+                                } else {
+                                    if name.contains("&") {
+                                        name.to_string().replace("&", &selector.to_string())
+                                    } else {
+                                        StyleSelector::from([
+                                            selector.to_string().replace("_", "").as_str(),
+                                            &name.replace("_", ""),
+                                        ])
+                                        .to_string()
+                                    }
+                                }
+                            } else {
+                                StyleSelector::from(name.replace("_", "").as_str()).to_string()
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                        .join(",");
                     props.extend(
                         extract_style_from_expression(
                             ast_builder,
                             None,
                             &mut o.value,
                             level,
-                            &Some(
-                                if let Some(selector) = selector {
-                                    name.replace("&", &selector.to_string())
-                                } else {
-                                    name
-                                }
-                                .as_str()
-                                .into(),
-                            ),
+                            &Some(StyleSelector::Selector(sel)),
                         )
                         .styles,
                     );