Add testcases

Author: owjs3901

libs/extractor/src/css_utils.rs

@@ -299,11 +299,87 @@ pub fn css_to_style_literal<'a>(
                     for (placeholder, idx) in &found_placeholders {
                         if *idx < css.expressions.len() {
                             let expr = &css.expressions[*idx];
+
+                            // Check if expression is a function (arrow function or function expression)
+                            let is_function = matches!(
+                                expr,
+                                oxc_ast::ast::Expression::ArrowFunctionExpression(_)
+                                    | oxc_ast::ast::Expression::FunctionExpression(_)
+                            );
+
                             let expr_code = expression_to_code(expr);
                             // Normalize the expression code while preserving string literals
-                            let normalized_code =
+                            let mut normalized_code =
                                 normalize_whitespace_preserving_strings(&expr_code);
 
+                            if is_function {
+                                // Normalize arrow function whitespace
+                                normalized_code = normalized_code
+                                    .replace(" => ", "=>")
+                                    .replace(" =>", "=>")
+                                    .replace("=> ", "=>");
+                                // Normalize function() { } to function(){ }
+                                normalized_code =
+                                    normalized_code.replace("function() {", "function(){");
+                                normalized_code =
+                                    normalized_code.replace("function (", "function(");
+                                // Remove trailing semicolon and spaces before closing brace
+                                normalized_code = normalized_code.replace("; }", "}");
+                                normalized_code = normalized_code.replace(" }", "}");
+
+                                // Wrap function in parentheses if not already wrapped
+                                let trimmed = normalized_code.trim();
+                                if !(trimmed.starts_with('(') && trimmed.ends_with(')')) {
+                                    normalized_code = format!("({})", trimmed);
+                                }
+                                // Add (rest) call
+                                normalized_code = format!("{}(rest)", normalized_code);
+
+                                // For function expressions, convert string literals in ternary operators
+                                let mut result = String::new();
+                                let mut chars = normalized_code.chars().peekable();
+                                let mut in_ternary_string = false;
+
+                                while let Some(ch) = chars.next() {
+                                    if ch == '?' || ch == ':' {
+                                        result.push(ch);
+                                        // Skip whitespace
+                                        while let Some(&' ') = chars.peek() {
+                                            result.push(chars.next().unwrap());
+                                        }
+                                        // Check if next is a string literal
+                                        if let Some(&'"') = chars.peek() {
+                                            in_ternary_string = true;
+                                            result.push('\'');
+                                            chars.next(); // consume the "
+                                        }
+                                    } else if in_ternary_string && ch == '"' {
+                                        // Check if this is a closing quote by looking ahead
+                                        let mut peeked = chars.clone();
+                                        // Skip whitespace
+                                        while let Some(&' ') = peeked.peek() {
+                                            peeked.next();
+                                        }
+                                        // If next is : or ? or ) or } or end, it's a closing quote
+                                        if peeked.peek().is_none()
+                                            || matches!(
+                                                peeked.peek(),
+                                                Some(&':') | Some(&'?') | Some(&')') | Some(&'}')
+                                            )
+                                        {
+                                            result.push('\'');
+                                            in_ternary_string = false;
+                                        } else {
+                                            // Not a closing quote, keep as is
+                                            result.push(ch);
+                                        }
+                                    } else {
+                                        result.push(ch);
+                                    }
+                                }
+                                normalized_code = result;
+                            }
+
                             // Replace placeholder with ${expr} syntax
                             let expr_template = format!("${{{}}}", normalized_code);
                             template_literal =
@@ -896,6 +972,9 @@ mod tests {
     #[case("`width: ${1}${2}px;`", vec![("width", "12px", None)])]
     #[case("`width: ${func(\n\t  1  ,   \n\t2\n)}px;`", vec![("width", "`${func(1,2)}px`", None)])]
     #[case("`width: ${func(\"  wow  \")}px;`", vec![("width", "`${func(\"  wow  \")}px`", None)])]
+    #[case("`width: ${func(\"hello\\nworld\")}px;`", vec![("width", "`${func(\"hello\\nworld\")}px`", None)])]
+    #[case("`width: ${func('test\\'quote')}px;`", vec![("width", "`${func(\"test'quote\")}px`", None)])]
+    #[case("`width: ${(props)=>props.b ? \"hello\\\"world\" : \"test\"}px;`", vec![("width", "`${((props)=>props.b ? 'hello\\\"world' : 'test')(rest)}px`", None)])]
     // wrong cases
     #[case(
         "`@media (min-width: 768px) {