perf: reduce allocations via regex early-exit, write!() codegen, and iterator optimizations

Author: owjs3901

libs/css/src/optimize_value.rs

@@ -43,30 +43,34 @@ pub fn optimize_value(value: &str) -> String {
             ret = s;
         }
     }
-    let replaced = F_RGBA_RE.replace_all(&ret, |c: &regex_lite::Captures| {
-        let r = c[1].parse::<i32>().unwrap();
-        let g = c[2].parse::<i32>().unwrap();
-        let b = c[3].parse::<i32>().unwrap();
-        let a = c[4].parse::<f32>().unwrap();
-        format!(
-            "#{:02X}{:02X}{:02X}{:02X}",
-            r,
-            g,
-            b,
-            (a * 255.0).round() as i32
-        )
-    });
-    if let std::borrow::Cow::Owned(s) = replaced {
-        ret = s;
+    if ret.contains("rgba(") {
+        let replaced = F_RGBA_RE.replace_all(&ret, |c: &regex_lite::Captures| {
+            let r = c[1].parse::<i32>().unwrap();
+            let g = c[2].parse::<i32>().unwrap();
+            let b = c[3].parse::<i32>().unwrap();
+            let a = c[4].parse::<f32>().unwrap();
+            format!(
+                "#{:02X}{:02X}{:02X}{:02X}",
+                r,
+                g,
+                b,
+                (a * 255.0).round() as i32
+            )
+        });
+        if let std::borrow::Cow::Owned(s) = replaced {
+            ret = s;
+        }
     }
-    let replaced = F_RGB_RE.replace_all(&ret, |c: &regex_lite::Captures| {
-        let r = c[1].parse::<i32>().unwrap();
-        let g = c[2].parse::<i32>().unwrap();
-        let b = c[3].parse::<i32>().unwrap();
-        format!("#{r:02X}{g:02X}{b:02X}")
-    });
-    if let std::borrow::Cow::Owned(s) = replaced {
-        ret = s;
+    if ret.contains("rgb(") {
+        let replaced = F_RGB_RE.replace_all(&ret, |c: &regex_lite::Captures| {
+            let r = c[1].parse::<i32>().unwrap();
+            let g = c[2].parse::<i32>().unwrap();
+            let b = c[3].parse::<i32>().unwrap();
+            format!("#{r:02X}{g:02X}{b:02X}")
+        });
+        if let std::borrow::Cow::Owned(s) = replaced {
+            ret = s;
+        }
     }
     if ret.contains('#') {
         let replaced =
@@ -91,32 +95,33 @@ pub fn optimize_value(value: &str) -> String {
 
         let mut lower = ret.to_lowercase();
         for f in ZERO_PERCENT_FUNCTION.iter() {
-            if lower.contains(f) {
-                let index = lower.find(f).unwrap() + f.len();
+            if let Some(start) = lower.find(f) {
+                let index = start + f.len();
                 let mut zero_idx = Vec::with_capacity(4);
-                let mut depth = 0;
-                let chars: Vec<char> = lower.chars().collect();
-                let byte_indices: Vec<usize> = lower.char_indices().map(|(i, _)| i).collect();
+                let mut depth: i32 = 0;
+                let bytes = lower.as_bytes();
 
-                for (char_idx, &ch) in chars.iter().enumerate().skip(index) {
-                    if ch == '(' {
-                        depth += 1;
-                    } else if ch == ')' {
-                        depth -= 1;
-                    } else if ch == '0'
-                        && (char_idx == 0 || !chars[char_idx - 1].is_ascii_digit())
-                        && (char_idx + 1 >= chars.len() || !chars[char_idx + 1].is_ascii_digit())
-                        && depth == 0
-                    {
-                        zero_idx.push(byte_indices[char_idx]);
+                for i in index..bytes.len() {
+                    match bytes[i] {
+                        b'(' => depth += 1,
+                        b')' => depth -= 1,
+                        b'0' if depth == 0
+                            && (i == 0 || !bytes[i - 1].is_ascii_digit())
+                            && (i + 1 >= bytes.len() || !bytes[i + 1].is_ascii_digit()) =>
+                        {
+                            zero_idx.push(i);
+                        }
+                        _ => {}
                     }
                 }
                 // In-place replacement: replace each '0' with '0%' from back to front
                 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();
+                if !zero_idx.is_empty() {
+                    // Refresh lowercase only when modification occurred
+                    lower = ret.to_lowercase();
+                }
             }
         }
     }

libs/extractor/src/css_utils.rs

@@ -486,11 +486,12 @@ pub fn optimize_css_block(css: &str) -> String {
         s2
     };
 
-    let segments: Vec<&str> = trimmed.split(';').collect();
-    for (i, s) in segments.iter().enumerate() {
-        if i > 0 {
+    let mut first_segment = true;
+    for s in trimmed.split(';') {
+        if !first_segment {
             result.push(';');
         }
+        first_segment = false;
         let parts: Vec<&str> = s.split('{').collect();
         let first_part_str = if parts.len() > 1 {
             parts[..parts.len() - 1]

libs/extractor/src/vanilla_extract.rs

@@ -18,6 +18,7 @@ use oxc_span::{GetSpan, SourceType};
 use oxc_transformer::{TransformOptions, Transformer};
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::cell::RefCell;
+use std::fmt::Write;
 use std::path::Path;
 use std::rc::Rc;
 
@@ -1196,10 +1197,10 @@ pub fn collected_styles_to_code_partial(
     package: &str,
     style_names: &FxHashSet<String>,
 ) -> String {
-    let mut code_parts = Vec::new();
+    let mut output = String::new();
 
     if !style_names.is_empty() {
-        code_parts.push(format!("import {{ css }} from '{}'", package));
+        write!(output, "import {{ css }} from '{}'", package).unwrap();
     }
 
     // Generate only the specified styles
@@ -1212,10 +1213,13 @@ pub fn collected_styles_to_code_partial(
 
     for (name, entry) in styles {
         // Generate as non-exported for first pass
-        code_parts.push(format!("const {} = css({})", name, entry.json));
+        if !output.is_empty() {
+            output.push('\n');
+        }
+        write!(output, "const {} = css({})", name, entry.json).unwrap();
     }
 
-    code_parts.join("\n")
+    output
 }
 
 /// Convert collected styles to code with selector references replaced by class names
@@ -1259,6 +1263,19 @@ pub fn collected_styles_to_code_with_classes(
         .map(|(name, entry)| (name.as_str(), entry.json.as_str()))
         .collect();
 
+    // Pre-build search/replace pairs to avoid format!() per iteration
+    let replacements: Vec<_> = class_map
+        .iter()
+        .map(|(style_name, class_name)| {
+            (
+                format!("\"{}:", style_name),
+                format!("\"{}:", class_name),
+                format!("\"{} ", style_name),
+                format!("\"{} ", class_name),
+            )
+        })
+        .collect();
+
     let mut styles: Vec<_> = collected.styles.iter().collect();
     styles.sort_by_key(|(name, _)| *name);
 
@@ -1267,10 +1284,13 @@ pub fn collected_styles_to_code_with_classes(
 
         // Replace style name references with class names in JSON
         let mut json = entry.json.clone();
-        for (style_name, class_name) in class_map {
-            // Replace patterns like "stylename:" with "classname:"
-            json = json.replace(&format!("\"{}:", style_name), &format!("\"{}:", class_name));
-            json = json.replace(&format!("\"{} ", style_name), &format!("\"{} ", class_name));
+        for (search_colon, replace_colon, search_space, replace_space) in &replacements {
+            if json.contains(search_colon.as_str()) {
+                json = json.replace(search_colon, replace_colon);
+            }
+            if json.contains(search_space.as_str()) {
+                json = json.replace(search_space, replace_space);
+            }
         }
 
         if entry.bases.is_empty() {

libs/sheet/src/lib.rs

@@ -671,7 +671,7 @@ impl StyleSheet {
                         base_styles
                             .entry(*prop.0)
                             .or_default()
-                            .extend(prop.1.clone());
+                            .extend(prop.1.iter().cloned());
                     });
                 }
             });
@@ -680,23 +680,29 @@ impl StyleSheet {
             // base style
 
             let theme_css = self.theme.to_css();
-            let mut layers_vec = Vec::new();
-            if style_orders.remove(&0) {
-                layers_vec.push("b".to_string());
-            }
-            if !theme_css.is_empty() {
-                layers_vec.push("t".to_string());
-            }
-            layers_vec.extend(style_orders.iter().map(|v| format!("o{v}")));
-            if !layers_vec.is_empty() {
+            let has_base = style_orders.remove(&0);
+            let has_theme = !theme_css.is_empty();
+            let has_orders = !style_orders.is_empty();
+            if has_base || has_theme || has_orders {
                 css.push_str("@layer ");
                 let mut first = true;
-                for layer in &layers_vec {
+                if has_base {
+                    css.push('b');
+                    first = false;
+                }
+                if has_theme {
+                    if !first {
+                        css.push(',');
+                    }
+                    css.push('t');
+                    first = false;
+                }
+                for v in &style_orders {
                     if !first {
                         css.push(',');
                     }
                     first = false;
-                    css.push_str(layer);
+                    write!(css, "o{v}").unwrap();
                 }
                 css.push(';');
             }