@linzjs/step-ag-grid 7.6.2 → 7.8.0

package/dist/src/utils/textValidator.d.ts

@@ -5,5 +5,13 @@ export interface TextInputValidatorProps<RowType extends GridBaseRow> {
     maxLength?: number;
     maxBytes?: number;
     invalid?: (value: string, data: RowType, context: any) => JSX.Element | string | null;
+    numberFormat?: {
+        precision?: number;
+        scale?: number;
+        gtMin?: number;
+        geMin?: number;
+        ltMax?: number;
+        leMax?: number;
+    };
 }
 export declare const TextInputValidator: <RowType extends GridBaseRow>(props: TextInputValidatorProps<RowType>, value: string | null, data: RowType, context: any) => string | JSX.Element | null;

package/dist/src/utils/textValidator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/step-ag-grid.esm.js

@@ -1306,7 +1306,7 @@ var wait$2 = function (timeoutMs) {
     });
 };
 var isFloat = function (value) {
-    var regexp = /^-?\d+(\.\d+)?$/;
+    var regexp = /^-?\d*(\.\d+)?$/;
     return regexp.test(value);
 };
 var findParentWithClass = function (className, child) {
@@ -4176,17 +4176,47 @@ var TextInputValidator = function (props, value, data, context) {
         return null;
     // This can happen because subcomponent is invoked without type safety
     if (typeof value !== "string") {
-        console.error("Value is not a string", value);
-        return null;
+        return "Value is not a string";
     }
-    if (props.required && value.length === 0) {
-        return "Some text is required";
+    if (props.required && value == "") {
+        return "Must not be empty";
     }
     if (props.maxLength && value.length > props.maxLength) {
-        return "Text must be no longer than ".concat(props.maxLength, " characters");
+        return "Must be no longer than ".concat(props.maxLength, " characters");
     }
     if (props.maxBytes && stringByteLengthIsInvalid(value, props.maxBytes)) {
-        return "Text must be no longer than ".concat(props.maxLength, " bytes");
+        return "Must be no longer than ".concat(props.maxBytes, " bytes");
+    }
+    var nf = props.numberFormat;
+    if (nf) {
+        if (value != "" && !isFloat(value)) {
+            return "Must be a valid number";
+        }
+        if (value != "") {
+            var number = parseFloat(value);
+            if (nf.gtMin != null && number <= nf.gtMin) {
+                return "Must be greater than ".concat(nf.gtMin);
+            }
+            if (nf.geMin != null && number < nf.geMin) {
+                return "Must not be less than ".concat(nf.geMin);
+            }
+            if (nf.ltMax != null && number >= nf.ltMax) {
+                return "Must be less than ".concat(nf.ltMax);
+            }
+            if (nf.leMax != null && number > nf.leMax) {
+                return "Must not be greater than ".concat(nf.leMax);
+            }
+            if (nf.precision != null && value != "") {
+                if (parseFloat(number.toPrecision(nf.precision)) != number) {
+                    return "Must have no more than ".concat(nf.precision, " digits precision");
+                }
+            }
+            if (nf.scale != null && value != "") {
+                if (parseFloat(number.toFixed(nf.scale)) != number) {
+                    return nf.scale == 0 ? "Must be a whole number" : "Must have no more than ".concat(nf.scale, " decimal places");
+                }
+            }
+        }
     }
     if (props.invalid) {
         return props.invalid(value, data, context);