Optimize

Author: owjs3901

bindings/devup-ui-wasm/src/lib.rs

@@ -1,5 +1,5 @@
-use css::class_map::{get_class_map, set_class_map};
-use css::file_map::{get_file_map, get_filename_by_file_num, set_file_map};
+use css::class_map::{set_class_map, with_class_map};
+use css::file_map::{set_file_map, with_file_map};
 use extractor::extract_style::extract_style_value::ExtractStyleValue;
 use extractor::{ExtractOption, ImportAlias, extract, has_devup_ui};
 use rustc_hash::FxHashSet;
@@ -212,7 +212,7 @@ pub fn export_sheet() -> Result<String, JsValue> {
 
 /// Internal function to export class map as JSON string (testable without `JsValue`)
 pub fn export_class_map_internal() -> Result<String, String> {
-    serde_json::to_string(&get_class_map()).map_err(|e| e.to_string())
+    with_class_map(serde_json::to_string).map_err(|e| e.to_string())
 }
 
 #[wasm_bindgen(js_name = "importClassMap")]
@@ -230,7 +230,7 @@ pub fn export_class_map() -> Result<String, JsValue> {
 
 /// Internal function to export file map as JSON string (testable without `JsValue`)
 pub fn export_file_map_internal() -> Result<String, String> {
-    serde_json::to_string(&get_file_map()).map_err(|e| e.to_string())
+    with_file_map(serde_json::to_string).map_err(|e| e.to_string())
 }
 
 #[wasm_bindgen(js_name = "importFileMap")]
@@ -349,10 +349,16 @@ pub fn get_default_theme() -> Result<Option<String>, JsValue> {
 #[cfg(not(tarpaulin_include))]
 pub fn get_css(file_num: Option<usize>, import_main_css: bool) -> Result<String, JsValue> {
     Ok(with_style_sheet(|sheet| {
-        sheet.create_css(
-            file_num.map(get_filename_by_file_num).as_deref(),
-            import_main_css,
-        )
+        if let Some(file_num) = file_num {
+            with_file_map(|map| {
+                sheet.create_css(
+                    map.get_by_right(&file_num).map(String::as_str),
+                    import_main_css,
+                )
+            })
+        } else {
+            sheet.create_css(None, import_main_css)
+        }
     }))
 }
 

libs/css/src/file_map.rs

@@ -19,7 +19,7 @@ static GLOBAL_FILE_MAP: LazyLock<Mutex<BiHashMap<String, usize>>> =
     LazyLock::new(|| Mutex::new(BiHashMap::new()));
 
 #[inline]
-fn with_file_map<F, R>(f: F) -> R
+pub fn with_file_map<F, R>(f: F) -> R
 where
     F: FnOnce(&BiHashMap<String, usize>) -> R,
 {

libs/extractor/src/gen_class_name.rs

@@ -162,19 +162,24 @@ pub fn merge_expression_for_class_name<'a>(
     ast_builder: &AstBuilder<'a>,
     expressions: Vec<Expression<'a>>,
 ) -> Option<Expression<'a>> {
-    let mut class_names = vec![];
     let mut unknown_expr = vec![];
+    let mut class_name = String::new();
     for expr in expressions {
         if let Expression::StringLiteral(str) = &expr {
-            class_names.push(str.value.trim().to_string());
+            let value = str.value.trim();
+            if !value.is_empty() {
+                if !class_name.is_empty() {
+                    class_name.push(' ');
+                }
+                class_name.push_str(value);
+            }
         } else {
             unknown_expr.push(expr);
         }
     }
-    if unknown_expr.is_empty() && class_names.is_empty() {
+    if unknown_expr.is_empty() && class_name.is_empty() {
         return None;
     }
-    let mut class_name = class_names.join(" ");
     if !unknown_expr.is_empty() {
         if class_name.is_empty() && unknown_expr.len() == 1 {
             Some(unknown_expr.remove(0))

libs/extractor/src/prop_modify_utils.rs

@@ -531,33 +531,39 @@ fn rebuild_expression_with_mapping<'a>(
 
 /// Extract all class name strings from a template literal, including from conditional expressions
 fn extract_all_classes_from_template_literal(template: &oxc_ast::ast::TemplateLiteral) -> String {
-    let mut classes = Vec::new();
+    let mut classes = String::new();
 
     // Extract from quasis (static parts of template literal)
     for quasi in &template.quasis {
         let raw = quasi.value.raw.as_str();
-        if !raw.trim().is_empty() {
-            classes.push(raw.trim().to_string());
-        }
+        push_class_segment(&mut classes, raw.trim());
     }
 
     // Extract from expressions (dynamic parts)
     for expr in &template.expressions {
         extract_classes_from_expression(expr, &mut classes);
     }
 
-    classes.join(" ")
+    classes
+}
+
+fn push_class_segment(classes: &mut String, value: &str) {
+    if value.is_empty() {
+        return;
+    }
+    if !classes.is_empty() {
+        classes.push(' ');
+    }
+    classes.push_str(value);
 }
 
 /// Recursively extract class name strings from an expression
-fn extract_classes_from_expression(expr: &Expression, classes: &mut Vec<String>) {
+fn extract_classes_from_expression(expr: &Expression, classes: &mut String) {
     match expr {
         // Direct string literal: 'text-red-500'
         Expression::StringLiteral(lit) => {
             let value = lit.value.as_str().trim();
-            if !value.is_empty() {
-                classes.push(value.to_string());
-            }
+            push_class_segment(classes, value);
         }
         // Ternary/conditional: cond ? 'text-red' : 'text-blue'
         Expression::ConditionalExpression(cond) => {
@@ -576,9 +582,7 @@ fn extract_classes_from_expression(expr: &Expression, classes: &mut Vec<String>)
         // Template literal inside expression
         Expression::TemplateLiteral(inner_template) => {
             let inner_classes = extract_all_classes_from_template_literal(inner_template);
-            if !inner_classes.is_empty() {
-                classes.push(inner_classes);
-            }
+            push_class_segment(classes, &inner_classes);
         }
         // Other expressions (variables, function calls, etc.) - skip, can't extract statically
         _ => {}

libs/extractor/src/vanilla_extract.rs

@@ -687,23 +687,10 @@ fn remap_style_names(
         })
         .collect();
 
-    // Replace __font_N__ placeholders in style JSON with font-family names
+    // Replace placeholders in a single pass per style JSON.
+    // This is needed for font-family references and selectors like `${parent}:hover &`.
     for entry in new_styles.values_mut() {
-        for (placeholder, font_family) in &font_family_map {
-            if entry.json.contains(placeholder) {
-                entry.json = entry.json.replace(placeholder, font_family);
-            }
-        }
-    }
-
-    // Replace __style_N__ placeholders in style JSON with variable names
-    // This is needed for selectors that reference other styles like `${parent}:hover &`
-    for entry in new_styles.values_mut() {
-        for (placeholder, var_name) in &placeholder_to_name {
-            if entry.json.contains(placeholder) {
-                entry.json = entry.json.replace(placeholder, var_name);
-            }
-        }
+        replace_placeholders_in_json(&mut entry.json, &font_family_map, &placeholder_to_name);
     }
 
     collected.styles = new_styles;
@@ -717,6 +704,45 @@ fn remap_style_names(
     collected.themes = new_themes;
 }
 
+fn replace_placeholders_in_json(
+    json: &mut String,
+    font_family_map: &FxHashMap<&str, &str>,
+    placeholder_to_name: &FxHashMap<String, String>,
+) {
+    let source = json.as_str();
+    let mut search_start = 0;
+    let mut last_copied = 0;
+    let mut output = None::<String>;
+
+    while let Some(relative_start) = source[search_start..].find("__") {
+        let start = search_start + relative_start;
+        let Some(relative_end) = source[start + 2..].find("__") else {
+            break;
+        };
+        let end = start + 2 + relative_end + 2;
+        let placeholder = &source[start..end];
+        let replacement = font_family_map
+            .get(placeholder)
+            .copied()
+            .or_else(|| placeholder_to_name.get(placeholder).map(String::as_str));
+
+        if let Some(replacement) = replacement {
+            let output = output.get_or_insert_with(|| String::with_capacity(source.len()));
+            output.push_str(&source[last_copied..start]);
+            output.push_str(replacement);
+            last_copied = end;
+            search_start = end;
+        } else {
+            search_start = start + 2;
+        }
+    }
+
+    if let Some(mut output) = output {
+        output.push_str(&source[last_copied..]);
+        *json = output;
+    }
+}
+
 /// Convert TypeScript to JavaScript using Oxc Transformer and replace imports
 fn preprocess_typescript(code: &str, package: &str) -> String {
     let allocator = Allocator::default();