[PATCH yew-widget-toolkit v2] widget: form: number: round floats to some decimal precision

[PATCH yew-widget-toolkit v2] widget: form: number: round floats to some decimal precision

[Christoph Heiss]

The precision is controllable through a property.

E.g. previously, for an input like

    Number::new()
        .name("some-float")
        .min(0.)
        .step(0.1)
        .submit_empty(false)
        .value(0.2)

and pressing the "range-up" button on the input would result in
0.30000000000000004 - which is rather undesirable.

Signed-off-by: Christoph Heiss <c.heiss@proxmox.com>
---
v1: https://lore.proxmox.com/yew-devel/20260319170432.1533393-1-c.heiss@proxmox.com/T/#u

Changes v1 -> v2:
  * added property to control precision, as suggested by Dominik

 src/widget/form/number.rs | 38 ++++++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 12 deletions(-)

diff --git a/src/widget/form/number.rs b/src/widget/form/number.rs
index 698dc85..13601f8 100644
--- a/src/widget/form/number.rs
+++ b/src/widget/form/number.rs
@@ -37,8 +37,8 @@ pub trait NumberTypeInfo:
 
     fn format(&self) -> String;
 
-    fn step_down(&self, step: Option<Self>) -> Self;
-    fn step_up(&self, step: Option<Self>) -> Self;
+    fn step_down(&self, step: Option<Self>, precision: u8) -> Self;
+    fn step_up(&self, step: Option<Self>, precision: u8) -> Self;
 
     fn clamp_value(&self, min: Option<Self>, max: Option<Self>) -> Self;
 
@@ -67,11 +67,17 @@ impl NumberTypeInfo for f64 {
     fn format(&self) -> String {
         crate::dom::format_float(*self)
     }
-    fn step_up(&self, step: Option<Self>) -> Self {
-        self + step.unwrap_or(1.0)
+    fn step_up(&self, step: Option<Self>, precision: u8) -> Self {
+        // Do a little dance here to round to the nearest step value, by multiplying,
+        // rounding to the nearest integer and dividing again
+        let m = 10f64.powf(precision as f64);
+        ((self + step.unwrap_or(1.0)) * m).round() / m
     }
-    fn step_down(&self, step: Option<Self>) -> Self {
-        self - step.unwrap_or(1.0)
+    fn step_down(&self, step: Option<Self>, precision: u8) -> Self {
+        // Do a little dance here to round to the nearest step value, by multiplying,
+        // rounding to the nearest integer and dividing again
+        let m = 10f64.powf(precision as f64);
+        ((self - step.unwrap_or(1.0)) * m).round() / m
     }
     fn clamp_value(&self, min: Option<Self>, max: Option<Self>) -> Self {
         self.clamp(min.unwrap_or(f64::MIN), max.unwrap_or(f64::MAX))
@@ -137,7 +143,7 @@ macro_rules! signed_number_impl {
             fn format(&self) -> String {
                 (*self).to_string()
             }
-            fn step_down(&self, step: Option<Self>) -> Self {
+            fn step_down(&self, step: Option<Self>, _precision: u8) -> Self {
                 let step = step.unwrap_or(1);
                 if *self >= (<$T>::MIN + step) {
                     self - step
@@ -145,7 +151,7 @@ macro_rules! signed_number_impl {
                     *self
                 }
             }
-            fn step_up(&self, step: Option<Self>) -> Self {
+            fn step_up(&self, step: Option<Self>, _precision: u8) -> Self {
                 let step = step.unwrap_or(1);
                 if *self <= (<$T>::MAX - step) {
                     self + step
@@ -216,7 +222,7 @@ macro_rules! unsigned_number_impl {
             fn format(&self) -> String {
                 (*self).to_string()
             }
-            fn step_down(&self, step: Option<Self>) -> Self {
+            fn step_down(&self, step: Option<Self>, _precision: u8) -> Self {
                 let step = step.unwrap_or(1);
                 if *self >= (<$T>::MIN + step) {
                     self - step
@@ -224,7 +230,7 @@ macro_rules! unsigned_number_impl {
                     *self
                 }
             }
-            fn step_up(&self, step: Option<Self>) -> Self {
+            fn step_up(&self, step: Option<Self>, _precision: u8) -> Self {
                 let step = step.unwrap_or(1);
                 if *self <= (<$T>::MAX - step) {
                     self + step
@@ -317,6 +323,14 @@ pub struct Number<T: NumberTypeInfo> {
     #[prop_or_default]
     pub step: Option<T>,
 
+    /// Number of decimal places to round to in case of floating point numbers.
+    /// Defaults to 5 decimal places, which should cover most most cases.
+    ///
+    /// Does nothing for integers.
+    #[builder(IntoPropValue, into_prop_value)]
+    #[prop_or(5)]
+    pub decimal_places: u8,
+
     /// Force value.
     ///
     /// To implement controlled components (for use without a FormContext).
@@ -562,7 +576,7 @@ impl<T: NumberTypeInfo> ManagedField for NumberField<T> {
                 let n = match (n, self.result.is_ok()) {
                     (None, true) => Some(T::default().clamp_value(props.min, props.max)),
                     (Some(n), _) => {
-                        let next = T::step_up(&n, props.step);
+                        let next = T::step_up(&n, props.step, props.decimal_places);
                         match props.max {
                             Some(max) if next <= max => {}
                             None => {}
@@ -582,7 +596,7 @@ impl<T: NumberTypeInfo> ManagedField for NumberField<T> {
                 let n = match (n, self.result.is_ok()) {
                     (None, true) => Some(T::default().clamp_value(props.min, props.max)),
                     (Some(n), _) => {
-                        let next = T::step_down(&n, props.step);
+                        let next = T::step_down(&n, props.step, props.decimal_places);
                         match props.min {
                             Some(min) if next >= min => {}
                             None => {}
-- 
2.53.0