Method _wheelAndUpDownActions

src/AutoNumeric.js:7571–7638

* Helper function that DRY the similar behaviors of the mousewheel and up/down arrow keys, which increment/decrement the element value, either by a fixed value, or using the 'progressive' heuristic * * @param {WheelEvent|KeyboardEvent} e The `wheel` or keyboard event * @param {boolean

(e, isUp, isDown, step)

     * @private
     */
    _wheelAndUpDownActions(e, isUp, isDown, step) {
        // 0) First, save the caret position so we can set it back once the value has been changed
        const selectionStart = e.target.selectionStart || 0;
        const selectionEnd = e.target.selectionEnd || 0;

        // 1) Get the unformatted value
        const currentUnformattedValue = this.rawValue;

        let result;
        if (AutoNumericHelper.isUndefinedOrNullOrEmpty(currentUnformattedValue)) {
            // If by default the input is empty, start at '0'
            if (this.settings.minimumValue > 0 || this.settings.maximumValue < 0) {
                // or if '0' is not between min and max value, 'minimumValue' if the user does a wheelup, 'maximumValue' if the user does a wheeldown
                if (isUp) {
                    result = this.settings.minimumValue;
                } else {
                    result = this.settings.maximumValue;
                }
            } else {
                result = 0;
            }
        } else {
            result = currentUnformattedValue;
        }

        result = +result; // Typecast to a number needed for the following addition/subtraction

        // 2) Increment/Decrement the value
        // But first, choose the increment/decrement method ; fixed or progressive
        if (AutoNumericHelper.isNumber(step)) {
            const stepToUse = +step; // Typecast to a number needed for the following addition/subtraction
            // Fixed method
            // This is the simplest method, where a fixed offset in added/subtracted from the current value
            if (isUp) { // Increment
                result += stepToUse;
            } else if (isDown) { // Decrement
                result -= stepToUse;
            }
        } else {
            // Progressive method
            // For this method, we calculate an offset that is in relation to the size of the current number (using only the integer part size).
            // The bigger the number, the bigger the offset (usually the number count in the integer part minus 3, except for small numbers where a different behavior is better for the user experience).
            //TODO Known limitation : The progressive method does not play well with numbers between 0 and 1 where to modify the decimal places the rawValue first has to go from '1' to '0'
            if (isUp) { // Increment
                result = AutoNumericHelper.addAndRoundToNearestAuto(result, this.settings.decimalPlacesRawValue);
            } else if (isDown) { // Decrement
                result = AutoNumericHelper.subtractAndRoundToNearestAuto(result, this.settings.decimalPlacesRawValue);
            }
        }

        // 3) Set the new value so it gets formatted
        // First clamp the result if needed
        result = AutoNumericHelper.clampToRangeLimits(result, this.settings);
        if (result !== +currentUnformattedValue) {
            // Only 'set' the value if it has changed. For instance 'set' should not happen if the user hits a limit and continue to try to go past it since we clamp the value.
            this.set(result);

            // Since we changed the input value, we send a native `input` event