perf: adopt FxHashMap/FxHashSet for hot-path hash collections

Replace std HashMap/HashSet with rustc-hash FxHashMap/FxHashSet across
extractor, sheet, and wasm crates. FxHash uses a faster non-cryptographic
hash (~50% faster for short string keys like CSS properties) which is
safe for build-time processing of trusted source code.

Converted: CollectedStyles (11 fields), DevupVisitor (4 fields),
ExtractOutput.styles, remap_style_names, extract_class_map_from_code,
class_mapping utilities, expression_map, PropertyMap, and update_styles.

Kept std HashMap for ExtractOption.import_aliases (public API, cold path,
WASM bindings compatibility).

All 1,702 tests passing. Zero clippy warnings.

Author: owjs3901

Cargo.lock

@@ -19,6 +19,7 @@ wasm-bindgen = "0.2.113"
 extractor = { path = "../../libs/extractor" }
 sheet = { path = "../../libs/sheet" }
 css = { path = "../../libs/css" }
+rustc-hash = "2"
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires

bindings/devup-ui-wasm/Cargo.toml

@@ -2,8 +2,9 @@ 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 extractor::extract_style::extract_style_value::ExtractStyleValue;
 use extractor::{ExtractOption, ImportAlias, extract, has_devup_ui};
+use rustc_hash::FxHashSet;
 use sheet::StyleSheet;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::{LazyLock, Mutex};
 use wasm_bindgen::prelude::*;
 
