Refactor code

Author: owjs3901

Cargo.toml

@@ -2,6 +2,53 @@
 resolver = "2"
 members = ["libs/extractor", "bindings/devup-ui-wasm", "libs/sheet", "libs/css"]
 
+[workspace.lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
+
+[workspace.lints.rustdoc]
+bare_urls = "deny"
+broken_intra_doc_links = "deny"
+
+[workspace.lints.clippy]
+all = { level = "deny", priority = -1 }
+cargo = { level = "deny", priority = -1 }
+nursery = { level = "deny", priority = -1 }
+pedantic = { level = "deny", priority = -1 }
+expect_used = "deny"
+unwrap_used = "deny"
+# Explicitly excluded from strict groups because they are noisy or conflict with
+# this workspace's public API, Oxc AST-builder ergonomics, WASM boundary shape,
+# or transitive dependency graph. Everything else in all/cargo/nursery/pedantic
+# is denied workspace-wide.
+cast_possible_truncation = "allow"
+cast_sign_loss = "allow"
+default_trait_access = "allow"
+from_iter_instead_of_collect = "allow"
+implicit_hasher = "allow"
+inline_always = "allow"
+fallible_impl_from = "allow"
+manual_let_else = "allow"
+missing_errors_doc = "allow"
+missing_fields_in_debug = "allow"
+missing_panics_doc = "allow"
+match_same_arms = "deny"
+must_use_candidate = "allow"
+needless_for_each = "allow"
+needless_pass_by_value = "allow"
+multiple_crate_versions = "allow"
+option_if_let_else = "allow"
+range_plus_one = "deny"
+ref_option = "allow"
+redundant_closure_for_method_calls = "deny"
+redundant_else = "deny"
+redundant_pub_crate = "allow"
+return_self_not_must_use = "allow"
+similar_names = "allow"
+too_many_lines = "allow"
+trivially_copy_pass_by_ref = "allow"
+use_self = "allow"
+used_underscore_binding = "allow"
+
 [profile.release]
 # Optimize for small code size (critical for WASM binary)
 opt-level = "s"

bindings/devup-ui-wasm/Cargo.toml

@@ -7,6 +7,8 @@ description = "Devup UI WASM bindings"
 license = "Apache-2.0"
 repository = "https://github.com/dev-five-git/devup-ui"
 documentation = "https://devup-ui.com"
+keywords = ["css", "wasm", "react", "devup-ui"]
+categories = ["development-tools", "wasm", "web-programming"]
 
 [lib]
 crate-type = ["cdylib"]
@@ -38,8 +40,8 @@ serial_test = "3.4.0"
 insta = "1.47.2"
 rstest = "0.26.1"
 
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
+[lints]
+workspace = true
 
 [package.metadata.wasm-pack.profile.release]
 wasm-opt = ["-Oz", "--enable-bulk-memory", "--enable-nontrapping-float-to-int"]

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

@@ -1,3 +1,5 @@
+#![allow(clippy::expect_used, clippy::unwrap_used)]
+
 use js_sys::{Object, Reflect};
 use sheet::theme::Typography;
 use wasm_bindgen::JsValue;

bindings/devup-ui-wasm/tests/wasm.rs

@@ -2,9 +2,14 @@
 name = "css"
 version = "0.1.0"
 edition = "2024"
+description = "CSS utilities and selector optimization for Devup UI"
+license = "Apache-2.0"
+repository = "https://github.com/dev-five-git/devup-ui"
+keywords = ["css", "selectors", "optimization", "react", "devup-ui"]
+categories = ["development-tools", "wasm", "web-programming"]
 
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
+[lints]
+workspace = true
 
 [dependencies]
 phf = { version = "0.13", features = ["macros"] }

libs/css/Cargo.toml

@@ -30,7 +30,7 @@ fn bench_sheet_to_classname(c: &mut Criterion) {
                 black_box(None),
                 black_box(None),
             )
-        })
+        });
     });
 
     group.bench_function("with_selector", |b| {
@@ -44,7 +44,7 @@ fn bench_sheet_to_classname(c: &mut Criterion) {
                 black_box(None),
                 black_box(None),
             )
-        })
+        });
     });
 
     group.bench_function("with_filename", |b| {
@@ -58,7 +58,7 @@ fn bench_sheet_to_classname(c: &mut Criterion) {
                 black_box(None),
                 black_box(Some("test.tsx")),
             )
-        })
+        });
     });
 
     group.bench_function("all_params", |b| {
@@ -72,7 +72,7 @@ fn bench_sheet_to_classname(c: &mut Criterion) {
                 black_box(Some(1)),
                 black_box(Some("test.tsx")),
             )
-        })
+        });
     });
 
     group.bench_function("multiple_sequential", |b| {
@@ -88,7 +88,7 @@ fn bench_sheet_to_classname(c: &mut Criterion) {
             sheet_to_classname("width", 0, Some("100%"), None, None, None);
             sheet_to_classname("height", 0, Some("50vh"), None, None, None);
             sheet_to_classname("border-radius", 0, Some("8px"), None, None, None);
-        })
+        });
     });
 
     group.finish();
