Fix coverage

Author: owjs3901

libs/css/src/lib.rs

@@ -487,6 +487,17 @@ mod tests {
             ),
             ".cls:hover"
         );
+
+        assert_eq!(
+            merge_selector(
+                "cls",
+                Some(&StyleSelector::Global(
+                    "&".to_string(),
+                    "file.ts".to_string()
+                ))
+            ),
+            "&"
+        );
     }
 
     #[test]

libs/extractor/src/css_utils.rs

@@ -135,9 +135,7 @@ pub fn keyframes_to_keyframes_style<'a>(
         let rest = &input[start + 1..];
         if let Some(end) = rest.find('}') {
             let block = &rest[..end];
-            let mut styles = css_to_style(block, 0, &None)
-                .into_iter()
-                .collect::<Vec<_>>();
+            let mut styles = css_to_style(block, 0, &None);
 
             styles.sort_by_key(|a| {
                 if let crate::ExtractStyleProp::Static(crate::ExtractStyleValue::Static(a)) = a {

libs/extractor/src/extractor/extract_global_style_from_expression.rs

@@ -71,38 +71,24 @@ pub fn extract_global_style_from_expression<'a>(
                     if let Expression::ArrayExpression(arr) = &o.value {
                         for p in arr.elements.iter() {
                             if let ArrayExpressionElement::ObjectExpression(o) = p {
-                                styles.push(ExtractStyleProp::Static(ExtractStyleValue::FontFace(
-                                    ExtractFontFace {
-                                        properties: BTreeMap::from_iter(
-                                            o.properties.iter().filter_map(|p| {
+                                styles.push(ExtractStyleProp::Static(ExtractStyleValue::FontFace(ExtractFontFace {
+                                    properties: BTreeMap::from_iter(
+                                        o.properties
+                                            .iter()
+                                            .filter_map(|p| {
                                                 if let ObjectPropertyKind::ObjectProperty(o) = p
-                                                    && let PropertyKey::StaticIdentifier(ident) =
-                                                        &o.key
-                                                    && let Some(s) =
-                                                        get_string_by_literal_expression(&o.value)
+                                                    && let PropertyKey::StaticIdentifier(ident) = &o.key
+                                                    && let Some(s) = get_string_by_literal_expression(&o.value)
                                                 {
-                                                    Some(
-                                                        disassemble_property(&ident.name)
-                                                            .iter()
-                                                            .map(|p| {
-                                                                (p.to_string(), if check_multi_css_optimize(p) {
-                                                                    optimize_mutli_css_value(
-                                                                        &s
-                                                                    )
-                                                                } else {
-                                                                    s.clone()
-                                                                })
-                                                            })
-                                                            .collect::<Vec<_>>(),
-                                                    )
+                                                    Some(disassemble_property(&ident.name).iter().map(|p| (p.to_string(), if check_multi_css_optimize(p) { optimize_mutli_css_value(&s) } else { s.clone() })).collect::<Vec<_>>())
                                                 } else {
                                                     None
                                                 }
-                                            }).flatten()
-                                        ),
-                                        file: file.to_string(),
-                                    },
-                                )));
+                                            })
+                                            .flatten(),
+                                    ),
+                                    file: file.to_string(),
+                                })));
                             } else if let ArrayExpressionElement::TemplateLiteral(t) = p {
                                 let css_styles = css_to_style(
                                     t.quasis

libs/extractor/src/extractor/extract_keyframes_from_expression.rs

@@ -18,21 +18,24 @@ pub fn extract_keyframes_from_expression<'a>(
 
     if let Expression::ObjectExpression(obj) = expression {
         for p in obj.properties.iter_mut() {
-            if let ObjectPropertyKind::ObjectProperty(o) = p {
-                let name = if let PropertyKey::StaticIdentifier(ident) = &o.key {
-                    ident.name.to_string()
+            if let ObjectPropertyKind::ObjectProperty(o) = p
+                && let Some(name) = if let PropertyKey::StaticIdentifier(ident) = &o.key {
+                    Some(ident.name.to_string())
                 } else if let PropertyKey::StringLiteral(s) = &o.key {
-                    s.value.to_string()
+                    Some(s.value.to_string())
                 } else if let PropertyKey::TemplateLiteral(t) = &o.key {
-                    t.quasis
-                        .iter()
-                        .map(|q| q.value.raw.as_str())
-                        .collect::<String>()
+                    Some(
+                        t.quasis
+                            .iter()
+                            .map(|q| q.value.raw.as_str())
+                            .collect::<String>(),
+                    )
                 } else if let PropertyKey::NumericLiteral(n) = &o.key {
-                    n.value.to_string()
+                    Some(n.value.to_string())
                 } else {
-                    continue;
-                };
+                    None
+                }
+            {
                 let mut styles =
                     extract_style_from_expression(ast_builder, None, &mut o.value, 0, &None)
                         .styles