sapo-components-ui-rn 1.1.41 → 1.1.42

package/dist/index.esm.js

@@ -7438,15 +7438,15 @@ var styles$1 = StyleSheet.create(__assign({}, containerStyles));
 
 var formatNumberInput = function (value, formatDecimal) {
     if (!value)
-        return "0";
+        return "";
     if (value === "")
-        return "0";
+        return "";
     // Xử lý số âm
     var isNegative = value.startsWith("-");
     var _a = value.replace(/[^0-9.]/g, "").split("."), intPart = _a[0], decimalPart = _a[1];
     // Format phần nguyên
     intPart = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-    // Giới hạn phần thập phân
+    // Giới hạn phần thập phân 3 số
     if (decimalPart)
         decimalPart = decimalPart.slice(0, formatDecimal);
     var result = intPart;
@@ -7465,17 +7465,20 @@ var NumberKeyboard = function (_a) {
     var _k = useState(true), canSave = _k[0], setCanSave = _k[1];
     useEffect(function () {
         if (visible) {
-            setInputValue((value === null || value === void 0 ? void 0 : value.toString()) || "");
+            var newValue = (value === null || value === void 0 ? void 0 : value.toString()) || "";
+            setInputValue(newValue);
             // Logic mới: Không reset về trạng thái nhập mới khi đã có giá trị
-            // Chỉ set isFirstInput = true khi inputValue rỗng hoặc chỉ có dấu trừ
-            if (inputValue === "" || inputValue === "-") {
+            // Chỉ set isFirstInput = true khi newValue rỗng hoặc chỉ có dấu trừ
+            // Điều này cho phép người dùng tiếp tục nhập từ giá trị hiện tại
+            // Ví dụ: value=999, người dùng có thể nhập "000" để tạo "999000"
+            if (newValue === "" || newValue === "-") {
                 setIsFirstInput(true);
             }
             else {
                 setIsFirstInput(false);
             }
         }
-    }, [visible, value, inputValue]);
+    }, [visible, value]);
     useEffect(function () {
         var currentValue = Number(inputValue);
         var minValueNumber = Number(minValue);
@@ -7510,39 +7513,39 @@ var NumberKeyboard = function (_a) {
         }
         setCanSave(isValid);
     }, [inputValue, minValue, maxValue]);
-    var handleKeyPress = useCallback(function (key) {
+    var handleKeyPress = function (key) {
         if (key === "del") {
             setInputValue(function (prev) { return prev.slice(0, -1); });
-            setIsFirstInput(false);
-            return;
         }
-        if (key === "000") {
-            if (type === "integer" && inputValue.length > 0) {
+        else if (key === "000") {
+            if (type === "integer") {
                 // Xử lý trường hợp nhập "000" để tạo số lớn hơn
                 // Ví dụ: "1" + "000" = "1000", "10" + "000" = "10000"
                 // Nếu vượt quá maxValue, sẽ tự động cắt bớt số 0
-                var newInputValue_1 = inputValue + "000";
-                var newValue_1 = Number(newInputValue_1);
-                var maxValueNumber_1 = Number(maxValue);
+                // Logic này đảm bảo người dùng có thể tiếp tục nhập số đã được khởi tạo
+                // Ví dụ: value=999, người dùng có thể nhập "000" để tạo "999000"
+                var newInputValue = inputValue + "000";
+                var newValue = Number(newInputValue);
+                var maxValueNumber = Number(maxValue);
                 // Kiểm tra nếu giá trị vượt quá maxValue, cắt bớt số 0
-                if (!isNaN(newValue_1) &&
-                    !isNaN(maxValueNumber_1) &&
-                    newValue_1 > maxValueNumber_1) {
+                if (!isNaN(newValue) &&
+                    !isNaN(maxValueNumber) &&
+                    newValue > maxValueNumber) {
                     // Tìm số 0 tối đa có thể thêm vào mà không vượt quá maxValue
                     var tempValue = inputValue;
                     var tempNewValue = Number(tempValue + "000");
                     // Giảm dần số 0 cho đến khi không vượt quá maxValue
-                    while (tempNewValue > maxValueNumber_1 && tempValue.endsWith("0")) {
+                    while (tempNewValue > maxValueNumber && tempValue.endsWith("0")) {
                         tempValue = tempValue.slice(0, -1);
                         tempNewValue = Number(tempValue + "000");
                     }
                     // Nếu vẫn vượt quá, chỉ thêm số 0 có thể
-                    if (tempNewValue > maxValueNumber_1) {
+                    if (tempNewValue > maxValueNumber) {
                         // Tìm số 0 tối đa có thể thêm
                         var maxZeros = 0;
                         for (var i = 1; i <= 3; i++) {
                             var testValue = Number(inputValue + "0".repeat(i));
-                            if (testValue <= maxValueNumber_1) {
+                            if (testValue <= maxValueNumber) {
                                 maxZeros = i;
                             }
                             else {
@@ -7550,8 +7553,8 @@ var NumberKeyboard = function (_a) {
                             }
                         }
                         if (maxZeros > 0) {
-                            newInputValue_1 = inputValue + "0".repeat(maxZeros);
-                            newValue_1 = Number(newInputValue_1);
+                            newInputValue = inputValue + "0".repeat(maxZeros);
+                            newValue = Number(newInputValue);
                         }
                         else {
                             // Không thể thêm số 0 nào
@@ -7559,22 +7562,23 @@ var NumberKeyboard = function (_a) {
                         }
                     }
                     else {
-                        newInputValue_1 = tempValue + "000";
-                        newValue_1 = Number(newInputValue_1);
+                        newInputValue = tempValue + "000";
+                        newValue = Number(newInputValue);
                     }
                 }
                 // Kiểm tra xem có thể nhập được không sau khi xử lý "000"
-                if (!isNaN(newValue_1) &&
-                    !isNaN(maxValueNumber_1) &&
-                    newValue_1 <= maxValueNumber_1) {
-                    setInputValue(newInputValue_1);
+                if (!isNaN(newValue) &&
+                    !isNaN(maxValueNumber) &&
+                    newValue <= maxValueNumber) {
+                    setInputValue(newInputValue);
                 }
                 setIsFirstInput(false);
             }
-            return;
+            // Nếu type là float, không cho phép nhập "000" ở đầu
         }
-        if (key === ".") {
-            if (type === "float" && !inputValue.includes(".")) {
+        else if (key === ".") {
+            if (!inputValue.includes(".")) {
+                // Nếu inputValue là "0" hoặc rỗng, giữ lại số 0 và thêm dấu "."
                 if (inputValue === "0" || inputValue === "") {
                     setInputValue("0.");
                 }
@@ -7583,33 +7587,51 @@ var NumberKeyboard = function (_a) {
                     setInputValue("-0.");
                 }
                 else {
+                    // Nếu đã có giá trị, thêm dấu "." vào cuối
                     setInputValue(function (prev) { return prev + key; });
                 }
                 setIsFirstInput(false);
             }
-            return;
         }
-        if (isFirstInput) {
-            // Nếu type là float và key là "0", không cho phép nhập số 0 đầu tiên
-            if (type === "float" && (key === "0" || key === "000")) {
-                return;
-            }
-            // Kiểm tra xem có thể nhập được không khi là lần đầu
-            var newValue_2 = Number(key);
-            var maxValueNumber_2 = Number(maxValue);
-            if (!isNaN(newValue_2) && !isNaN(maxValueNumber_2)) {
-                var canInput_1 = false;
-                if (newValue_2 < 0) {
-                    // Với số âm, kiểm tra giá trị tuyệt đối không vượt quá maxValue
-                    var absNewValue = Math.abs(newValue_2);
-                    var absMaxValue = Math.abs(maxValueNumber_2);
-                    canInput_1 = absNewValue <= absMaxValue;
+        else {
+            if (isFirstInput) {
+                // Nếu type là float và key là "0", không cho phép nhập số 0 đầu tiên
+                if (type === "float" && key === "000") {
+                    return;
                 }
-                else {
-                    // Với số dương, kiểm tra bình thường
-                    canInput_1 = newValue_2 <= maxValueNumber_2;
+                // Cho phép nhập số 0 đầu tiên cho type float, nhưng không cho phép nhập "000"
+                // Kiểm tra xem có thể nhập được không khi là lần đầu
+                var newValue = Number(key);
+                var maxValueNumber = Number(maxValue);
+                if (!isNaN(newValue) && !isNaN(maxValueNumber)) {
+                    var canInput = false;
+                    if (newValue < 0) {
+                        // Với số âm, kiểm tra giá trị tuyệt đối không vượt quá maxValue
+                        var absNewValue = Math.abs(newValue);
+                        var absMaxValue = Math.abs(maxValueNumber);
+                        canInput = absNewValue <= absMaxValue;
+                    }
+                    else {
+                        // Với số dương, kiểm tra bình thường
+                        canInput = newValue <= maxValueNumber;
+                    }
+                    if (canInput) {
+                        // Nếu inputValue rỗng hoặc chỉ có dấu trừ, thay thế hoàn toàn
+                        if (inputValue === "" || inputValue === "-") {
+                            setInputValue(key);
+                        }
+                        else {
+                            // Nếu đã có giá trị, thêm vào cuối
+                            setInputValue(inputValue + key);
+                        }
+                        setIsFirstInput(false);
+                    }
+                    else {
+                        // Nếu vượt quá maxValue ngay từ đầu, không cho phép nhập
+                        return;
+                    }
                 }
-                if (canInput_1) {
+                else {
                     // Nếu inputValue rỗng hoặc chỉ có dấu trừ, thay thế hoàn toàn
                     if (inputValue === "" || inputValue === "-") {
                         setInputValue(key);
@@ -7620,137 +7642,129 @@ var NumberKeyboard = function (_a) {
                     }
                     setIsFirstInput(false);
                 }
-                else {
-                    // Nếu vượt quá maxValue ngay từ đầu, không cho phép nhập
-                    return;
-                }
-            }
-            else {
-                // Nếu inputValue rỗng hoặc chỉ có dấu trừ, thay thế hoàn toàn
-                if (inputValue === "" || inputValue === "-") {
-                    setInputValue(key);
-                }
-                else {
-                    // Nếu đã có giá trị, thêm vào cuối
-                    setInputValue(inputValue + key);
-                }
-                setIsFirstInput(false);
-            }
-            return;
-        }
-        // Kiểm tra nếu input bắt đầu bằng 0 và không có dấu chấm
-        if (inputValue === "0") {
-            if (key === ".") {
-                setInputValue("0.");
-                return;
-            }
-            else if (key >= "1" && key <= "9") {
-                setInputValue(key);
-                return;
             }
             else {
-                return;
-            }
-        }
-        var newInputValue = inputValue + key;
-        var newValue = Number(newInputValue);
-        var maxValueNumber = Number(maxValue);
-        // Kiểm tra xem có thể nhập được không
-        var canInput = false;
-        var shouldCheckLength = true;
-        if (!isNaN(newValue) && !isNaN(maxValueNumber)) {
-            if (newValue < 0) {
-                // Với số âm, kiểm tra giá trị tuyệt đối không vượt quá maxValue
-                var absNewValue = Math.abs(newValue);
-                var absMaxValue = Math.abs(maxValueNumber);
-                if (absNewValue <= absMaxValue) {
-                    canInput = true;
-                }
-                else {
-                    // Nếu vượt quá maxValue, kiểm tra xem có thể nhập được không
-                    var maxValueStr = absMaxValue.toString();
-                    inputValue.length;
-                    var newLength = newInputValue.length;
-                    // Nếu độ dài mới lớn hơn độ dài của maxValue, không cho phép nhập
-                    if (newLength > maxValueStr.length) {
-                        return;
-                    }
-                    // Nếu độ dài bằng nhau, kiểm tra giá trị
-                    if (newLength === maxValueStr.length && absNewValue > absMaxValue) {
+                // Kiểm tra nếu input bắt đầu bằng 0 và không có dấu chấm
+                if (inputValue === "0") {
+                    if (key === ".") {
+                        setInputValue("0.");
                         return;
                     }
-                    // Nếu độ dài nhỏ hơn, có thể nhập được (sẽ kiểm tra khi nhập tiếp)
-                    canInput = true;
-                    shouldCheckLength = false;
-                }
-            }
-            else {
-                // Với số dương, kiểm tra bình thường
-                if (newValue <= maxValueNumber) {
-                    canInput = true;
-                }
-                else {
-                    // Nếu vượt quá maxValue, kiểm tra xem có thể nhập được không
-                    var maxValueStr = maxValueNumber.toString();
-                    inputValue.length;
-                    var newLength = newInputValue.length;
-                    // Nếu độ dài mới lớn hơn độ dài của maxValue, không cho phép nhập
-                    if (newLength > maxValueStr.length) {
+                    else if (key >= "1" && key <= "9") {
+                        setInputValue(key);
                         return;
                     }
-                    // Nếu độ dài bằng nhau, kiểm tra giá trị
-                    if (newLength === maxValueStr.length && newValue > maxValueNumber) {
+                    else {
                         return;
                     }
-                    // Nếu độ dài nhỏ hơn, có thể nhập được (sẽ kiểm tra khi nhập tiếp)
-                    // Ví dụ: maxValue = 999, inputValue = "99", nhập "9" → "999" (OK)
-                    canInput = true;
-                    shouldCheckLength = false;
-                }
-            }
-        }
-        if (canInput) {
-            if (inputValue.includes(".")) {
-                // Xử lý số thập phân
-                var _a = inputValue.split("."); _a[0]; var _b = _a[1], decimalPart = _b === void 0 ? "" : _b;
-                if (newInputValue.length <= 12 && decimalPart.length === 0) {
-                    setInputValue(function (prev) { return prev + key; });
                 }
-                else if (newInputValue.length <= 12 &&
-                    decimalPart.length < formatDecimal) {
-                    setInputValue(function (prev) { return prev + key; });
-                }
-            }
-            else {
-                // Xử lý số nguyên
-                if (shouldCheckLength && newInputValue.length <= 12) {
-                    setInputValue(function (prev) { return prev + key; });
+                var newInputValue = inputValue + key;
+                var newValue = Number(newInputValue);
+                var maxValueNumber = Number(maxValue);
+                // Kiểm tra xem có thể nhập được không
+                var canInput = false;
+                var shouldCheckLength = true;
+                if (!isNaN(newValue) && !isNaN(maxValueNumber)) {
+                    if (newValue < 0) {
+                        // Với số âm, kiểm tra giá trị tuyệt đối không vượt quá maxValue
+                        var absNewValue = Math.abs(newValue);
+                        var absMaxValue = Math.abs(maxValueNumber);
+                        if (absNewValue <= absMaxValue) {
+                            canInput = true;
+                        }
+                        else {
+                            // Nếu vượt quá maxValue, kiểm tra xem có thể nhập được không
+                            var maxValueStr = absMaxValue.toString();
+                            inputValue.length;
+                            var newLength = newInputValue.length;
+                            // Nếu độ dài mới lớn hơn độ dài của maxValue, không cho phép nhập
+                            if (newLength > maxValueStr.length) {
+                                return;
+                            }
+                            // Nếu độ dài bằng nhau, kiểm tra giá trị
+                            if (newLength === maxValueStr.length &&
+                                absNewValue > absMaxValue) {
+                                return;
+                            }
+                            // Nếu độ dài nhỏ hơn, có thể nhập được (sẽ kiểm tra khi nhập tiếp)
+                            canInput = true;
+                            shouldCheckLength = false;
+                        }
+                    }
+                    else {
+                        // Với số dương, kiểm tra bình thường
+                        if (newValue <= maxValueNumber) {
+                            canInput = true;
+                        }
+                        else {
+                            // Nếu vượt quá maxValue, kiểm tra xem có thể nhập được không
+                            var maxValueStr = maxValueNumber.toString();
+                            inputValue.length;
+                            var newLength = newInputValue.length;
+                            // Nếu độ dài mới lớn hơn độ dài của maxValue, không cho phép nhập
+                            if (newLength > maxValueStr.length) {
+                                return;
+                            }
+                            // Nếu độ dài bằng nhau, kiểm tra giá trị
+                            if (newLength === maxValueStr.length &&
+                                newValue > maxValueNumber) {
+                                return;
+                            }
+                            // Nếu độ dài nhỏ hơn, có thể nhập được (sẽ kiểm tra khi nhập tiếp)
+                            // Ví dụ: maxValue = 999, inputValue = "99", nhập "9" → "999" (OK)
+                            canInput = true;
+                            shouldCheckLength = false;
+                        }
+                    }
                 }
-                else if (!shouldCheckLength) {
-                    // Nếu không cần kiểm tra độ dài (đã kiểm tra maxValue ở trên)
-                    setInputValue(function (prev) { return prev + key; });
+                if (canInput) {
+                    if (inputValue.includes(".")) {
+                        // Xử lý số thập phân
+                        var _a = inputValue.split("."); _a[0]; var _b = _a[1], decimalPart = _b === void 0 ? "" : _b;
+                        if (newInputValue.length <= 12 && decimalPart.length === 0) {
+                            setInputValue(function (prev) { return prev + key; });
+                        }
+                        else if (newInputValue.length <= 12 && decimalPart.length < 3) {
+                            setInputValue(function (prev) { return prev + key; });
+                        }
+                    }
+                    else {
+                        // Xử lý số nguyên
+                        if (shouldCheckLength && newInputValue.length <= 12) {
+                            setInputValue(function (prev) { return prev + key; });
+                        }
+                        else if (!shouldCheckLength) {
+                            // Nếu không cần kiểm tra độ dài (đã kiểm tra maxValue ở trên)
+                            setInputValue(function (prev) { return prev + key; });
+                        }
+                    }
                 }
             }
         }
-    }, [inputValue, maxValue, type, formatDecimal, isFirstInput]);
+    };
     var handleClear = useCallback(function () {
         setInputValue("");
         setIsFirstInput(true);
     }, []);
     var handleSave = useCallback(function () {
-        if (!canSave)
-            return;
         var finalValue = inputValue;
         if (inputValue.endsWith(".")) {
             finalValue = inputValue.slice(0, -1);
         }
-        onChangeText === null || onChangeText === void 0 ? void 0 : onChangeText(finalValue);
+        if (type === "integer") {
+            onChangeText === null || onChangeText === void 0 ? void 0 : onChangeText(finalValue);
+        }
+        else {
+            onChangeText === null || onChangeText === void 0 ? void 0 : onChangeText(formatNumberInput(finalValue, formatDecimal));
+        }
         onClose();
-    }, [inputValue, onChangeText, onClose, canSave]);
+    }, [inputValue, onChangeText, onClose, type, formatDecimal]);
     var handleClose = useCallback(function () {
         onClose();
-        setIsFirstInput(true);
-    }, [onClose]);
+        setTimeout(function () {
+            setInputValue((value === null || value === void 0 ? void 0 : value.toString()) || "");
+        }, 300);
+    }, [onClose, value]);
     return (React__default.createElement(Modal, { visible: visible, transparent: true, animationType: "fade", onRequestClose: handleClose },
         React__default.createElement(TouchableOpacity, { style: styles.modalOverlay, activeOpacity: 1, onPress: handleClose },
             React__default.createElement(View, { onPress: function () { }, activeOpacity: 1, backgroundColor: colors.surfacePrimaryDefault, style: styles.modalContent },