Add culture-aware decimal input cleaning to formatter

Implemented CleanInput in DecimalFormatter to normalize and sanitize decimal input strings, handling group and decimal separators per culture and limiting fractional digits. DecimalEntryBehavior now delegates input cleaning to the formatter for consistent, culture-aware normalization.

Author: IsmailHassani

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

@@ -21,6 +21,63 @@ public override string FormatValue(decimal value)
         return value.ToString($"N{_decimalPlaces}", _culture);
     }
 
+    /// <summary>
+    /// Cleans and normalizes decimal input, preserving the fractional part up to DecimalPlaces.
+    /// </summary>
+    public override string CleanInput(string input)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+            return string.Empty;
+
+        var decimalSeparator = _culture.NumberFormat.NumberDecimalSeparator;
+        var groupSeparator = _culture.NumberFormat.NumberGroupSeparator;
+        
+        // Remove group separators
+        var cleaned = input.Replace(groupSeparator, string.Empty).Trim();
+        
+        // Normalize alternative decimal separators to culture-specific separator
+        var alternativeSeparators = new[] { ".", ",", "·", "٫" }
+            .Where(s => s != decimalSeparator && s != groupSeparator)
+            .ToArray();
+
+        foreach (var separator in alternativeSeparators)
+        {
+            cleaned = cleaned.Replace(separator, decimalSeparator);
+        }
+
+        // Split on the decimal separator
+        if (cleaned.Contains(decimalSeparator))
+        {
+            var parts = cleaned.Split(new[] { decimalSeparator }, StringSplitOptions.None);
+            
+            if (parts.Length > 2)
+            {
+                // Multiple decimal separators - take first two parts only
+                parts = new[] { parts[0], parts[1] };
+            }
+
+            // Preserve integer part and fractional part (up to DecimalPlaces)
+            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))
+            {
+                return integerPart + decimalSeparator + fractionalPart;
+            }
+            
+            return integerPart;
+        }
+
+        return cleaned;
+    }
+
     public bool HasValidDecimalPlaces(decimal value)
     {
         var decimalPlaces = BitConverter.GetBytes(decimal.GetBits(value)[3])[2];

src/ISynergy.Framework.UI.Maui/Behaviors/DecimalEntryBehavior.cs

@@ -59,6 +59,17 @@ protected override string FormatValue(decimal value)
         return _formatter.FormatValue(rounded);
     }
 
+    protected override string CleanInput(string input)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+            return string.Empty;
+
+        _formatter ??= new DecimalFormatter(Culture, DecimalPlaces);
+
+        // Use the formatter's CleanInput which preserves the fractional part
+        return _formatter.CleanInput(input);
+    }
+
     private void UpdateFormatter()
     {
         _formatter = new DecimalFormatter(Culture, DecimalPlaces);