Improve decimal input handling and formatting robustness

- DecimalFormatter now preserves full fractional input (no truncation).
- Added IsFormatting attached property to NumericEntryBehaviorBase to prevent recursive updates.
- Enhanced OnEntryTextChanged to use delayed dispatcher for formatting, ensuring UI consistency.
- Clarified CurrencyToStringConverter behavior and docs; now attempts currency parsing first in ConvertBack for better robustness with formatted input.

Author: IsmailHassani

src/ISynergy.Framework.Core/Formatters/DecimalFormatter.cs

@@ -22,7 +22,7 @@ public override string FormatValue(decimal value)
     }
 
     /// <summary>
-    /// Cleans and normalizes decimal input, preserving the fractional part up to DecimalPlaces.
+    /// Cleans and normalizes decimal input, preserving the fractional part.
     /// </summary>
     public override string CleanInput(string input)
     {
@@ -56,16 +56,10 @@ public override string CleanInput(string input)
                 parts = new[] { parts[0], parts[1] };
             }
 
-            // Preserve integer part and fractional part (up to DecimalPlaces)
+            // Preserve integer part and fractional part (do NOT truncate here)
             var integerPart = parts[0];
             var fractionalPart = parts.Length > 1 ? parts[1] : string.Empty;
 
-            // Limit fractional part to DecimalPlaces
-            if (fractionalPart.Length > _decimalPlaces)
-            {
-                fractionalPart = fractionalPart.Substring(0, _decimalPlaces);
-            }
-
             // Rejoin with culture-specific decimal separator
             if (!string.IsNullOrEmpty(fractionalPart))
             {

src/ISynergy.Framework.UI.Maui/Behaviors/Base/NumericEntryBehaviorBase.cs

@@ -12,6 +12,18 @@ public abstract class NumericEntryBehaviorBase : Behavior<Entry>
     private bool _isUpdating;
     private string _lastValidText = string.Empty;
 
+    /// <summary>
+    /// Attached property to indicate the entry is being formatted by the behavior.
+    /// </summary>
+    public static readonly BindableProperty IsFormattingProperty = BindableProperty.CreateAttached(
+        "IsFormatting",
+        typeof(bool),
+        typeof(NumericEntryBehaviorBase),
+        defaultValue: false);
+
+    public static bool GetIsFormatting(BindableObject view) => (bool)view.GetValue(IsFormattingProperty);
+    public static void SetIsFormatting(BindableObject view, bool value) => view.SetValue(IsFormattingProperty, value);
+
     public static readonly BindableProperty MinimumValueProperty = BindableProperty.Create(
         nameof(MinimumValue),
         typeof(decimal?),
@@ -200,17 +212,27 @@ private void OnUnfocused(object? sender, FocusEventArgs e)
         if (TryParseInput(currentText, out var value) && IsValueValid(value))
         {
             _isUpdating = true;
-            try
-            {
-                // Format will handle rounding
-                var formatted = FormatValue(value);
-                entry.Text = formatted;
-                _lastValidText = formatted;
-            }
-            finally
+            SetIsFormatting(entry, true);
+            
+            // Format will handle rounding
+            var formatted = FormatValue(value);
+            _lastValidText = formatted;
+            
+            // Set the formatted text immediately
+            entry.Text = formatted;
+            
+            // Use dispatcher to clear the formatting flag after the binding cycle completes
+            entry.Dispatcher.DispatchDelayed(TimeSpan.FromMilliseconds(50), () =>
             {
+                SetIsFormatting(entry, false);
                 _isUpdating = false;
-            }
+                
+                // Reapply formatted text if it was overwritten
+                if (entry.Text != formatted && !entry.IsFocused)
+                {
+                    entry.Text = formatted;
+                }
+            });
         }
         else
         {

src/ISynergy.Framework.UI.Maui/Converters/CurrencyConverters.cs

@@ -49,21 +49,22 @@ public object ConvertBack(object? value, Type targetType, object? parameter, Cul
 public class CurrencyToStringConverter : IValueConverter
 {
     /// <summary>
-    /// Converts decimal to string without formatting (raw value).
+    /// Converts decimal to string for display.
     /// </summary>
     /// <param name="value">The decimal value.</param>
     /// <param name="targetType">Type of the target.</param>
-    /// <param name="parameter">Optional: Not used - behavior handles formatting.</param>
+    /// <param name="parameter">Optional: Pass "formatted" to return currency-formatted value.</param>
     /// <param name="culture">The culture.</param>
-    /// <returns>Raw string representation or empty string for zero values.</returns>
+    /// <returns>String representation for entry binding.</returns>
     public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
     {
         if (value is decimal decimalValue)
         {
             if (decimalValue == 0m)
                 return string.Empty;
 
-            // Return raw value without formatting - behavior will format on blur
+            // Return raw value for editing - the behavior will format with currency symbol on blur
+            // The behavior handles the formatting lifecycle (raw during edit, formatted on blur)
             return decimalValue.ToString(culture);
         }
         return string.Empty;
@@ -81,7 +82,13 @@ public object ConvertBack(object? value, Type targetType, object? parameter, Cul
     {
         if (value is string stringValue && !string.IsNullOrWhiteSpace(stringValue))
         {
-            // Remove currency symbols and other formatting - accept any valid input
+            // Try to parse as currency first (handles formatted values with currency symbols)
+            if (decimal.TryParse(stringValue, NumberStyles.Currency, culture, out var currencyResult))
+            {
+                return currencyResult;
+            }
+            
+            // Fallback: Remove currency symbols and other formatting - accept any valid input
             var cleaned = new string(stringValue.Where(c => 
                 char.IsDigit(c) || 
                 c.ToString() == culture.NumberFormat.NumberDecimalSeparator ||