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

package/src/numerictextbox/utils/index.tsx

@@ -1,744 +0,0 @@
-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;
-};