@@ -34,7 +35,7 @@ pub struct Output {
 impl Output {
     fn new(
         code: String,
-        styles: HashSet<ExtractStyleValue>,
+        styles: FxHashSet<ExtractStyleValue>,
         map: Option<String>,
         single_css: bool,
         filename: String,
@@ -739,7 +740,7 @@ mod tests {
         css::class_map::reset_class_map();
 
         // Create output with empty styles
-        let styles = HashSet::new();
+        let styles = FxHashSet::default();
         let output = Output::new(
             "code".to_string(),
             styles,
@@ -839,7 +840,7 @@ mod tests {
         css::class_map::reset_class_map();
 
         // Now create output which should trigger rm_global_css
-        let styles = HashSet::new();
+        let styles = FxHashSet::default();
         let output = Output::new(
             "new code".to_string(),
             styles,

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

@@ -19,6 +19,7 @@ strum = "0.28.0"
 strum_macros = "0.28.0"
 serde_json = "1.0"
 boa_engine = "0.21"
+rustc-hash = "2"
 
 [dev-dependencies]
 insta = "1.46.3"

libs/extractor/Cargo.toml

@@ -62,7 +62,8 @@ 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::with_capacity(css.expressions.len());
+    let mut expression_map =
+        rustc_hash::FxHashMap::with_capacity_and_hasher(css.expressions.len(), Default::default());
 
     for (i, quasi) in css.quasis.iter().enumerate() {
         css_parts.push(quasi.value.raw.to_string());

libs/extractor/src/css_utils.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 use crate::{
     ExtractStyleProp,
@@ -19,7 +19,7 @@ use oxc_span::SPAN;
 
 fn extract_base_tag_and_class_name<'a>(
     input: &Expression<'a>,
-    imports: &HashMap<String, ExportVariableKind>,
+    imports: &FxHashMap<String, ExportVariableKind>,
 ) -> (Option<String>, Option<Vec<ExtractStyleValue>>) {
     if let Expression::StaticMemberExpression(member) = input {
         (Some(member.property.name.to_string()), None)
@@ -58,7 +58,7 @@ pub fn extract_style_from_styled<'a>(
     ast_builder: &AstBuilder<'a>,
     expression: &mut Expression<'a>,
     split_filename: Option<&str>,
-    imports: &HashMap<String, ExportVariableKind>,
+    imports: &FxHashMap<String, ExportVariableKind>,
 ) -> (ExtractResult<'a>, Expression<'a>) {
     let (result, new_expr) = if let Expression::TaggedTemplateExpression(tag) = expression
         && let (Some(tag_name), default_class_name) =

libs/extractor/src/extractor/extract_style_from_styled.rs

@@ -21,7 +21,8 @@ use oxc_ast_visit::VisitMut;
 use oxc_codegen::{Codegen, CodegenOptions};
 use oxc_parser::{Parser, ParserReturn};
 use oxc_span::SourceType;
-use std::collections::{BTreeMap, HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
+use std::collections::{BTreeMap, HashMap};
 use std::error::Error;
 use std::path::PathBuf;
 
@@ -131,7 +132,7 @@ impl<'a> ExtractStyleProp<'a> {
 #[derive(Debug)]
 pub struct ExtractOutput {
     // used styles
-    pub styles: HashSet<ExtractStyleValue>,
+    pub styles: FxHashSet<ExtractStyleValue>,
 
     // output source
     pub code: String,
@@ -182,7 +183,7 @@ pub fn extract(
     if !has_relevant_import {
         // skip if not using package
         return Ok(ExtractOutput {
-            styles: HashSet::new(),
+            styles: FxHashSet::default(),
             code: code.to_string(),
             map: None,
             css_file: None,
@@ -216,7 +217,7 @@ pub fn extract(
                     let class_map = if !partial_code.is_empty() {
                         extract_class_map_from_code(filename, &partial_code, &option, &referenced)?
                     } else {
-                        std::collections::HashMap::new()
+                        FxHashMap::default()
                     };
 
                     // Generate full code with class names substituted into selectors
@@ -240,7 +241,7 @@ pub fn extract(
     // For vanilla-extract files, if no styles were collected, return early
     if is_vanilla_extract && processed_code.is_empty() {
         return Ok(ExtractOutput {
-            styles: HashSet::new(),
+            styles: FxHashSet::default(),
             code: code.to_string(),
             map: None,
             css_file: None,
@@ -310,8 +311,8 @@ fn extract_class_map_from_code(
     filename: &str,
     partial_code: &str,
     option: &ExtractOption,
-    style_names: &HashSet<String>,
-) -> Result<std::collections::HashMap<String, String>, Box<dyn Error>> {
+    style_names: &FxHashSet<String>,
+) -> Result<FxHashMap<String, String>, Box<dyn Error>> {
     let source_type = SourceType::from_path(filename)?;
     let css_file = if option.single_css {
         format!("{}/devup-ui.css", option.css_dir)
@@ -331,7 +332,7 @@ fn extract_class_map_from_code(
         ..
     } = Parser::new(&allocator, partial_code, source_type).parse();
     if panicked {
-        Ok(std::collections::HashMap::new())
+        Ok(FxHashMap::default())
     } else {
         let mut visitor = DevupVisitor::new(
             &allocator,
@@ -350,7 +351,7 @@ fn extract_class_map_from_code(
 
         // Parse the output code to extract class name assignments
         // Format: const styleName = "className" or const styleName = "className1 className2"
-        let mut class_map = std::collections::HashMap::new();
+        let mut class_map = FxHashMap::default();
         for line in result.code.lines() {
             let line = line.trim();
             if line.starts_with("const ") || line.starts_with("export const ") {
@@ -13315,7 +13316,7 @@ export const card = style({
     #[serial]
     fn test_extract_class_map_from_code_parser_panic() {
         // Test extract_class_map_from_code with invalid code that causes parser panic (covers line 153-154)
-        let mut style_names = HashSet::new();
+        let mut style_names = FxHashSet::default();
         style_names.insert("test".to_string());
 
         let result = extract_class_map_from_code(

libs/extractor/src/lib.rs

@@ -13,7 +13,7 @@ use oxc_ast::ast::{
     PropertyKey, PropertyKind, TemplateElementValue,
 };
 use oxc_span::SPAN;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 
 /// Combine two optional className expressions into a conditional expression.
 /// `condition ? con_expr : alt_expr`, falling back to `""` for the missing branch.
@@ -428,8 +428,8 @@ fn build_tailwind_class_mapping(
     class_str: &str,
     style_order: Option<u8>,
     filename: Option<&str>,
-) -> HashMap<String, String> {
-    let mut mapping = HashMap::new();
+) -> FxHashMap<String, String> {
+    let mut mapping = FxHashMap::default();
 
     for class in class_str.split_whitespace() {
         if let Some(parsed) = parse_single_class(class) {
@@ -451,7 +451,7 @@ fn build_tailwind_class_mapping(
 fn rebuild_template_literal_with_mapping<'a>(
     ast_builder: &AstBuilder<'a>,
     template: &oxc_ast::ast::TemplateLiteral<'a>,
-    class_mapping: &HashMap<String, String>,
+    class_mapping: &FxHashMap<String, String>,
 ) -> Expression<'a> {
     // Rebuild quasis with replaced class names
     let new_quasis = template.quasis.iter().map(|quasi| {
@@ -486,7 +486,7 @@ fn rebuild_template_literal_with_mapping<'a>(
 }
 
 /// Replace Tailwind class names in a string with generated class names
-fn replace_classes_in_string(s: &str, class_mapping: &HashMap<String, String>) -> String {
+fn replace_classes_in_string(s: &str, class_mapping: &FxHashMap<String, String>) -> String {
     let mut result = s.to_string();
     // Sort by length descending to avoid partial replacements (e.g., "text-3xl" before "text-3")
     let mut sorted_classes: Vec<_> = class_mapping.iter().collect();
@@ -502,7 +502,7 @@ fn replace_classes_in_string(s: &str, class_mapping: &HashMap<String, String>) -
 fn rebuild_expression_with_mapping<'a>(
     ast_builder: &AstBuilder<'a>,
     expr: &Expression<'a>,
-    class_mapping: &HashMap<String, String>,
+    class_mapping: &FxHashMap<String, String>,
 ) -> Expression<'a> {
     match expr {
         Expression::StringLiteral(lit) => {