Optimize

Author: owjs3901

libs/css/src/optimize_value.rs

@@ -89,14 +89,14 @@ pub fn optimize_value(value: &str) -> String {
             ret = s;
         }
 
+        let mut lower = ret.to_lowercase();
         for f in ZERO_PERCENT_FUNCTION.iter() {
-            let tmp = ret.to_lowercase();
-            if tmp.contains(f) {
-                let index = tmp.find(f).unwrap() + f.len();
+            if lower.contains(f) {
+                let index = lower.find(f).unwrap() + f.len();
                 let mut zero_idx = Vec::with_capacity(4);
                 let mut depth = 0;
-                let chars: Vec<char> = tmp.chars().collect();
-                let byte_indices: Vec<usize> = tmp.char_indices().map(|(i, _)| i).collect();
+                let chars: Vec<char> = lower.chars().collect();
+                let byte_indices: Vec<usize> = lower.char_indices().map(|(i, _)| i).collect();
 
                 for (char_idx, &ch) in chars.iter().enumerate().skip(index) {
                     if ch == '(' {
@@ -115,6 +115,8 @@ pub fn optimize_value(value: &str) -> String {
                 for i in zero_idx.iter().rev() {
                     ret.replace_range(*i..*i + 1, "0%");
                 }
+                // Refresh lowercase after modification for subsequent iterations
+                lower = ret.to_lowercase();
             }
         }
     }
@@ -181,25 +183,35 @@ fn optimize_color(value: &str) -> String {
     let mut ret = value.to_uppercase();
 
     if ret.len() == 6 {
-        let ch = ret.chars().collect::<Vec<char>>();
-        if ch[0] == ch[1] && ch[2] == ch[3] && ch[4] == ch[5] {
-            ret = format!("{}{}{}", ch[0], ch[2], ch[4]);
+        let b = ret.as_bytes();
+        if b[0] == b[1] && b[2] == b[3] && b[4] == b[5] {
+            let (c0, c2, c4) = (b[0], b[2], b[4]);
+            ret.clear();
+            ret.push(c0 as char);
+            ret.push(c2 as char);
+            ret.push(c4 as char);
         }
     } else if ret.len() == 8 {
-        let ch = ret.chars().collect::<Vec<char>>();
-        if ch[0] == ch[1] && ch[2] == ch[3] && ch[4] == ch[5] && ch[6] == ch[7] {
-            ret = format!("{}{}{}{}", ch[0], ch[2], ch[4], ch[6]);
-            if ret.ends_with("F") {
-                ret = ret[..ret.len() - 1].to_string();
+        let b = ret.as_bytes();
+        if b[0] == b[1] && b[2] == b[3] && b[4] == b[5] && b[6] == b[7] {
+            let (c0, c2, c4, c6) = (b[0], b[2], b[4], b[6]);
+            let has_trailing_f = c6 == b'F';
+            ret.clear();
+            ret.push(c0 as char);
+            ret.push(c2 as char);
+            ret.push(c4 as char);
+            if !has_trailing_f {
+                ret.push(c6 as char);
             }
         } else if ret.ends_with("FF") {
-            ret = ret[..ret.len() - 2].to_string();
+            ret.truncate(ret.len() - 2);
         }
-    } else if ret.len() == 4 && ret.ends_with("F") {
-        ret = ret[..ret.len() - 1].to_string();
+    } else if ret.len() == 4 && ret.ends_with('F') {
+        ret.truncate(ret.len() - 1);
     }
 
-    format!("#{ret}")
+    ret.insert(0, '#');
+    ret
 }
 
 #[cfg(test)]

libs/extractor/src/css_utils.rs

@@ -62,7 +62,7 @@ pub fn css_to_style_literal<'a>(
     // Build a combined CSS string with unique placeholders for expressions
     // Use a format that won't conflict with actual CSS values
     let mut css_parts = Vec::new();
-    let mut expression_map = std::collections::HashMap::new();
+    let mut expression_map = std::collections::HashMap::with_capacity(css.expressions.len());
 
     for (i, quasi) in css.quasis.iter().enumerate() {
         css_parts.push(quasi.value.raw.to_string());

libs/extractor/src/vanilla_extract.rs

@@ -545,99 +545,62 @@ fn remap_style_names(
     // Track the last processed theme's vars_object_json for ThemeVars handling
     let mut last_theme_vars_json: Option<String> = None;
 
-    // First pass: collect old entries preserving all fields
-    let old_styles: HashMap<String, StyleEntry> = collected.styles.drain().collect();
-    let old_keyframes: HashMap<String, StyleEntry> = collected.keyframes.drain().collect();
-    let old_style_variants: HashMap<String, HashMap<String, StyleVariant>> = collected
-        .style_variants
-        .drain()
-        .map(|(k, v)| (k, v.0))
-        .collect();
-    let old_vars: HashMap<String, String> = collected.vars.drain().map(|(k, v)| (k, v.0)).collect();
-    let old_containers: HashMap<String, String> = collected
-        .containers
-        .drain()
-        .map(|(k, v)| (k, v.0))
-        .collect();
-    let old_layers: HashMap<String, String> =
-        collected.layers.drain().map(|(k, v)| (k, v.0)).collect();
-    // font_faces: placeholder_id -> (json, font_family, exported)
-    let old_font_faces: HashMap<String, (String, String)> = collected
-        .font_faces
-        .drain()
-        .map(|(k, v)| (k, (v.0, v.1)))
-        .collect();
-    // global_themes: placeholder_id -> GlobalThemeEntry (without exported flag for remapping)
-    let old_global_themes: HashMap<String, GlobalThemeEntry> =
-        collected.global_themes.drain().collect();
-    // themes: placeholder_id -> ThemeEntry (without exported flag for remapping)
-    let old_themes: HashMap<String, ThemeEntry> = collected.themes.drain().collect();
+    // First pass: take ownership of old entries (avoids drain+collect overhead)
+    let mut old_styles = std::mem::take(&mut collected.styles);
+    let mut old_keyframes = std::mem::take(&mut collected.keyframes);
+    let mut old_style_variants = std::mem::take(&mut collected.style_variants);
+    let mut old_vars = std::mem::take(&mut collected.vars);
+    let mut old_containers = std::mem::take(&mut collected.containers);
+    let mut old_layers = std::mem::take(&mut collected.layers);
+    let mut old_font_faces = std::mem::take(&mut collected.font_faces);
+    let mut old_global_themes = std::mem::take(&mut collected.global_themes);
+    let mut old_themes = std::mem::take(&mut collected.themes);
 
     for (name, info) in vars {
         match info {
             VarInfo::StyleApi { exported } => {
                 // First check if this is a fontFace (uses __font_N__ placeholder)
                 let font_placeholder = format!("__font_{}__", font_idx);
-                if let Some((json, font_family)) = old_font_faces.get(&font_placeholder) {
-                    font_placeholder_to_name.insert(font_placeholder.clone(), name.clone());
-                    new_font_faces
-                        .insert(name.clone(), (json.clone(), font_family.clone(), *exported));
+                if let Some((json, font_family, _)) = old_font_faces.remove(&font_placeholder) {
+                    font_placeholder_to_name.insert(font_placeholder, name.clone());
+                    new_font_faces.insert(name.clone(), (json, font_family, *exported));
                     font_idx += 1;
                     continue;
                 }
 
                 // Check if this is a createGlobalTheme (uses __global_theme_N__ placeholder)
                 let global_theme_placeholder = format!("__global_theme_{}__", global_theme_idx);
-                if let Some(entry) = old_global_themes.get(&global_theme_placeholder) {
-                    new_global_themes.insert(
-                        name.clone(),
-                        GlobalThemeEntry {
-                            selector: entry.selector.clone(),
-                            css_vars: entry.css_vars.clone(),
-                            vars_object_json: entry.vars_object_json.clone(),
-                            exported: *exported,
-                        },
-                    );
+                if let Some(mut entry) = old_global_themes.remove(&global_theme_placeholder) {
+                    entry.exported = *exported;
+                    new_global_themes.insert(name.clone(), entry);
                     global_theme_idx += 1;
                     continue;
                 }
 
                 let placeholder = format!("__style_{}__", style_idx);
                 placeholder_to_name.insert(placeholder.clone(), name.clone());
 
-                if let Some(entry) = old_styles.get(&placeholder) {
-                    new_styles.insert(
-                        name.clone(),
-                        StyleEntry {
-                            json: entry.json.clone(),
-                            exported: *exported,
-                            bases: entry.bases.clone(),
-                        },
-                    );
+                if let Some(mut entry) = old_styles.remove(&placeholder) {
+                    entry.exported = *exported;
+                    new_styles.insert(name.clone(), entry);
                     style_idx += 1;
-                } else if let Some(entry) = old_keyframes.get(&placeholder) {
-                    new_keyframes.insert(
-                        name.clone(),
-                        StyleEntry {
-                            json: entry.json.clone(),
-                            exported: *exported,
-                            bases: entry.bases.clone(),
-                        },
-                    );
+                } else if let Some(mut entry) = old_keyframes.remove(&placeholder) {
+                    entry.exported = *exported;
+                    new_keyframes.insert(name.clone(), entry);
                     style_idx += 1;
-                } else if let Some(variants) = old_style_variants.get(&placeholder) {
-                    new_style_variants.insert(name.clone(), (variants.clone(), *exported));
+                } else if let Some((variants, _)) = old_style_variants.remove(&placeholder) {
+                    new_style_variants.insert(name.clone(), (variants, *exported));
                     style_idx += 1;
-                } else if let Some(value) = old_vars.get(&placeholder) {
-                    new_vars.insert(name.clone(), (value.clone(), *exported));
+                } else if let Some((value, _)) = old_vars.remove(&placeholder) {
+                    new_vars.insert(name.clone(), (value, *exported));
                     style_idx += 1;
-                } else if let Some(value) = old_containers.get(&placeholder) {
-                    new_containers.insert(name.clone(), (value.clone(), *exported));
+                } else if let Some((value, _)) = old_containers.remove(&placeholder) {
+                    new_containers.insert(name.clone(), (value, *exported));
                     style_idx += 1;
-                } else if let Some(value) = old_layers.get(&placeholder) {
-                    new_layers.insert(name.clone(), (value.clone(), *exported));
+                } else if let Some((value, _)) = old_layers.remove(&placeholder) {
+                    new_layers.insert(name.clone(), (value, *exported));
                     style_idx += 1;
-                } else if let Some(entry) = old_themes.get(&placeholder) {
+                } else if let Some(mut entry) = old_themes.remove(&placeholder) {
                     // Track this theme name for the next ThemeVars entry
                     if entry.vars_object_json.is_some() {
                         last_theme_vars_json = Some(name.clone());
@@ -662,16 +625,10 @@ fn remap_style_names(
                             .push((format!(".{}", class_name), vars_json));
                     }
 
-                    new_themes.insert(
-                        name.clone(),
-                        ThemeEntry {
-                            css_vars: entry.css_vars.clone(),
-                            exported: *exported,
-                            vars_object_json: entry.vars_object_json.clone(),
-                            vars_name: None, // Will be set by ThemeVars if present
-                            class_name,
-                        },
-                    );
+                    entry.exported = *exported;
+                    entry.vars_name = None;
+                    entry.class_name = class_name;
+                    new_themes.insert(name.clone(), entry);
                     style_idx += 1;
                 }
             }
@@ -705,30 +662,27 @@ fn remap_style_names(
 
     // Remap base references in styles (for composition)
     for entry in new_styles.values_mut() {
-        entry.bases = entry
-            .bases
-            .iter()
+        let old_bases = std::mem::take(&mut entry.bases);
+        entry.bases = old_bases
+            .into_iter()
             .map(|b| {
-                placeholder_to_name
-                    .get(b)
-                    .cloned()
-                    .unwrap_or_else(|| b.clone())
+                if let Some(name) = placeholder_to_name.get(&b) {
+                    name.clone()
+                } else {
+                    b
+                }
             })
             .collect();
     }
 
     // Replace font placeholders in style JSONs with actual font-family names
     // Build a mapping from placeholder to font-family name
-    let font_family_map: HashMap<String, String> = new_font_faces
+    let font_family_map: HashMap<&str, &str> = font_placeholder_to_name
         .iter()
-        .map(|(name, (_, font_family, _))| {
-            // Find the placeholder that maps to this name
-            let placeholder = font_placeholder_to_name
-                .iter()
-                .find(|(_, n)| *n == name)
-                .map(|(p, _)| p.clone())
-                .unwrap_or_default();
-            (placeholder, font_family.clone())
+        .filter_map(|(placeholder, name)| {
+            new_font_faces
+                .get(name)
+                .map(|(_, font_family, _)| (placeholder.as_str(), font_family.as_str()))
         })
         .collect();
 

libs/sheet/src/lib.rs

@@ -294,24 +294,21 @@ impl StyleSheet {
         self.font_faces.remove(file);
         let property_key = if single_css { "" } else { file }.to_string();
 
-        for map in self
-            .properties
-            .entry(property_key.clone())
-            .or_default()
-            .values_mut()
-        {
-            for props in map.values_mut() {
-                props.retain(|prop| {
-                    if let Some(StyleSelector::Global(_, f)) = prop.selector.as_ref() {
-                        f != file
-                    } else {
-                        true
-                    }
-                });
-            }
-            // remove empty map
-            if map.iter().all(|(_, v)| v.is_empty()) {
-                map.clear();
+        if let Some(prop_map) = self.properties.get_mut(&property_key) {
+            for map in prop_map.values_mut() {
+                for props in map.values_mut() {
+                    props.retain(|prop| {
+                        if let Some(StyleSelector::Global(_, f)) = prop.selector.as_ref() {
+                            f != file
+                        } else {
+                            true
+                        }
+                    });
+                }
+                // remove empty map
+                if map.iter().all(|(_, v)| v.is_empty()) {
+                    map.clear();
+                }
             }
         }
         if self
@@ -551,14 +548,14 @@ impl StyleSheet {
                     let mut selector_map: BTreeMap<_, Vec<_>> = BTreeMap::new();
                     for prop in non_layered_props {
                         if let Some(StyleSelector::Global(selector, _)) = &prop.selector {
-                            selector_map.entry(selector.clone()).or_default().push(prop);
+                            selector_map.entry(selector).or_default().push(prop);
                         }
                     }
                     if let Some(break_point) = break_point {
                         write!(current_css, "@media(min-width:{break_point}px){{").unwrap();
                     }
                     for (selector, props) in selector_map {
-                        current_css.push_str(&selector);
+                        current_css.push_str(selector);
                         current_css.push('{');
                         let mut first = true;
                         for prop in props {

libs/sheet/src/theme.rs

@@ -2,6 +2,7 @@ use css::optimize_value::optimize_value;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
 use std::collections::{BTreeMap, HashMap};
+use std::fmt::Write;
 
 /// ColorEntry stores both the original key (for TypeScript interface) and CSS key (for CSS variables)
 #[derive(Debug, Clone, Serialize)]
@@ -428,10 +429,10 @@ impl Theme {
                     Some(theme_name)
                 };
                 if let Some(theme_key) = theme_key {
-                    theme_declaration.push_str(format!(":root[data-theme={theme_key}]{{").as_str());
+                    write!(theme_declaration, ":root[data-theme={theme_key}]{{").unwrap();
                     css_contents.push("color-scheme:dark".to_string());
                 } else {
-                    theme_declaration.push_str(":root{".to_string().as_str());
+                    theme_declaration.push_str(":root{");
                     if !single_theme {
                         css_contents.push("color-scheme:light".to_string());
                     }
@@ -496,23 +497,23 @@ impl Theme {
                         t.font_family
                             .as_ref()
                             .map(|v| format!("font-family:{}", optimize_value(v)))
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                         t.font_size
                             .as_ref()
                             .map(|v| format!("font-size:{}", optimize_value(v)))
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                         t.font_weight
                             .as_ref()
                             .map(|v| format!("font-weight:{}", optimize_value(v)))
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                         t.line_height
                             .as_ref()
                             .map(|v| format!("line-height:{}", optimize_value(v)))
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                         t.letter_spacing
                             .as_ref()
                             .map(|v| format!("letter-spacing:{}", optimize_value(v)))
-                            .unwrap_or("".to_string()),
+                            .unwrap_or_default(),
                     ]
                     .iter()
                     .filter_map(|v| {
@@ -539,7 +540,7 @@ impl Theme {
                 .get(level as usize)
                 .map(|v| format!("(min-width:{v}px)"))
             {
-                css.push_str(format!("@media{media}{{{}}}", css_vec.join("")).as_str());
+                css.push_str(&format!("@media{media}{{{}}}", css_vec.join("")));
             }
         }
         css