@progress/kendo-react-inputs 5.6.0-dev.202208251227 → 5.7.0-sig.202208281415

package/src/numerictextbox/utils/index.tsx

@@ -0,0 +1,744 @@
+import { NumericTextBoxState } from '../interfaces/NumericTextBoxState';
+import { NumberFormatOptions } from '@progress/kendo-react-intl';
+
+const DEFAULT_NUMBER = 1111111.1111111;
+const MAX_DECIMAL = 0.31111111111111117;
+const MIN_DECIMAL = 1;
+const ONE_NUMBER = 1;
+const ZERO_NUMBER = 0;
+const DIGITS_REGEX = /\d/;
+const MAX_PRECISION = 15;
+
+/**
+ * @hidden
+ */
+export const getInitialState = () => ({
+    eventValue: null,
+    prevLooseValue: '',
+    currentLooseValue: '',
+
+    focused: false,
+
+    selectionStart: undefined,
+    selectionEnd: undefined,
+    decimalSelect: false,
+    valueIsCorrected: false,
+    valueIsOutOfRange: false
+} as NumericTextBoxState);
+
+/**
+ * @hidden
+ */
+export const getStateOrPropsValue = (
+    value: number | null | undefined,
+    stateValue: number | null | undefined
+): number | null | undefined => {
+    return value !== undefined ? value : stateValue;
+};
+
+/**
+ * @hidden
+ */
+export const formatValue = (
+    value: string | number | null | undefined,
+    format: string | NumberFormatOptions | undefined,
+    intlService: any
+): string => {
+    if (value === null && value === undefined) {
+        return '';
+    }
+
+    if (typeof value === 'string') {
+        return value;
+    }
+
+    return intlService.formatNumber(value, format);
+};
+
+/**
+ * @hidden
+ */
+export const fractionLength = (value: number) => {
+    return (String(value).split('.')[1] || '').length;
+};
+
+/**
+ * @hidden
+ */
+const maxFractionLength = (value1: number, value2: number): number => {
+    return Math.max(fractionLength(value1), fractionLength(value2));
+};
+
+/**
+ * @hidden
+ */
+export const limitPrecision = (precision: number): number => Math.min(precision, MAX_PRECISION);
+
+/**
+ * @hidden
+ */
+export const toFixedPrecision = (value: number, precision: number): number => {
+    const maxPrecision = limitPrecision(precision);
+
+    return parseFloat(value.toFixed(maxPrecision));
+};
+
+/**
+ * @hidden
+ */
+export const increaseValue = (value: any, newState: any, step: any, min: any, max: any, format: any, intlService: any) => {
+    const maxPrecision = maxFractionLength(value || 0, step || 0);
+    const increasedValue = rangeValue(toFixedPrecision((value || 0) + (step || 0), maxPrecision), min, max);
+
+    newState.eventValue = increasedValue;
+    newState.currentLooseValue = formatValue(increasedValue, format, intlService);
+
+    newState.selectionStart = newState.selectionEnd = getLastNumberIndex(newState.currentLooseValue, DIGITS_REGEX);
+};
+
+/**
+ * @hidden
+ */
+export const decreaseValue = (value: any, newState: any, step: any, min: any, max: any, format: any, intlService: any) => {
+    const maxPrecision = maxFractionLength(value || 0, step || 0);
+    const decreasedValue = rangeValue(toFixedPrecision((value || 0) - (step || 0), maxPrecision), min, max);
+
+    newState.eventValue = decreasedValue;
+    newState.currentLooseValue = formatValue(decreasedValue, format, intlService);
+    newState.selectionStart = newState.selectionEnd = getLastNumberIndex(newState.currentLooseValue, DIGITS_REGEX);
+};
+
+/**
+ * @hidden
+ */
+export const rangeValue = (value: number | null, min?: number, max?: number): number | null => {
+    if (value == null) {
+        return value;
+    }
+
+    if (!(value > 1 || value < 1 || value === 1)) {
+        // null, undefined or NaN
+        return null;
+    }
+
+    if (max !== undefined && min !== undefined && max < min) {
+        return null;
+    }
+
+    if (max !== undefined && value > max) {
+        value = max;
+    }
+
+    if (min !== undefined && value! < min) {
+        value = min;
+    }
+
+    return value;
+};
+
+/**
+ * @hidden
+ */
+export const getMaxCursorPosition = (nextValue: string, formatInfo: string[][]) => {
+    const formatSuffixIndex = formatInfo.findIndex(([_, currSuffix]) => {
+        return Boolean(currSuffix) && nextValue.indexOf(currSuffix) === nextValue.length - currSuffix.length;
+    });
+
+    if (formatSuffixIndex === -1) {
+        return -1;
+    }
+
+    const suffix = formatInfo[formatSuffixIndex][1];
+    return nextValue.length - suffix.length;
+};
+
+/**
+ * @hidden
+ */
+export const getMinCursorPosition = (nextValue: string, formatInfo: string[][]) => {
+    const formatPrefixIndex = formatInfo.findIndex(([currPrefix, _]) => {
+        return Boolean(currPrefix) && nextValue.indexOf(currPrefix) === 0;
+    });
+
+    if (formatPrefixIndex === -1) {
+        return -1;
+    }
+
+    const prefix = formatInfo[formatPrefixIndex][0];
+    return prefix.length;
+};
+
+/**
+ * @hidden
+ */
+export const rangeSelection = (nextLooseValue: string, formatInfo: string[][], newState: NumericTextBoxState) => {
+    const maxPosition = getMaxCursorPosition(nextLooseValue, formatInfo);
+
+    if (maxPosition !== -1 && newState.selectionStart! > maxPosition) {
+        newState.selectionStart = newState.selectionEnd = maxPosition;
+        return;
+    }
+
+    if (newState.selectionStart! > nextLooseValue.length) {
+        newState.selectionStart = newState.selectionEnd = nextLooseValue.length;
+    }
+
+    const minPosition = getMinCursorPosition(nextLooseValue, formatInfo);
+
+    if (minPosition !== -1 && newState.selectionStart! < minPosition) {
+        newState.selectionStart = newState.selectionEnd = minPosition;
+    }
+
+    if (newState.selectionStart! === -1) {
+        newState.selectionStart = newState.selectionEnd = 0;
+    }
+};
+
+/**
+ * @hidden
+ */
+export const setSelection = (newState: NumericTextBoxState, newIndex: number, nextLooseValue: string, formatInfo: string[][]) => {
+    newState.selectionStart = newState.selectionEnd = newIndex;
+
+    rangeSelection(nextLooseValue, formatInfo, newState);
+};
+
+/**
+ * @hidden
+ */
+export const setInvalid = (
+    newState: NumericTextBoxState,
+    format: string | NumberFormatOptions | undefined,
+    formatInfo: string[][],
+    intlService: any
+): void => {
+    newState.eventValue = intlService.parseNumber(newState.prevLooseValue, format);
+    newState.currentLooseValue = newState.prevLooseValue;
+    newState.valueIsCorrected = true;
+
+    setSelection(newState, newState.selectionStart!, newState.currentLooseValue!, formatInfo);
+};
+
+/**
+ * @hidden
+ */
+export const isMinusSymbolAdded = (newState: NumericTextBoxState, symbols: any) => {
+    const newText = String(newState.currentLooseValue);
+    const oldText = String(newState.prevLooseValue);
+
+    return (
+        newText.split(symbols.minusSign).length !== oldText.split(symbols.minusSign).length &&
+        newText.length === oldText.length + symbols.minusSign.length
+    );
+};
+
+/**
+ * @hidden
+ */
+export const isMinusSymbolRemoved = (newState: NumericTextBoxState, symbols: any) => {
+    const newText = String(newState.currentLooseValue);
+    const oldText = String(newState.prevLooseValue);
+
+    return (
+        newText.indexOf(symbols.minusSign) === -1 && oldText.indexOf(symbols.minusSign) !== -1
+    );
+};
+
+/**
+ * @hidden
+ */
+export const isDecimalDuplicated = (newState: NumericTextBoxState, symbols: any) => {
+    const newText = String(newState.currentLooseValue);
+
+    return newText.split(symbols.decimal).length > 2;
+};
+
+/**
+ * @hidden
+ */
+export const getFormatPrefixSufix = (format: string | NumberFormatOptions | undefined, intlService: any) => {
+    const positiveResult = intlService.formatNumber(DEFAULT_NUMBER, format);
+    const negativeResult = intlService.formatNumber(-DEFAULT_NUMBER, format);
+    const zeroResult = intlService.formatNumber(ZERO_NUMBER, format);
+    const oneResult = intlService.formatNumber(ONE_NUMBER, format);
+
+    const positivePrefix = getPrefix(positiveResult);
+    const negativePrefix = getPrefix(negativeResult);
+    const zeroPrefix = getPrefix(zeroResult);
+    const onePrefix = getPrefix(oneResult);
+
+    const positiveSuffix = getSuffix(positiveResult);
+    const negativeSuffix = getSuffix(negativeResult);
+    const zeroSuffix = getSuffix(zeroResult);
+    const oneSuffix = getSuffix(oneResult);
+
+    return {
+        positiveInfo: [positivePrefix, positiveSuffix],
+        negativeInfo: [negativePrefix, negativeSuffix],
+        zeroInfo: [zeroPrefix, zeroSuffix],
+        oneInfo: [onePrefix, oneSuffix]
+    };
+};
+
+/**
+ * @hidden
+ */
+export const getFormatSymbols = (format: string | NumberFormatOptions | undefined, intlService: any): string => {
+    const positiveResult = intlService.formatNumber(DEFAULT_NUMBER, format);
+    const negativeResult = intlService.formatNumber(-DEFAULT_NUMBER, format);
+    const zeroResult = intlService.formatNumber(ZERO_NUMBER, format);
+    const oneResult = intlService.formatNumber(ONE_NUMBER, format);
+
+    const symbols = intlService.numberSymbols();
+    const sanitizeRegex = new RegExp(`[\\d\\${symbols.decimal}${symbols.group}]`, 'g');
+
+    const resultWithDuplicates = [positiveResult, negativeResult, zeroResult, oneResult]
+        .map(result => result.replace(sanitizeRegex, ''))
+        .join('');
+
+    return resultWithDuplicates
+        .split('')
+        .filter((x, n, s) => s.indexOf(x) === n)
+        .join('');
+};
+
+/**
+ * @hidden
+ */
+export const getInitialPosition = (nextLooseValue: string, symbols: any) => {
+    const decimalIdex = nextLooseValue.indexOf(symbols.decimal);
+    if (decimalIdex > -1) {
+        return decimalIdex;
+    }
+
+    return getLastNumberIndex(nextLooseValue, DIGITS_REGEX);
+};
+
+/**
+ * @hidden
+ */
+export const reverseString = (str: string): string => {
+    return str.split('').reverse().join('');
+};
+
+/**
+ * @hidden
+ */
+export const getLastNumberIndex = (currentLooseValue: string, inputRegex: RegExp) => {
+    return currentLooseValue.length - reverseString(currentLooseValue).search(inputRegex);
+};
+
+/**
+ * @hidden
+ */
+export const getPrefix = (str: string): string => {
+    return str.split(str[str.search(DIGITS_REGEX)])[0];
+};
+
+/**
+ * @hidden
+ */
+export const getSuffix = (str: string): string => {
+    const reversedString = reverseString(str);
+    return reverseString(reversedString.split(reversedString[reversedString.search(DIGITS_REGEX)])[0]);
+};
+
+/**
+ * @hidden
+ */
+export const getFirstNumberIndex = (prevLooseValue: string, inputRegex: RegExp) => {
+    return prevLooseValue.search(inputRegex);
+};
+
+/**
+ * @hidden
+ */
+export const getDecimalCount = (value: string, decimal: string) => {
+    const currentDecimalPlace = value.indexOf(decimal);
+
+    return currentDecimalPlace > -1 ? value.length - currentDecimalPlace - 1 : 0;
+};
+
+/**
+ * @hidden
+ */
+export const changeBasedSelection = (
+    currentValue: string,
+    nextValue: string,
+    selectionPosition: number,
+    isDelete: boolean,
+    sanitizeRegex: any
+) => {
+    const isCurrentLeadingZero = currentValue.replace(sanitizeRegex, '')[0] === '0';
+    const isNextLeadingZero = nextValue.replace(sanitizeRegex, '')[0] === '0';
+
+    if (isCurrentLeadingZero && !isNextLeadingZero) {
+        return selectionPosition - 1;
+    }
+
+    if (isNextLeadingZero && isDelete) {
+        return selectionPosition + 1;
+    }
+
+    let numberCounter = 0;
+    for (let idx = 0; idx < selectionPosition; idx++) {
+        if (DIGITS_REGEX.test(currentValue.charAt(idx))) {
+            numberCounter++;
+        }
+    }
+
+    let newSelection = 0;
+    while (numberCounter > 0 && nextValue.length > newSelection) {
+        if (DIGITS_REGEX.test(nextValue.charAt(newSelection))) {
+            numberCounter--;
+        }
+        newSelection++;
+    }
+
+    return newSelection;
+};
+
+/**
+ * @hidden
+ */
+export const sanitizeNumber = (
+    state: NumericTextBoxState,
+    format: string | NumberFormatOptions | undefined,
+    intlService: any
+): NumericTextBoxState => {
+    const newState: NumericTextBoxState = { ...state };
+
+    const { prevLooseValue } = newState;
+    const symbols = intlService.numberSymbols();
+    const restrictedSymbols = getFormatSymbols(format, intlService);
+
+    const currentLooseValueAsString = String(newState.currentLooseValue);
+    const prevLooseValueAsString = String(prevLooseValue);
+
+    const sanitizeRegex = new RegExp(`[^\\d\\${symbols.decimal}]`, 'g');
+    const sanitizeGroupRegex = new RegExp(`[^\\d\\${symbols.decimal}\\${symbols.group}]`, 'g');
+    const allSymbolsRegex = new RegExp(`[\\d\\${symbols.decimal}\\${symbols.group}]`);
+
+    const sanitizedString = currentLooseValueAsString.replace(sanitizeRegex, '');
+
+    const numberStart = getFirstNumberIndex(currentLooseValueAsString, DIGITS_REGEX);
+    const numberEnd = numberStart === -1 ? -1 : getLastNumberIndex(currentLooseValueAsString, DIGITS_REGEX);
+    const decimalIndex = currentLooseValueAsString.indexOf(symbols.decimal);
+
+    const sanitizedFormattedString = (
+        currentLooseValueAsString.substring(0, numberStart) +
+        currentLooseValueAsString.substring(numberStart, numberEnd).replace(sanitizeGroupRegex, '') +
+        currentLooseValueAsString.substring(numberEnd, currentLooseValueAsString.length))
+        .split('')
+        .filter(s => restrictedSymbols.indexOf(s) !== -1 || s.search(allSymbolsRegex) !== -1)
+        .join('');
+
+    const formattedMax = intlService.formatNumber(MAX_DECIMAL, format).replace(sanitizeRegex, '');
+    const maxDecimalIndex = formattedMax.indexOf(symbols.decimal);
+    const maxDecimalCount = maxDecimalIndex > -1 ? formattedMax.length - maxDecimalIndex - 1 : 0;
+
+    const formattedMin = intlService.formatNumber(MIN_DECIMAL, format).replace(sanitizeRegex, '');
+    const minDecimalIndex = formattedMin.indexOf(symbols.decimal);
+    const minDecimalCount = minDecimalIndex > -1 ? formattedMin.length - minDecimalIndex - 1 : 0;
+
+    const {
+        positiveInfo, negativeInfo, zeroInfo, oneInfo
+    } = getFormatPrefixSufix(format, intlService);
+    const formatInfo: string[][] = [positiveInfo, negativeInfo, zeroInfo, oneInfo];
+    const isFormatContainPrefixSuffix = formatInfo.findIndex(info => info.findIndex(nestedInfo => Boolean(nestedInfo)) !== -1) !== 1;
+    const isDelete = currentLooseValueAsString.length > 0 && currentLooseValueAsString.length < prevLooseValueAsString.length;
+    const isPercentFormat = typeof format === 'string' &&
+                            format[0] === 'p' &&
+                            currentLooseValueAsString &&
+                            currentLooseValueAsString.indexOf(symbols.percentSign) === -1;
+
+    if (!newState.isPaste) {
+        // 1. Empty input
+        if (currentLooseValueAsString === '') {
+            newState.eventValue = null;
+            newState.currentLooseValue = '';
+
+            return newState;
+        }
+
+        // 2. Check is minus sign
+        if (newState.currentLooseValue === symbols.minusSign && intlService.formatNumber(-0, format) !== prevLooseValueAsString) {
+            newState.eventValue = -0;
+            newState.currentLooseValue = formatValue(newState.eventValue, format, intlService);
+
+            setSelection(
+                newState,
+                getInitialPosition(newState.currentLooseValue, symbols),
+                newState.currentLooseValue,
+                formatInfo
+            );
+
+            return newState;
+        }
+
+        // 3. Minus sign toggle
+        if (isMinusSymbolAdded(newState, symbols)) {
+            const nextValue = intlService.parseNumber(prevLooseValue, format);
+            newState.eventValue = -(nextValue !== null ? nextValue : 0);
+            newState.currentLooseValue = formatValue(newState.eventValue, format, intlService);
+
+            const currentNumberStart = getFirstNumberIndex(newState.currentLooseValue, DIGITS_REGEX);
+            const oldNumberStart = getFirstNumberIndex(prevLooseValueAsString, DIGITS_REGEX);
+
+            setSelection(
+                newState,
+                newState.selectionEnd! - 1 + (currentNumberStart - oldNumberStart),
+                newState.currentLooseValue,
+                formatInfo
+            );
+
+            return newState;
+        }
+
+        if (isMinusSymbolRemoved(newState, symbols)) {
+            newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+
+            setSelection(
+                newState,
+                newState.selectionStart!,
+                newState.currentLooseValue!,
+                formatInfo
+            );
+
+            return newState;
+        }
+
+        // 4. Check is decimal symbol
+        if (newState.currentLooseValue === symbols.decimal) {
+            newState.eventValue = 0;
+            const valueCandidate = formatValue(newState.eventValue, format, intlService);
+
+            if (minDecimalCount === 0 && maxDecimalCount > 0) {
+                const currentLastNumberIndex = getLastNumberIndex(valueCandidate, DIGITS_REGEX);
+                newState.currentLooseValue = valueCandidate.substring(0, currentLastNumberIndex) +
+                    symbols.decimal +
+                    valueCandidate.substring(currentLastNumberIndex);
+            } else {
+                newState.currentLooseValue = valueCandidate;
+            }
+
+            setSelection(
+                newState,
+                getInitialPosition(newState.currentLooseValue, symbols) + 1,
+                newState.currentLooseValue,
+                formatInfo
+            );
+
+            return newState;
+        }
+
+        // 5. Duplicate decimal - it's possible only as trailing
+        if (isDecimalDuplicated(newState, symbols)) {
+            setInvalid(newState, format, formatInfo, intlService);
+
+            return newState;
+        }
+
+        // 6. Percent format
+        if (isPercentFormat) {
+            newState.eventValue = intlService.parseNumber(currentLooseValueAsString, format) / 100;
+            newState.currentLooseValue = formatValue(newState.eventValue, format, intlService);
+
+            return newState;
+        }
+
+        // 7. More than 15 numeric symbols
+        const numericSymbols = String(newState.currentLooseValue).replace(/[^\d]/g, '');
+
+        if (numericSymbols.length > MAX_PRECISION) {
+            setInvalid(newState, format, formatInfo, intlService);
+
+            return newState;
+        }
+
+        // 8. Check prefix / suffix for modifications
+        if (sanitizedString !== currentLooseValueAsString &&
+            currentLooseValueAsString &&
+            isFormatContainPrefixSuffix
+        ) {
+            const formatInfoIndex = formatInfo.findIndex(([prefix, suffix]) => {
+                const prefixIndex = currentLooseValueAsString.indexOf(prefix);
+                const suffixIndex = currentLooseValueAsString.indexOf(suffix);
+
+                const prefixFound = prefixIndex === 0;
+                const suffixFound = suffixIndex === currentLooseValueAsString.length - suffix.length;
+
+                const prefixGap = prefixIndex + prefix.length !== numberStart &&
+                    numberStart !== -1 &&
+                    currentLooseValueAsString[prefixIndex + prefix.length] !== symbols.decimal;
+
+                const suffixGap = suffixIndex !== numberEnd &&
+                    numberEnd !== -1 &&
+                    currentLooseValueAsString[suffixIndex - 1] !== symbols.decimal;
+
+                if (prefix && suffix) {
+                    if (prefixGap || suffixGap) {
+                        return false;
+                    }
+
+                    return prefixFound && suffixFound;
+                }
+
+                if (prefix) {
+                    if (prefixGap) {
+                        return false;
+                    }
+
+                    return prefixFound;
+                }
+
+                if (suffix) {
+                    if (suffixGap) {
+                        return false;
+                    }
+
+                    return suffixFound;
+                }
+
+                return false;
+            });
+
+            if (formatInfoIndex === -1) {
+                setInvalid(newState, format, formatInfo, intlService);
+
+                return newState;
+            }
+        }
+
+        // 9. Value ending on decimal separator (here as decimal might be typed inside format)
+        if (sanitizedString[sanitizedString.length - 1] === symbols.decimal && maxDecimalCount > 0) {
+            newState.eventValue = intlService.parseNumber(currentLooseValueAsString, format);
+            newState.currentLooseValue = sanitizedFormattedString;
+
+            return newState;
+        }
+
+        // 10. prevent deleting decimal and group symbols
+        if (newState.currentLooseValue && prevLooseValue) {
+            const isSpecialSymbolDeleted = (restrictedSymbols + symbols.decimal + symbols.group)
+                .split('')
+                .findIndex(s => {
+                    if (currentLooseValueAsString.split('').filter(x => x === s).length <
+                        prevLooseValueAsString.split('').filter(x => x === s).length &&
+                        currentLooseValueAsString.length + 1 === prevLooseValueAsString.length) {
+
+                        if (s === symbols.decimal &&
+                            getDecimalCount(prevLooseValueAsString.replace(sanitizeRegex, ''), symbols.decimal) === 0) {
+                            return false;
+                        }
+
+                        return true;
+                    }
+
+                    return false;
+                }) > -1;
+
+            if (isSpecialSymbolDeleted) {
+                newState.eventValue = intlService.parseNumber(state.prevLooseValue, format);
+                newState.currentLooseValue = state.prevLooseValue;
+
+                return newState;
+            }
+        }
+
+        const currentDecimalCount = getDecimalCount(sanitizedString, symbols.decimal);
+        const endsOnDecimal = sanitizedString[sanitizedString.length - 1] === '0';
+
+        // 11. Deleting more decimals than allowed
+        if (isDelete && endsOnDecimal && currentDecimalCount < minDecimalCount) {
+            newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+            newState.currentLooseValue = formatValue(newState.eventValue, format, intlService);
+
+            return newState;
+        }
+
+        // 12. Ending on zero OR more decimals than allowed
+        if (currentDecimalCount > 0) {
+            const valueUntillDecimal = currentLooseValueAsString.substring(0, decimalIndex);
+
+            if (endsOnDecimal && (!valueUntillDecimal || prevLooseValueAsString.indexOf(valueUntillDecimal) !== 0)) {
+                // ending on zero but typing before decimal separator
+                newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+                const nextLooseValue = formatValue(newState.eventValue, format, intlService);
+
+                setSelection(
+                    newState,
+                    changeBasedSelection(currentLooseValueAsString, nextLooseValue, newState.selectionEnd!, isDelete, sanitizeRegex),
+                    nextLooseValue,
+                    formatInfo
+                );
+
+                newState.currentLooseValue = nextLooseValue;
+
+                return newState;
+            }
+
+            if (currentDecimalCount > maxDecimalCount) {
+                // typing more symbols than format allows
+                const looseDecimalPlace = currentLooseValueAsString.indexOf(symbols.decimal);
+
+                const result = currentLooseValueAsString.substring(0, looseDecimalPlace) +
+                    currentLooseValueAsString.substring(looseDecimalPlace, looseDecimalPlace + 1 + maxDecimalCount) +
+                    currentLooseValueAsString.substring(numberEnd, String(newState.currentLooseValue).length);
+
+                newState.eventValue = intlService.parseNumber(result, format);
+                newState.currentLooseValue = result;
+
+                setSelection(newState, newState.selectionStart!, result, formatInfo);
+
+                return newState;
+            }
+
+            if (minDecimalCount !== maxDecimalCount && currentDecimalCount <= maxDecimalCount && endsOnDecimal) {
+                // adding trailing zeroes
+                newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+                newState.currentLooseValue = sanitizedFormattedString;
+
+                return newState;
+            }
+
+            if (currentDecimalCount < minDecimalCount) {
+                // deleting more decimals than allowed
+                newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+                newState.currentLooseValue = formatValue(newState.eventValue, format, intlService);
+
+                return newState;
+            }
+        }
+    }
+
+    // X. All other values should be parsed
+    newState.eventValue = intlService.parseNumber(newState.currentLooseValue, format);
+
+    if (isPercentFormat) {
+        newState.eventValue = newState.eventValue! / 100;
+    }
+
+    if (typeof newState.eventValue === 'number') {
+        const nextLooseValue = formatValue(newState.eventValue, format, intlService);
+
+        // First digit add
+        if (currentLooseValueAsString.length === 1) {
+            setSelection(newState, getInitialPosition(nextLooseValue, symbols), nextLooseValue, formatInfo);
+        } else {
+            setSelection(
+                newState,
+                changeBasedSelection(currentLooseValueAsString, nextLooseValue, newState.selectionEnd!, isDelete, sanitizeRegex),
+                nextLooseValue,
+                formatInfo
+            );
+        }
+
+        newState.currentLooseValue = nextLooseValue;
+    } else {
+        // Case when deleting last number
+        newState.currentLooseValue = formatValue(intlService.parseNumber(sanitizedString), format, intlService);
+    }
+
+    return newState;
+};