Refactor

Author: owjs3901

libs/extractor/src/gen_class_name.rs

@@ -2,7 +2,7 @@ use crate::{ExtractStyleProp, StyleProperty};
 use oxc_allocator::CloneIn;
 use oxc_ast::AstBuilder;
 use oxc_ast::ast::{
-    Expression, JSXAttribute, JSXAttributeValue, JSXExpression, ObjectPropertyKind, PropertyKey,
+    Expression, ObjectPropertyKind, PropertyKey,
     PropertyKind, TemplateElement, TemplateElementValue,
 };
 use oxc_span::SPAN;
@@ -214,52 +214,3 @@ pub fn merge_expression_for_class_name<'a>(
         )))
     }
 }
-
-pub fn apply_class_name_attribute<'a>(
-    ast_builder: &AstBuilder<'a>,
-    class_prop: &mut JSXAttribute<'a>,
-    expression: Expression<'a>,
-) {
-    if let Some(ref value) = class_prop.value {
-        if let Some(ret) = match value {
-            JSXAttributeValue::StringLiteral(str) => merge_expression_for_class_name(
-                ast_builder,
-                vec![
-                    Expression::StringLiteral(str.clone_in(ast_builder.allocator)),
-                    expression,
-                ],
-            ),
-            JSXAttributeValue::ExpressionContainer(container) => match container.expression {
-                JSXExpression::EmptyExpression(_) => Some(expression),
-                _ => merge_expression_for_class_name(
-                    ast_builder,
-                    vec![
-                        container
-                            .expression
-                            .clone_in(ast_builder.allocator)
-                            .into_expression(),
-                        expression,
-                    ],
-                ),
-            },
-            _ => None,
-        } {
-            class_prop.value = match ret {
-                Expression::StringLiteral(literal) => Some(JSXAttributeValue::StringLiteral(
-                    literal.clone_in(ast_builder.allocator),
-                )),
-                _ => Some(JSXAttributeValue::ExpressionContainer(
-                    ast_builder.alloc_jsx_expression_container(SPAN, JSXExpression::from(ret)),
-                )),
-            }
-        }
-    } else {
-        class_prop.value = Some(if let Expression::StringLiteral(literal) = expression {
-            JSXAttributeValue::StringLiteral(literal.clone_in(ast_builder.allocator))
-        } else {
-            JSXAttributeValue::ExpressionContainer(
-                ast_builder.alloc_jsx_expression_container(SPAN, JSXExpression::from(expression)),
-            )
-        });
-    };
-}

libs/extractor/src/gen_style.rs

@@ -1,16 +1,13 @@
 use crate::{ExtractStyleProp, StyleProperty};
 use oxc_allocator::CloneIn;
 use oxc_ast::AstBuilder;
-use oxc_ast::ast::{
-    Expression, JSXAttribute, JSXAttributeValue, JSXExpression, ObjectExpression,
-    ObjectPropertyKind, PropertyKey, PropertyKind,
-};
+use oxc_ast::ast::{Expression, ObjectPropertyKind, PropertyKey, PropertyKind};
 use oxc_span::SPAN;
 use std::collections::BTreeMap;
 pub fn gen_styles<'a>(
     ast_builder: &AstBuilder<'a>,
     style_props: &[ExtractStyleProp<'a>],
-) -> Option<ObjectExpression<'a>> {
+) -> Option<Expression<'a>> {
     if style_props.is_empty() {
         return None;
     }
@@ -22,9 +19,11 @@ pub fn gen_styles<'a>(
     if properties.is_empty() {
         return None;
     }
-    Some(ast_builder.object_expression(
-        SPAN,
-        oxc_allocator::Vec::from_iter_in(properties, ast_builder.allocator),
+    Some(Expression::ObjectExpression(
+        ast_builder.alloc_object_expression(
+            SPAN,
+            oxc_allocator::Vec::from_iter_in(properties, ast_builder.allocator),
+        ),
     ))
 }
 fn gen_style<'a>(
@@ -345,39 +344,3 @@ fn gen_style<'a>(
     properties.reverse();
     properties
 }
-
-pub fn apply_style_attribute<'a>(
-    ast_builder: &AstBuilder<'a>,
-    style_prop: &mut JSXAttribute<'a>,
-    // must be an object expression
-    mut expression: ObjectExpression<'a>,
-) {
-    if let Some(ref mut value) = style_prop.value {
-        if let JSXAttributeValue::ExpressionContainer(container) = value {
-            if let Some(spread_property) = match &container.expression {
-                JSXExpression::ObjectExpression(obj) => Some(Expression::ObjectExpression(
-                    obj.clone_in(ast_builder.allocator),
-                )),
-                JSXExpression::Identifier(ident) => Some(Expression::Identifier(
-                    ident.clone_in(ast_builder.allocator),
-                )),
-                _ => None,
-            } {
-                expression.properties.insert(
-                    0,
-                    ObjectPropertyKind::SpreadProperty(
-                        ast_builder.alloc_spread_element(SPAN, spread_property),
-                    ),
-                );
-            }
-            container.expression = JSXExpression::ObjectExpression(ast_builder.alloc(expression));
-        }
-    } else {
-        style_prop.value = Some(JSXAttributeValue::ExpressionContainer(
-            ast_builder.alloc_jsx_expression_container(
-                SPAN,
-                JSXExpression::ObjectExpression(ast_builder.alloc(expression)),
-            ),
-        ));
-    };
-}

libs/extractor/src/lib.rs

@@ -1818,6 +1818,54 @@ export {
             )
             .unwrap()
         ));
+
+        reset_class_map();
+        assert_debug_snapshot!(ToBTreeSet::from(
+            extract(
+                "test.js",
+                r#"import { jsx as e } from "react/jsx-runtime";
+import { Box as o } from "@devup-ui/core";
+e(o, { className: "a", bg: "red" })
+"#,
+                ExtractOption {
+                    package: "@devup-ui/core".to_string(),
+                    css_file: None
+                }
+            )
+            .unwrap()
+        ));
+
+        reset_class_map();
+        assert_debug_snapshot!(ToBTreeSet::from(
+            extract(
+                "test.js",
+                r#"import { jsx as e } from "react/jsx-runtime";
+import { Box as o } from "@devup-ui/core";
+e(o, { className: "a", bg: variable, style: { color: "blue" } })
+"#,
+                ExtractOption {
+                    package: "@devup-ui/core".to_string(),
+                    css_file: None
+                }
+            )
+            .unwrap()
+        ));
+
+        reset_class_map();
+        assert_debug_snapshot!(ToBTreeSet::from(
+            extract(
+                "test.js",
+                r#"import { jsx as e } from "react/jsx-runtime";
+import { Box as o } from "@devup-ui/core";
+e(o, { className: "a", bg: variable, style: { color: "blue" }, ...props })
+"#,
+                ExtractOption {
+                    package: "@devup-ui/core".to_string(),
+                    css_file: None
+                }
+            )
+            .unwrap()
+        ));
     }
 
     #[test]
@@ -3260,4 +3308,24 @@ export {
             .unwrap()
         ));
     }
+
+    #[test]
+    #[serial]
+    fn style_variables_mjs() {
+        reset_class_map();
+        assert_debug_snapshot!(ToBTreeSet::from(
+            extract(
+                "test.js",
+                r#"import { jsx as e } from "react/jsx-runtime";
+import { Box as o } from "@devup-ui/core";
+e(o, { styleVars: { c: "yellow" } })
+"#,
+                ExtractOption {
+                    package: "@devup-ui/core".to_string(),
+                    css_file: None
+                }
+            )
+            .unwrap()
+        ));
+    }
 }