@@ -98,29 +98,29 @@ fn bench_optimize_value(c: &mut Criterion) {
     let mut group = c.benchmark_group("optimize_value");
 
     group.bench_function("simple_keyword", |b| {
-        b.iter(|| optimize_value(black_box("red")))
+        b.iter(|| optimize_value(black_box("red")));
     });
 
     group.bench_function("simple_px", |b| {
-        b.iter(|| optimize_value(black_box("14px")))
+        b.iter(|| optimize_value(black_box("14px")));
     });
 
     group.bench_function("zero_unit", |b| b.iter(|| optimize_value(black_box("0px"))));
 
     group.bench_function("rgba_color", |b| {
-        b.iter(|| optimize_value(black_box("rgba(255, 0, 0, 0.5)")))
+        b.iter(|| optimize_value(black_box("rgba(255, 0, 0, 0.5)")));
     });
 
     group.bench_function("translate", |b| {
-        b.iter(|| optimize_value(black_box("translate(10px, 0px)")))
+        b.iter(|| optimize_value(black_box("translate(10px, 0px)")));
     });
 
     group.bench_function("complex_multi", |b| {
-        b.iter(|| optimize_value(black_box("0px 0px 10px rgba(0,0,0,0.1)")))
+        b.iter(|| optimize_value(black_box("0px 0px 10px rgba(0,0,0,0.1)")));
     });
 
     group.bench_function("theme_var", |b| {
-        b.iter(|| optimize_value(black_box("$primary")))
+        b.iter(|| optimize_value(black_box("$primary")));
     });
 
     group.finish();
@@ -130,23 +130,23 @@ fn bench_to_kebab_case(c: &mut Criterion) {
     let mut group = c.benchmark_group("to_kebab_case");
 
     group.bench_function("backgroundColor", |b| {
-        b.iter(|| to_kebab_case(black_box("backgroundColor")))
+        b.iter(|| to_kebab_case(black_box("backgroundColor")));
     });
 
     group.bench_function("borderRadius", |b| {
-        b.iter(|| to_kebab_case(black_box("borderRadius")))
+        b.iter(|| to_kebab_case(black_box("borderRadius")));
     });
 
     group.bench_function("justifyContent", |b| {
-        b.iter(|| to_kebab_case(black_box("justifyContent")))
+        b.iter(|| to_kebab_case(black_box("justifyContent")));
     });
 
     group.bench_function("WebkitTransform", |b| {
-        b.iter(|| to_kebab_case(black_box("WebkitTransform")))
+        b.iter(|| to_kebab_case(black_box("WebkitTransform")));
     });
 
     group.bench_function("simple_color", |b| {
-        b.iter(|| to_kebab_case(black_box("color")))
+        b.iter(|| to_kebab_case(black_box("color")));
     });
 
     group.finish();
@@ -156,15 +156,15 @@ fn bench_merge_selector(c: &mut Criterion) {
     let mut group = c.benchmark_group("merge_selector");
 
     group.bench_function("no_selector", |b| {
-        b.iter(|| merge_selector(black_box("a"), black_box(None)))
+        b.iter(|| merge_selector(black_box("a"), black_box(None)));
     });
 
     group.bench_function("hover", |b| {
-        b.iter(|| merge_selector(black_box("a"), black_box(Some(&"hover".into()))))
+        b.iter(|| merge_selector(black_box("a"), black_box(Some(&"hover".into()))));
     });
 
     group.bench_function("theme_dark", |b| {
-        b.iter(|| merge_selector(black_box("a"), black_box(Some(&"theme-dark".into()))))
+        b.iter(|| merge_selector(black_box("a"), black_box(Some(&"theme-dark".into()))));
     });
 
     group.finish();

libs/css/benches/css_benchmark.rs

@@ -30,7 +30,10 @@ where
     }
     #[cfg(not(target_arch = "wasm32"))]
     {
-        f(&GLOBAL_CLASS_MAP.lock().unwrap())
+        let guard = GLOBAL_CLASS_MAP
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        f(&guard)
     }
 }
 
@@ -46,21 +49,24 @@ where
     }
     #[cfg(not(target_arch = "wasm32"))]
     {
-        f(&mut GLOBAL_CLASS_MAP.lock().unwrap())
+        let mut guard = GLOBAL_CLASS_MAP
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        f(&mut guard)
     }
 }
 
 /// for test
 pub fn reset_class_map() {
-    with_class_map_mut(|map| map.clear());
+    with_class_map_mut(HashMap::clear);
 }
 
 pub fn set_class_map(new_map: HashMap<String, HashMap<String, usize>>) {
     with_class_map_mut(|map| *map = new_map);
 }
 
 pub fn get_class_map() -> HashMap<String, HashMap<String, usize>> {
-    with_class_map(|map| map.clone())
+    with_class_map(Clone::clone)
 }
 
 #[cfg(test)]
