Merge branch 'release/18.1.1'

Author: joanpablo

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 18.1.1
+
+## Fixes
+- Fix `NumberValidator` to correctly handle decimal numbers with trailing zeros.
+- Improve `NumberValidator` to correctly validate numbers with multiple decimal points, single dot, and dot at the end.
+
 # 18.1.0
 
 - Add `oneOf` validator to the list of validators.
@@ -1000,4 +1006,4 @@ to migrate from version 1.x to 2.x.
 
 - ReactiveForm
 - ReactiveFormConsumer
-- ReactiveValueListenableBuilder
+- ReactiveValueListenableBuilder

README.md

@@ -1,4 +1,4 @@
-'''# Reactive Forms
+# Reactive Forms
 
 This is a model-driven approach to handling form inputs and validations, heavily inspired by [Angular's Reactive Forms](https://angular.io/guide/reactive-forms).
 
@@ -88,7 +88,7 @@ dependencies:
   flutter:
     sdk: flutter
 
-  reactive_forms: ^18.1.0
+  reactive_forms: ^18.1.1
 ```
 
 Then, run the command `flutter packages get` in the console.
@@ -1756,4 +1756,3 @@ You can also check the [Star Rating with Flutter Reactive Forms](https://dev.to/
 
 Visit the [Migration Guide](https://github.com/joanpablo/reactive_forms/wiki/Migration-Guide) to see
 more details about different version breaking changes.
-''

lib/src/validators/number_validator.dart

@@ -5,7 +5,42 @@
 import 'package:reactive_forms/reactive_forms.dart';
 import 'package:reactive_forms/src/validators/number_validator_error.dart';
 
-/// Validator that validates if control's value is a numeric value.
+/// A validator that checks if a control's value represents a valid number.
+///
+/// This validator can be used for both `String` and `num` types. It provides
+/// options to allow or disallow null values, negative numbers, and to specify
+/// the number of allowed decimal places.
+///
+/// ## Example:
+///
+/// ```dart
+/// final control = FormControl<String>(
+///   validators: [Validators.number()],
+/// );
+///
+/// control.value = '123';
+/// print(control.valid); // true
+///
+/// control.value = 'abc';
+/// print(control.valid); // false
+///
+/// control.value = '12.34';
+/// print(control.valid); // false, because decimals are not allowed by default
+/// ```
+///
+/// To allow decimals, you can use the `allowedDecimals` parameter:
+///
+/// ```dart
+/// final decimalControl = FormControl<String>(
+///   validators: [Validators.number(allowedDecimals: 2)],
+/// );
+///
+/// decimalControl.value = '12.34';
+/// print(decimalControl.valid); // true
+///
+/// decimalControl.value = '12.345';
+/// print(decimalControl.valid); // false, as it exceeds the allowed decimal places
+/// ```
 class NumberValidator extends Validator<dynamic> {
   /// The regex expression of a numeric string value.
   static final RegExp notNumbersRegex = RegExp(r'[^0-9.]');
@@ -93,17 +128,17 @@ class NumberValidator extends Validator<dynamic> {
     // Split the number string at the decimal point
     final parts = numberString.split('.');
 
-    if (parts.length > 2) {
+    if (parts.length > 2 || numberString == '.' || numberString.endsWith('.')) {
       // More than one decimal point, invalid format
       return false;
     }
 
     if (parts.length == 1) {
-      // No decimal part, validate it has 0 decimals
-      return allowedDecimals == 0;
+      // No decimal part, so it's valid
+      return true;
     }
 
-    // Check if the decimal part length is equal to the allowed decimals
-    return parts[1].length == allowedDecimals;
+    // Check if the decimal part length is within the allowed limit
+    return parts[1].length <= allowedDecimals;
   }
 }

lib/src/validators/validators.dart

@@ -131,10 +131,101 @@ class Validators {
   /// validation test.
   static Validator<dynamic> get email => const EmailValidator();
 
-  /// Creates a validator function that checks if a control's value is a valid number.
+  /// Creates a validator that checks if a control's value is a valid number.
   ///
-  /// [allowedDecimals] (optional): The allowed number of decimal places. Defaults to 0.
-  /// [allowNegatives] (optional): Whether to allow negative numbers. Defaults to true.
+  /// This validator can be applied to controls with `String` or `num` (int, double) values.
+  /// It provides fine-grained control over what constitutes a valid number:
+  ///
+  /// - [allowNull]: If `true`, a `null` control value is considered valid. Defaults to `false`.
+  /// - [allowedDecimals]: Specifies the maximum number of digits allowed after the decimal point.
+  ///   Defaults to `0`, meaning only integers are allowed. For example, `allowedDecimals: 2`
+  ///   would allow numbers like `123.45` or `123.4` but not `123.456`.
+  /// - [allowNegatives]: If `true`, negative numbers (e.g., `-10`) are considered valid.
+  ///   Defaults to `true`.
+  ///
+  /// The validation error is exposed under the `ValidationMessage.number` key.
+  /// Possible error values include `NumberValidatorError.nullValue` (if `allowNull` is `false`
+  /// and the value is `null`), `NumberValidatorError.unsignedNumber` (if `allowNegatives` is
+  /// `false` and the number is negative), `NumberValidatorError.invalidDecimals` (if the number
+  /// of decimal places exceeds `allowedDecimals`), or `NumberValidatorError.invalidNumber`
+  /// (for non-numeric input or invalid formatting).
+  ///
+  /// ## Examples:
+  ///
+  /// ### Basic Usage (Integer only, not null, positive):
+  /// ```dart
+  /// final control = FormControl<String>(validators: [Validators.number()]);
+  ///
+  /// control.value = '123';
+  /// print(control.valid); // true
+  ///
+  /// control.value = '-123';
+  /// print(control.valid); // true (allowNegatives is true by default)
+  ///
+  /// control.value = '12.34';
+  /// print(control.valid); // false (allowedDecimals is 0 by default)
+  ///
+  /// control.value = 'abc';
+  /// print(control.valid); // false
+  ///
+  /// control.value = null;
+  /// print(control.valid); // false (allowNull is false by default)
+  /// ```
+  ///
+  /// ### Allowing Decimals:
+  /// ```dart
+  /// final decimalControl = FormControl<String>(
+  ///   validators: [Validators.number(allowedDecimals: 2)],
+  /// );
+  ///
+  /// decimalControl.value = '12.34';
+  /// print(decimalControl.valid); // true
+  ///
+  /// decimalControl.value = '12.345';
+  /// print(decimalControl.valid); // false (too many decimal places)
+  ///
+  /// decimalControl.value = '12';
+  /// print(decimalControl.valid); // true (integers are valid when decimals are allowed)
+  /// ```
+  ///
+  /// ### Disallowing Negative Numbers:
+  /// ```dart
+  /// final positiveControl = FormControl<String>(
+  ///   validators: [Validators.number(allowNegatives: false)],
+  /// );
+  ///
+  /// positiveControl.value = '100';
+  /// print(positiveControl.valid); // true
+  ///
+  /// positiveControl.value = '-50';
+  /// print(positiveControl.valid); // false
+  /// ```
+  ///
+  /// ### Allowing Null Values:
+  /// ```dart
+  /// final nullableControl = FormControl<String>(
+  ///   validators: [Validators.number(allowNull: true)],
+  /// );
+  ///
+  /// nullableControl.value = null;
+  /// print(nullableControl.valid); // true
+  ///
+  /// nullableControl.value = '123';
+  /// print(nullableControl.valid); // true
+  /// ```
+  ///
+  /// ### Using with `double` type controls:
+  /// ```dart
+  /// final doubleControl = FormControl<double>(
+  ///   validators: [Validators.number(allowedDecimals: 2)],
+  /// );
+  ///
+  /// doubleControl.value = 123.45;
+  /// print(doubleControl.valid); // true
+  ///
+  /// doubleControl.value = 123.456;
+  /// print(doubleControl.valid); // false
+  /// ```
   static Validator<dynamic> number({
     bool allowNull = false,
     int allowedDecimals = 0,

pubspec.yaml

@@ -1,6 +1,6 @@
 name: reactive_forms
 description: This is a model-driven approach to handling form inputs and validations, heavily inspired in Angular Reactive Forms.
-version: 18.1.0
+version: 18.1.1
 homepage: "https://github.com/joanpablo/reactive_forms"
 
 environment:

test/src/validators/number_validator_test.dart

@@ -83,5 +83,137 @@ void main() {
         NumberValidatorError.invalidDecimals,
       );
     });
+
+    test('FormControl of type String valid decimal numbers with .00', () {
+      final control = FormControl<String>(
+        validators: [Validators.number(allowedDecimals: 2)],
+      );
+
+      control.value = '10.00';
+
+      expect(control.valid, true);
+      expect(control.errors.isEmpty, true);
+    });
+
+    test('FormControl of type double valid decimal numbers with .00', () {
+      final control = FormControl<double>(
+        validators: [Validators.number(allowedDecimals: 2)],
+      );
+
+      control.value = 10.00;
+
+      expect(control.valid, true);
+      expect(control.errors.isEmpty, true);
+    });
+
+    test(
+      'FormControl invalid negative number when allowNegatives is false',
+      () {
+        final control = FormControl<String>(
+          validators: [Validators.number(allowNegatives: false)],
+        );
+
+        control.value = '-10';
+
+        expect(control.valid, false);
+        expect(
+          control.errors[ValidationMessage.number],
+          NumberValidatorError.unsignedNumber,
+        );
+      },
+    );
+
+    test('FormControl invalid with multiple decimal points', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = '10.1.0';
+
+      expect(control.valid, false);
+      expect(
+        control.errors[ValidationMessage.number],
+        NumberValidatorError.invalidDecimals,
+      );
+    });
+
+    test('FormControl valid with leading/trailing spaces', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = ' 10 ';
+
+      expect(control.valid, true);
+    });
+
+    test('FormControl invalid with invalid characters', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = '10a.5';
+
+      expect(control.valid, false);
+      expect(
+        control.errors[ValidationMessage.number],
+        NumberValidatorError.invalidDecimals,
+      );
+    });
+
+    test('FormControl invalid with only spaces', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = '   ';
+
+      expect(control.valid, false);
+      expect(
+        control.errors[ValidationMessage.number],
+        NumberValidatorError.invalidNumber,
+      );
+    });
+
+    test('FormControl invalid with a single dot', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = '.';
+
+      expect(control.valid, false);
+      expect(
+        control.errors[ValidationMessage.number],
+        NumberValidatorError.invalidDecimals,
+      );
+    });
+
+    test('FormControl invalid with a dot at the end', () {
+      final control = FormControl<String>(validators: [Validators.number()]);
+
+      control.value = '10.';
+
+      expect(control.valid, false);
+      expect(
+        control.errors[ValidationMessage.number],
+        NumberValidatorError.invalidDecimals,
+      );
+    });
+
+    test(
+      'FormControl invalid with invalid characters and no decimal point',
+      () {
+        final control = FormControl<String>(validators: [Validators.number()]);
+
+        control.value = '1a0';
+
+        expect(control.valid, false);
+        expect(
+          control.errors[ValidationMessage.number],
+          NumberValidatorError.invalidNumber,
+        );
+      },
+    );
+
+    test('FormControl valid with a dot at the beginning', () {
+      final control = FormControl<String>(
+        validators: [Validators.number(allowedDecimals: 1)],
+      );
+
+      control.value = '.5';
+
+      expect(control.valid, true);
+    });
   });
 }