fixed load time unit mismatch

Author: chaos-dotcom

crates/web/src/pages/create_dosage.rs

@@ -451,9 +451,9 @@ fn dosage_editor_page(schedule_only: bool) -> impl IntoView {
 
             if let Some(next_value) = converted {
                 estrogen_dose.set(if target_iu_mode {
-                    fmt(next_value, 0)
+                    format!("{next_value:.0}")
                 } else {
-                    fmt(next_value, 3)
+                    format!("{next_value:.3}")
                 });
                 estrogen_dose_in_iu.set(target_iu_mode);
             } else if target_iu_mode {
@@ -505,6 +505,9 @@ fn dosage_editor_page(schedule_only: bool) -> impl IntoView {
             if initialized.get() {
                 return;
             }
+            if store.is_loading.get() {
+                return;
+            }
             let data = store.data.get();
             if let Some(inj) = data.injectableEstradiol.as_ref() {
                 estrogen_method.set("injection".to_string());

crates/web/src/store.rs

@@ -41,9 +41,9 @@ impl AppStore {
         let is_dirty = self.is_dirty;
         let last_error = self.last_error;
         let api_base = api_base();
+        is_loading.set(true);
+        last_error.set(None);
         spawn_local(async move {
-            is_loading.set(true);
-            last_error.set(None);
             let resp = Request::get(&format!("{}/api/data", api_base)).send().await;
             match resp {
                 Ok(resp) => match resp.json::<HrtData>().await {

crates/web/src/utils.rs

@@ -49,8 +49,64 @@ pub fn parse_decimal(value: &str) -> Option<f64> {
     if trimmed.is_empty() {
         return None;
     }
-    let normalized = trimmed.replace(',', ".");
-    normalized.parse::<f64>().ok().filter(|v| v.is_finite())
+    let normalized = trimmed
+        .replace('\u{00a0}', "")
+        .replace('\u{202f}', "")
+        .replace('\u{2009}', "")
+        .replace(' ', "")
+        .replace('_', "")
+        .replace('\'', "");
+    if normalized.is_empty() {
+        return None;
+    }
+
+    let parse = |raw: String| raw.parse::<f64>().ok().filter(|v| v.is_finite());
+
+    let comma_count = normalized.matches(',').count();
+    let dot_count = normalized.matches('.').count();
+
+    if comma_count > 0 && dot_count > 0 {
+        let last_comma = normalized.rfind(',').unwrap_or(0);
+        let last_dot = normalized.rfind('.').unwrap_or(0);
+        if last_comma > last_dot {
+            // 1.234,56 -> 1234.56
+            return parse(normalized.replace('.', "").replace(',', "."));
+        }
+        // 1,234.56 -> 1234.56
+        return parse(normalized.replace(',', ""));
+    }
+
+    if comma_count > 0 {
+        if comma_count > 1 {
+            // 1,234,567 -> 1234567
+            return parse(normalized.replace(',', ""));
+        }
+        let split_idx = normalized.find(',').unwrap_or(0);
+        let int_part = &normalized[..split_idx];
+        let frac_part = &normalized[split_idx + 1..];
+        let int_digits = int_part.trim_start_matches(['+', '-']);
+        let grouped_thousands = frac_part.len() == 3
+            && frac_part.chars().all(|ch| ch.is_ascii_digit())
+            && !int_digits.is_empty()
+            && int_digits != "0"
+            && !int_digits.starts_with('0')
+            && int_part
+                .chars()
+                .all(|ch| ch.is_ascii_digit() || ch == '+' || ch == '-');
+        if grouped_thousands {
+            // 1,000 -> 1000
+            return parse(normalized.replace(',', ""));
+        }
+        // 1,25 -> 1.25
+        return parse(normalized.replace(',', "."));
+    }
+
+    if dot_count > 1 {
+        // 1.234.567 -> 1234567
+        return parse(normalized.replace('.', ""));
+    }
+
+    parse(normalized)
 }
 
 pub fn parse_decimal_or_nan(value: &str) -> f64 {
@@ -274,6 +330,20 @@ mod tests {
         assert_eq!(parse_decimal("0,2"), Some(0.2));
         assert_eq!(parse_decimal(" 1.25 "), Some(1.25));
         assert_eq!(parse_decimal(" 1,25 "), Some(1.25));
+        assert_eq!(parse_decimal("1.000"), Some(1.0));
+        assert_eq!(parse_decimal("0.125"), Some(0.125));
+        assert_eq!(parse_decimal("0,125"), Some(0.125));
+    }
+
+    #[test]
+    fn parse_decimal_accepts_grouped_thousands_inputs() {
+        assert_eq!(parse_decimal("1,000"), Some(1000.0));
+        assert_eq!(parse_decimal("12,345"), Some(12345.0));
+        assert_eq!(parse_decimal("1,234.5"), Some(1234.5));
+        assert_eq!(parse_decimal("1.234,5"), Some(1234.5));
+        assert_eq!(parse_decimal("1.234.567"), Some(1234567.0));
+        assert_eq!(parse_decimal("1 234,5"), Some(1234.5));
+        assert_eq!(parse_decimal("1'234,5"), Some(1234.5));
     }
 
     #[test]