@@ -73,7 +79,7 @@ mod tests {
     #[serial]
     fn test_set_and_get_class_map() {
         let mut test_map = HashMap::new();
-        test_map.insert("".to_string(), HashMap::new());
+        test_map.insert(String::new(), HashMap::new());
         set_class_map(test_map.clone());
         let got = get_class_map();
         assert_eq!(got.get(""), Some(&HashMap::new()));
@@ -83,7 +89,7 @@ mod tests {
     #[serial]
     fn test_reset_class_map() {
         let mut test_map = HashMap::new();
-        test_map.insert("".to_string(), HashMap::new());
+        test_map.insert(String::new(), HashMap::new());
         set_class_map(test_map);
         reset_class_map();
         let got = get_class_map();

libs/css/src/class_map.rs

@@ -4,6 +4,11 @@ use phf::{phf_map, phf_set};
 use regex_lite::Regex;
 use std::sync::LazyLock;
 
+fn compile_regex(pattern: &str) -> Regex {
+    Regex::new(pattern)
+        .unwrap_or_else(|err| panic!("invalid built-in regex pattern `{pattern}`: {err}"))
+}
+
 pub(super) static SELECTOR_ORDER_MAP: LazyLock<HashMap<String, u8>> = LazyLock::new(|| {
     let mut map = HashMap::new();
     for (idx, selector) in [
@@ -161,43 +166,40 @@ pub(super) static ZERO_PERCENT_FUNCTION: phf::Set<&str> = phf_set! {
     "tan(",
 };
 
-pub(super) static F_SPACE_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\s*,\s*").unwrap());
+pub(super) static F_SPACE_RE: LazyLock<Regex> = LazyLock::new(|| compile_regex(r"\s*,\s*"));
 pub(super) static CSS_FUNCTION_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^[a-zA-Z-]+(\(.*\))").unwrap());
-pub(super) static CHECK_QUOTES_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"[()\s]").unwrap());
+    LazyLock::new(|| compile_regex(r"^[a-zA-Z-]+(\(.*\))"));
+pub(super) static CHECK_QUOTES_RE: LazyLock<Regex> = LazyLock::new(|| compile_regex(r"[()\s]"));
 
 pub(super) static CSS_COMMENT_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"/\*[\s\S]*?\*/").unwrap());
+    LazyLock::new(|| compile_regex(r"/\*[\s\S]*?\*/"));
 
-pub(super) static F_DOT_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"(\b|,)0\.(\d+)").unwrap());
+pub(super) static F_DOT_RE: LazyLock<Regex> = LazyLock::new(|| compile_regex(r"(\b|,)0\.(\d+)"));
 pub(super) static DOT_ZERO_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"(\b|,)-?0\.0+([^\d])").unwrap());
+    LazyLock::new(|| compile_regex(r"(\b|,)-?0\.0+([^\d])"));
 
-pub(super) static COLOR_HASH: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"#([0-9a-zA-Z]+)").unwrap());
+pub(super) static COLOR_HASH: LazyLock<Regex> = LazyLock::new(|| compile_regex(r"#([0-9a-zA-Z]+)"));
 pub(super) static INNER_TRIM_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"\(\s*([^)]*?)\s*\)").unwrap());
+    LazyLock::new(|| compile_regex(r"\(\s*([^)]*?)\s*\)"));
 
 pub(super) static RM_MINUS_ZERO_RE: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"-0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg|\)|,)").unwrap()
+    compile_regex(r"-0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg|\)|,)")
 });
 
 pub(super) static NUM_TRIM_RE: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"(\d(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)?)\s+(\d)")
-        .unwrap()
+    compile_regex(r"(\d(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)?)\s+(\d)")
 });
 pub(super) static ZERO_RE: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"(\b|,|\(|^|\s)-?0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)")
-        .unwrap()
+    compile_regex(
+        r"(\b|,|\(|^|\s)-?0(px|em|rem|vh|vw|%|dvh|dvw|vmax|vmin|mm|cm|in|pt|pc|lh|ic|deg)",
+    )
 });
 
 pub(super) static F_RGBA_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"rgba\((\d+),(\d+),(\d+),(\d*\.?\d*)\)").unwrap());
+    LazyLock::new(|| compile_regex(r"rgba\((\d+),(\d+),(\d+),(\d*\.?\d*)\)"));
 
 pub(super) static F_RGB_RE: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"rgb\((\d+),(\d+),(\d+)\)").unwrap());
+    LazyLock::new(|| compile_regex(r"rgb\((\d+),(\d+),(\d+)\)"));
 
 pub(super) static N_BASE_ARRAY: [char; 27] = [
     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',