currency-fomatter 1.0.3 → 1.0.4

package/dist/esm/components/currency/index.d.ts

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

package/dist/esm/components/currency/index.js

@@ -0,0 +1,686 @@
+import { __assign, __extends } from "tslib";
+//@flow
+import PropTypes from "prop-types";
+import React, { Component } from "react";
+import { noop, returnTrue, charIsNumber, escapeRegExp, fixLeadingZero, splitString, limitToScale, roundToPrecision, omit, setCaretPosition, thousandGroupSpacing, } from "./utils";
+var propTypes = {
+    thousandSeparator: PropTypes.oneOfType([PropTypes.string, PropTypes.oneOf([true])]),
+    thousandSpacing: PropTypes.oneOf(["2", "2s", "3", "4"]),
+    decimalSeparator: PropTypes.string,
+    decimalScale: PropTypes.number,
+    fixedDecimalScale: PropTypes.bool,
+    displayType: PropTypes.oneOf(["input", "text"]),
+    prefix: PropTypes.string,
+    suffix: PropTypes.string,
+    format: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+    removeFormatting: PropTypes.func,
+    mask: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
+    value: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+    isNumericString: PropTypes.bool,
+    customInput: PropTypes.func,
+    allowNegative: PropTypes.bool,
+    onValueChange: PropTypes.func,
+    onKeyDown: PropTypes.func,
+    onMouseUp: PropTypes.func,
+    onChange: PropTypes.func,
+    onFocus: PropTypes.func,
+    onBlur: PropTypes.func,
+    type: PropTypes.oneOf(["text", "tel"]),
+    isAllowed: PropTypes.func,
+    renderText: PropTypes.func,
+};
+var defaultProps = {
+    displayType: "input",
+    decimalSeparator: ".",
+    thousandSpacing: "3",
+    fixedDecimalScale: false,
+    prefix: "",
+    suffix: "",
+    allowNegative: true,
+    isNumericString: false,
+    type: "text",
+    onValueChange: noop,
+    onChange: noop,
+    onKeyDown: noop,
+    onMouseUp: noop,
+    onFocus: noop,
+    onBlur: noop,
+    isAllowed: returnTrue,
+};
+var CurrencyFormat = /** @class */ (function (_super) {
+    __extends(CurrencyFormat, _super);
+    function CurrencyFormat(props) {
+        var _this = _super.call(this, props) || this;
+        //validate props
+        _this.validateProps();
+        var formattedValue = _this.formatValueProp();
+        _this.state = {
+            value: formattedValue,
+            numAsString: _this.removeFormatting(formattedValue),
+        };
+        _this.onChange = _this.onChange.bind(_this);
+        _this.onKeyDown = _this.onKeyDown.bind(_this);
+        _this.onMouseUp = _this.onMouseUp.bind(_this);
+        _this.onFocus = _this.onFocus.bind(_this);
+        _this.onBlur = _this.onBlur.bind(_this);
+        return _this;
+    }
+    CurrencyFormat.prototype.componentDidUpdate = function (prevProps) {
+        this.updateValueIfRequired(prevProps);
+    };
+    CurrencyFormat.prototype.updateValueIfRequired = function (prevProps) {
+        var _a = this, props = _a.props, state = _a.state;
+        if (prevProps !== props) {
+            //validate props
+            this.validateProps();
+            var stateValue = state.value;
+            var lastNumStr = state.numAsString || "";
+            var formattedValue = props.value === undefined ? this.formatNumString(lastNumStr) : this.formatValueProp();
+            if (formattedValue !== stateValue) {
+                this.setState({
+                    value: formattedValue,
+                    numAsString: this.removeFormatting(formattedValue),
+                });
+            }
+        }
+    };
+    /** Misc methods **/
+    CurrencyFormat.prototype.getFloatString = function (num) {
+        if (num === void 0) { num = ""; }
+        var decimalSeparator = this.getSeparators().decimalSeparator;
+        var numRegex = this.getNumberRegex(true);
+        //remove negation for regex check
+        var hasNegation = num[0] === "-";
+        if (hasNegation)
+            num = num.replace("-", "");
+        num = (num.match(numRegex) || []).join("").replace(decimalSeparator, ".");
+        //remove extra decimals
+        var firstDecimalIndex = num.indexOf(".");
+        if (firstDecimalIndex !== -1) {
+            num = "".concat(num.substring(0, firstDecimalIndex), ".").concat(num
+                .substring(firstDecimalIndex + 1, num.length)
+                .replace(new RegExp(escapeRegExp(decimalSeparator), "g"), ""));
+        }
+        //add negation back
+        if (hasNegation)
+            num = "-" + num;
+        return num;
+    };
+    //returned regex assumes decimalSeparator is as per prop
+    CurrencyFormat.prototype.getNumberRegex = function (g, ignoreDecimalSeparator) {
+        var _a = this.props, format = _a.format, decimalScale = _a.decimalScale;
+        var decimalSeparator = this.getSeparators().decimalSeparator;
+        return new RegExp("\\d" +
+            (decimalSeparator && decimalScale !== 0 && !ignoreDecimalSeparator && !format
+                ? "|" + escapeRegExp(decimalSeparator)
+                : ""), g ? "g" : undefined);
+    };
+    CurrencyFormat.prototype.getSeparators = function () {
+        var _a = this.props, decimalSeparator = _a.decimalSeparator, thousandSpacing = _a.thousandSpacing;
+        var thousandSeparator = this.props.thousandSeparator;
+        if (thousandSeparator === true) {
+            thousandSeparator = ",";
+        }
+        return {
+            decimalSeparator: decimalSeparator,
+            thousandSeparator: thousandSeparator,
+            thousandSpacing: thousandSpacing,
+        };
+    };
+    CurrencyFormat.prototype.getMaskAtIndex = function (index) {
+        var _a = this.props.mask, mask = _a === void 0 ? " " : _a;
+        if (typeof mask === "string") {
+            return mask;
+        }
+        return mask[index] || " ";
+    };
+    CurrencyFormat.prototype.validateProps = function () {
+        var mask = this.props.mask;
+        //validate decimalSeparator and thousandSeparator
+        var _a = this.getSeparators(), decimalSeparator = _a.decimalSeparator, thousandSeparator = _a.thousandSeparator;
+        if (decimalSeparator === thousandSeparator) {
+            throw new Error("\n          Decimal separator can't be same as thousand separator.\n\n          thousandSeparator: ".concat(thousandSeparator, " (thousandSeparator = {true} is same as thousandSeparator = \",\")\n          decimalSeparator: ").concat(decimalSeparator, " (default value for decimalSeparator is .)\n       "));
+        }
+        //validate mask
+        if (mask) {
+            var maskAsStr = mask === "string" ? mask : mask.toString();
+            if (maskAsStr.match(/\d/g)) {
+                throw new Error("\n          Mask ".concat(mask, " should not contain numeric character;\n        "));
+            }
+        }
+    };
+    CurrencyFormat.prototype.splitDecimal = function (numStr) {
+        var allowNegative = this.props.allowNegative;
+        var hasNagation = numStr[0] === "-";
+        var addNegation = hasNagation && allowNegative;
+        numStr = numStr.replace("-", "");
+        var parts = numStr.split(".");
+        var beforeDecimal = parts[0];
+        var afterDecimal = parts[1] || "";
+        return {
+            beforeDecimal: beforeDecimal,
+            afterDecimal: afterDecimal,
+            hasNagation: hasNagation,
+            addNegation: addNegation,
+        };
+    };
+    /** Misc methods end **/
+    /** caret specific methods **/
+    CurrencyFormat.prototype.setPatchedCaretPosition = function (el, caretPos, currentValue) {
+        /* setting caret position within timeout of 0ms is required for mobile chrome,
+    otherwise browser resets the caret position after we set it
+    We are also setting it without timeout so that in normal browser we don't see the flickering */
+        setCaretPosition(el, caretPos);
+        setTimeout(function () {
+            if (el.value === currentValue)
+                setCaretPosition(el, caretPos);
+        }, 0);
+    };
+    /* This keeps the caret within typing area so people can't type in between prefix or suffix */
+    CurrencyFormat.prototype.correctCaretPosition = function (value, caretPos, direction) {
+        var _a = this.props, prefix = _a.prefix, suffix = _a.suffix, format = _a.format;
+        //in case of format as number limit between prefix and suffix
+        if (!format) {
+            var hasNegation = value[0] === "-";
+            return Math.min(Math.max(caretPos, prefix.length + (hasNegation ? 1 : 0)), value.length - suffix.length);
+        }
+        //in case if custom format method don't do anything
+        if (typeof format === "function")
+            return caretPos;
+        /* in case format is string find the closest # position from the caret position */
+        //in case the caretPos have input value on it don't do anything
+        if (format[caretPos] === "#" && charIsNumber(value[caretPos]))
+            return caretPos;
+        //if caretPos is just after input value don't do anything
+        if (format[caretPos - 1] === "#" && charIsNumber(value[caretPos - 1]))
+            return caretPos;
+        //find the nearest caret position
+        var firstHashPosition = format.indexOf("#");
+        var lastHashPosition = format.lastIndexOf("#");
+        //limit the cursor between the first # position and the last # position
+        caretPos = Math.min(Math.max(caretPos, firstHashPosition), lastHashPosition + 1);
+        var nextPos = format.substring(caretPos, format.length).indexOf("#");
+        var caretLeftBound = caretPos;
+        var caretRightBoud = caretPos + (nextPos === -1 ? 0 : nextPos);
+        //get the position where the last number is present
+        while (caretLeftBound > firstHashPosition &&
+            (format[caretLeftBound] !== "#" || !charIsNumber(value[caretLeftBound]))) {
+            caretLeftBound -= 1;
+        }
+        var goToLeft = !charIsNumber(value[caretRightBoud]) ||
+            (direction === "left" && caretPos !== firstHashPosition) ||
+            caretPos - caretLeftBound < caretRightBoud - caretPos;
+        return goToLeft ? caretLeftBound + 1 : caretRightBoud;
+    };
+    CurrencyFormat.prototype.getCaretPosition = function (inputValue, formattedValue, caretPos) {
+        var format = this.props.format;
+        var stateValue = this.state.value;
+        var numRegex = this.getNumberRegex(true);
+        var inputNumber = (inputValue.match(numRegex) || []).join("");
+        var formattedNumber = (formattedValue.match(numRegex) || []).join("");
+        var j, i;
+        j = 0;
+        for (i = 0; i < caretPos; i++) {
+            var currentInputChar = inputValue[i] || "";
+            var currentFormatChar = formattedValue[j] || "";
+            //no need to increase new cursor position if formatted value does not have those characters
+            //case inputValue = 1a23 and formattedValue =  123
+            if (!currentInputChar.match(numRegex) && currentInputChar !== currentFormatChar)
+                continue;
+            //When we are striping out leading zeros maintain the new cursor position
+            //Case inputValue = 00023 and formattedValue = 23;
+            if (currentInputChar === "0" &&
+                currentFormatChar.match(numRegex) &&
+                currentFormatChar !== "0" &&
+                inputNumber.length !== formattedNumber.length)
+                continue;
+            //we are not using currentFormatChar because j can change here
+            while (currentInputChar !== formattedValue[j] && j < formattedValue.length)
+                j++;
+            j++;
+        }
+        if (typeof format === "string" && !stateValue) {
+            //set it to the maximum value so it goes after the last number
+            j = formattedValue.length;
+        }
+        //correct caret position if its outside of editable area
+        j = this.correctCaretPosition(formattedValue, j);
+        return j;
+    };
+    /** caret specific methods ends **/
+    /** methods to remove formattting **/
+    CurrencyFormat.prototype.removePrefixAndSuffix = function (val) {
+        var _a = this.props, format = _a.format, prefix = _a.prefix, suffix = _a.suffix;
+        //remove prefix and suffix
+        if (!format && val) {
+            var isNegative = val[0] === "-";
+            //remove negation sign
+            if (isNegative)
+                val = val.substring(1, val.length);
+            //remove prefix
+            val = prefix && val.indexOf(prefix) === 0 ? val.substring(prefix.length, val.length) : val;
+            //remove suffix
+            var suffixLastIndex = val.lastIndexOf(suffix);
+            val =
+                suffix && suffixLastIndex !== -1 && suffixLastIndex === val.length - suffix.length
+                    ? val.substring(0, suffixLastIndex)
+                    : val;
+            //add negation sign back
+            if (isNegative)
+                val = "-" + val;
+        }
+        return val;
+    };
+    CurrencyFormat.prototype.removePatternFormatting = function (val) {
+        var format = this.props.format;
+        var formatArray = format.split("#").filter(function (str) { return str !== ""; });
+        var start = 0;
+        var numStr = "";
+        for (var i = 0, ln = formatArray.length; i <= ln; i++) {
+            var part = formatArray[i] || "";
+            //if i is the last fragment take the index of end of the value
+            //For case like +1 (911) 911 91 91 having pattern +1 (###) ### ## ##
+            var index = i === ln ? val.length : val.indexOf(part, start);
+            /* in any case if we don't find the pattern part in the value assume the val as numeric string
+      This will be also in case if user has started typing, in any other case it will not be -1
+      unless wrong prop value is provided */
+            if (index === -1) {
+                numStr = val;
+                break;
+            }
+            else {
+                numStr += val.substring(start, index);
+                start = index + part.length;
+            }
+        }
+        return (numStr.match(/\d/g) || []).join("");
+    };
+    CurrencyFormat.prototype.removeFormatting = function (val) {
+        var _a = this.props, format = _a.format, removeFormatting = _a.removeFormatting;
+        if (!val)
+            return val;
+        if (!format) {
+            val = this.removePrefixAndSuffix(val);
+            val = this.getFloatString(val);
+        }
+        else if (typeof format === "string") {
+            val = this.removePatternFormatting(val);
+        }
+        else if (typeof removeFormatting === "function") {
+            //condition need to be handled if format method is provide,
+            val = removeFormatting(val);
+        }
+        else {
+            val = (val.match(/\d/g) || []).join("");
+        }
+        return val;
+    };
+    /** methods to remove formattting end **/
+    /*** format specific methods start ***/
+    /**
+     * Format when # based string is provided
+     * @param  {string} numStr Numeric String
+     * @return {string}        formatted Value
+     */
+    CurrencyFormat.prototype.formatWithPattern = function (numStr) {
+        var format = this.props.format;
+        var hashCount = 0;
+        var formattedNumberAry = format.split("");
+        for (var i = 0, ln = format.length; i < ln; i++) {
+            if (format[i] === "#") {
+                formattedNumberAry[i] = numStr[hashCount] || this.getMaskAtIndex(hashCount);
+                hashCount += 1;
+            }
+        }
+        return formattedNumberAry.join("");
+    };
+    /**
+     * Format the given string according to thousand separator and thousand spacing
+     * @param {*} beforeDecimal
+     * @param {*} thousandSeparator
+     * @param {*} thousandSpacing
+     */
+    CurrencyFormat.prototype.formatThousand = function (beforeDecimal, thousandSeparator, thousandSpacing) {
+        var digitalGroup;
+        switch (thousandSpacing) {
+            case thousandGroupSpacing.two:
+                digitalGroup = /(\d)(?=(\d{2})+(?!\d))/g;
+                break;
+            case thousandGroupSpacing.twoScaled:
+                digitalGroup = /(\d)(?=(((\d{2})+)(\d{1})(?!\d)))/g;
+                break;
+            case thousandGroupSpacing.four:
+                digitalGroup = /(\d)(?=(\d{4})+(?!\d))/g;
+                break;
+            default:
+                digitalGroup = /(\d)(?=(\d{3})+(?!\d))/g;
+        }
+        return beforeDecimal.replace(digitalGroup, "$1" + thousandSeparator);
+    };
+    /**
+     * @param  {string} numStr Numeric string/floatString] It always have decimalSeparator as .
+     * @return {string} formatted Value
+     */
+    CurrencyFormat.prototype.formatAsNumber = function (numStr) {
+        var _a = this.props, decimalScale = _a.decimalScale, fixedDecimalScale = _a.fixedDecimalScale, prefix = _a.prefix, suffix = _a.suffix;
+        var _b = this.getSeparators(), thousandSeparator = _b.thousandSeparator, decimalSeparator = _b.decimalSeparator, thousandSpacing = _b.thousandSpacing;
+        var hasDecimalSeparator = numStr.indexOf(".") !== -1 || (decimalScale && fixedDecimalScale);
+        var _c = this.splitDecimal(numStr), beforeDecimal = _c.beforeDecimal, afterDecimal = _c.afterDecimal, addNegation = _c.addNegation; // eslint-disable-line prefer-const
+        //apply decimal precision if its defined
+        if (decimalScale !== undefined)
+            afterDecimal = limitToScale(afterDecimal, decimalScale, fixedDecimalScale);
+        if (thousandSeparator) {
+            beforeDecimal = this.formatThousand(beforeDecimal, thousandSeparator, thousandSpacing);
+        }
+        //add prefix and suffix
+        if (prefix)
+            beforeDecimal = prefix + beforeDecimal;
+        if (suffix)
+            afterDecimal = afterDecimal + suffix;
+        //restore negation sign
+        if (addNegation)
+            beforeDecimal = "-" + beforeDecimal;
+        numStr = beforeDecimal + ((hasDecimalSeparator && decimalSeparator) || "") + afterDecimal;
+        return numStr;
+    };
+    CurrencyFormat.prototype.formatNumString = function (value) {
+        if (value === void 0) { value = ""; }
+        var format = this.props.format;
+        var formattedValue = value;
+        if (value === "") {
+            formattedValue = "";
+        }
+        else if (value === "-" && !format) {
+            formattedValue = "-";
+            value = "";
+        }
+        else if (typeof format === "string") {
+            formattedValue = this.formatWithPattern(formattedValue);
+        }
+        else if (typeof format === "function") {
+            formattedValue = format(formattedValue);
+        }
+        else {
+            formattedValue = this.formatAsNumber(formattedValue);
+        }
+        return formattedValue;
+    };
+    CurrencyFormat.prototype.formatValueProp = function () {
+        var _a = this.props, format = _a.format, decimalScale = _a.decimalScale, fixedDecimalScale = _a.fixedDecimalScale;
+        var _b = this.props, value = _b.value, isNumericString = _b.isNumericString;
+        // if value is not defined return empty string
+        if (value === undefined)
+            return "";
+        if (typeof value === "number") {
+            value = value.toString();
+            isNumericString = true;
+        }
+        //round the number based on decimalScale
+        //format only if non formatted value is provided
+        if (isNumericString && !format && typeof decimalScale === "number") {
+            value = roundToPrecision(value, decimalScale, fixedDecimalScale);
+        }
+        var formattedValue = isNumericString ? this.formatNumString(value) : this.formatInput(value);
+        return formattedValue;
+    };
+    CurrencyFormat.prototype.formatNegation = function (value) {
+        if (value === void 0) { value = ""; }
+        var allowNegative = this.props.allowNegative;
+        var negationRegex = new RegExp("(-)");
+        var doubleNegationRegex = new RegExp("(-)(.)*(-)");
+        // Check number has '-' value
+        var hasNegation = negationRegex.test(value);
+        // Check number has 2 or more '-' values
+        var removeNegation = doubleNegationRegex.test(value);
+        //remove negation
+        value = value.replace(/-/g, "");
+        if (hasNegation && !removeNegation && allowNegative) {
+            value = "-" + value;
+        }
+        return value;
+    };
+    CurrencyFormat.prototype.formatInput = function (value) {
+        if (value === void 0) { value = ""; }
+        var format = this.props.format;
+        //format negation only if we are formatting as number
+        if (!format) {
+            value = this.formatNegation(value);
+        }
+        //remove formatting from number
+        value = this.removeFormatting(value);
+        return this.formatNumString(value);
+    };
+    /*** format specific methods end ***/
+    CurrencyFormat.prototype.isCharacterAFormat = function (caretPos, value) {
+        var _a = this.props, format = _a.format, prefix = _a.prefix, suffix = _a.suffix, decimalScale = _a.decimalScale, fixedDecimalScale = _a.fixedDecimalScale;
+        var decimalSeparator = this.getSeparators().decimalSeparator;
+        //check within format pattern
+        if (typeof format === "string" && format[caretPos] !== "#")
+            return true;
+        //check in number format
+        if (!format &&
+            (caretPos < prefix.length ||
+                caretPos >= value.length - suffix.length ||
+                (decimalScale && fixedDecimalScale && value[caretPos] === decimalSeparator))) {
+            return true;
+        }
+        return false;
+    };
+    CurrencyFormat.prototype.checkIfFormatGotDeleted = function (start, end, value) {
+        for (var i = start; i < end; i++) {
+            if (this.isCharacterAFormat(i, value))
+                return true;
+        }
+        return false;
+    };
+    /**
+     * This will check if any formatting got removed by the delete or backspace and reset the value
+     * It will also work as fallback if android chome keyDown handler does not work
+     **/
+    CurrencyFormat.prototype.correctInputValue = function (caretPos, lastValue, value) {
+        var format = this.props.format;
+        var lastNumStr = this.state.numAsString || "";
+        //don't do anyhting if something got added, or if value is empty string (when whole input is cleared)
+        if (value.length >= lastValue.length || !value.length) {
+            return value;
+        }
+        var start = caretPos;
+        var lastValueParts = splitString(lastValue, caretPos);
+        var newValueParts = splitString(value, caretPos);
+        var deletedIndex = lastValueParts[1].lastIndexOf(newValueParts[1]);
+        var diff = deletedIndex !== -1 ? lastValueParts[1].substring(0, deletedIndex) : "";
+        var end = start + diff.length;
+        //if format got deleted reset the value to last value
+        if (this.checkIfFormatGotDeleted(start, end, lastValue)) {
+            value = lastValue;
+        }
+        //for numbers check if beforeDecimal got deleted and there is nothing after decimal,
+        //clear all numbers in such case while keeping the - sign
+        if (!format) {
+            var numericString = this.removeFormatting(value);
+            var _a = this.splitDecimal(numericString), beforeDecimal = _a.beforeDecimal, afterDecimal = _a.afterDecimal, addNegation = _a.addNegation; // eslint-disable-line prefer-const
+            //clear only if something got deleted
+            if (numericString.length < lastNumStr.length && beforeDecimal === "" && !parseFloat(afterDecimal)) {
+                return addNegation ? "-" : "";
+            }
+        }
+        return value;
+    };
+    CurrencyFormat.prototype.onChange = function (e) {
+        e.persist();
+        var el = e.target;
+        var inputValue = el.value;
+        var _a = this, state = _a.state, props = _a.props;
+        var isAllowed = props.isAllowed;
+        var lastValue = state.value || "";
+        /*Max of selectionStart and selectionEnd is taken for the patch of pixel and other mobile device caret bug*/
+        var currentCaretPosition = Math.max(el.selectionStart, el.selectionEnd);
+        inputValue = this.correctInputValue(currentCaretPosition, lastValue, inputValue);
+        var formattedValue = this.formatInput(inputValue) || "";
+        var numAsString = this.removeFormatting(formattedValue);
+        var valueObj = {
+            formattedValue: formattedValue,
+            value: numAsString,
+            floatValue: parseFloat(numAsString),
+        };
+        if (!isAllowed(valueObj)) {
+            formattedValue = lastValue;
+        }
+        //set the value imperatively, this is required for IE fix
+        el.value = formattedValue;
+        //get the caret position
+        var caretPos = this.getCaretPosition(inputValue, formattedValue, currentCaretPosition);
+        //set caret position
+        this.setPatchedCaretPosition(el, caretPos, formattedValue);
+        //change the state
+        if (formattedValue !== lastValue) {
+            this.setState({ value: formattedValue, numAsString: numAsString }, function () {
+                props.onValueChange(valueObj);
+                props.onChange(e);
+            });
+        }
+        else {
+            props.onChange(e);
+        }
+    };
+    CurrencyFormat.prototype.onBlur = function (e) {
+        var _a = this, props = _a.props, state = _a.state;
+        var format = props.format, onBlur = props.onBlur;
+        var numAsString = state.numAsString;
+        var lastValue = state.value;
+        if (!format) {
+            numAsString = fixLeadingZero(numAsString);
+            var formattedValue = this.formatNumString(numAsString);
+            var valueObj_1 = {
+                formattedValue: formattedValue,
+                value: numAsString,
+                floatValue: parseFloat(numAsString),
+            };
+            //change the state
+            if (formattedValue !== lastValue) {
+                // the event needs to be persisted because its properties can be accessed in an asynchronous way
+                e.persist();
+                this.setState({ value: formattedValue, numAsString: numAsString }, function () {
+                    props.onValueChange(valueObj_1);
+                    onBlur(e);
+                });
+                return;
+            }
+        }
+        onBlur(e);
+    };
+    CurrencyFormat.prototype.onKeyDown = function (e) {
+        var el = e.target;
+        var key = e.key;
+        var selectionEnd = el.selectionEnd, value = el.value;
+        var selectionStart = el.selectionStart;
+        var expectedCaretPosition;
+        var _a = this.props, decimalScale = _a.decimalScale, fixedDecimalScale = _a.fixedDecimalScale, prefix = _a.prefix, suffix = _a.suffix, format = _a.format, onKeyDown = _a.onKeyDown;
+        var ignoreDecimalSeparator = decimalScale !== undefined && fixedDecimalScale;
+        var numRegex = this.getNumberRegex(false, ignoreDecimalSeparator);
+        var negativeRegex = new RegExp("-");
+        var isPatternFormat = typeof format === "string";
+        //Handle backspace and delete against non numerical/decimal characters or arrow keys
+        if (key === "ArrowLeft" || key === "Backspace") {
+            expectedCaretPosition = selectionStart - 1;
+        }
+        else if (key === "ArrowRight") {
+            expectedCaretPosition = selectionStart + 1;
+        }
+        else if (key === "Delete") {
+            expectedCaretPosition = selectionStart;
+        }
+        //if expectedCaretPosition is not set it means we don't want to Handle keyDown
+        //also if multiple characters are selected don't handle
+        if (expectedCaretPosition === undefined || selectionStart !== selectionEnd) {
+            onKeyDown(e);
+            return;
+        }
+        var newCaretPosition = expectedCaretPosition;
+        var leftBound = isPatternFormat ? format.indexOf("#") : prefix.length;
+        var rightBound = isPatternFormat ? format.lastIndexOf("#") + 1 : value.length - suffix.length;
+        if (key === "ArrowLeft" || key === "ArrowRight") {
+            var direction = key === "ArrowLeft" ? "left" : "right";
+            newCaretPosition = this.correctCaretPosition(value, expectedCaretPosition, direction);
+        }
+        else if (key === "Delete" &&
+            !numRegex.test(value[expectedCaretPosition]) &&
+            !negativeRegex.test(value[expectedCaretPosition])) {
+            while (!numRegex.test(value[newCaretPosition]) && newCaretPosition < rightBound)
+                newCaretPosition++;
+        }
+        else if (key === "Backspace" &&
+            !numRegex.test(value[expectedCaretPosition]) &&
+            !negativeRegex.test(value[expectedCaretPosition])) {
+            while (!numRegex.test(value[newCaretPosition - 1]) && newCaretPosition > leftBound) {
+                newCaretPosition--;
+            }
+            newCaretPosition = this.correctCaretPosition(value, newCaretPosition, "left");
+        }
+        if (newCaretPosition !== expectedCaretPosition ||
+            expectedCaretPosition < leftBound ||
+            expectedCaretPosition > rightBound) {
+            e.preventDefault();
+            this.setPatchedCaretPosition(el, newCaretPosition, value);
+        }
+        /* NOTE: this is just required for unit test as we need to get the newCaretPosition,
+            Remove this when you find different solution */
+        if (e.isUnitTestRun) {
+            this.setPatchedCaretPosition(el, newCaretPosition, value);
+        }
+        this.props.onKeyDown(e);
+    };
+    /** required to handle the caret position when click anywhere within the input **/
+    CurrencyFormat.prototype.onMouseUp = function (e) {
+        var el = e.target;
+        var selectionStart = el.selectionStart, selectionEnd = el.selectionEnd, value = el.value;
+        if (selectionStart === selectionEnd) {
+            var caretPostion = this.correctCaretPosition(value, selectionStart);
+            if (caretPostion !== selectionStart) {
+                this.setPatchedCaretPosition(el, caretPostion, value);
+            }
+        }
+        this.props.onMouseUp(e);
+    };
+    CurrencyFormat.prototype.onFocus = function (e) {
+        var _this = this;
+        // Workaround Chrome and Safari bug https://bugs.chromium.org/p/chromium/issues/detail?id=779328
+        // (onFocus event target selectionStart is always 0 before setTimeout)
+        e.persist();
+        setTimeout(function () {
+            var el = e.target;
+            var selectionStart = el.selectionStart, value = el.value;
+            var caretPosition = _this.correctCaretPosition(value, selectionStart);
+            if (caretPosition !== selectionStart) {
+                _this.setPatchedCaretPosition(el, caretPosition, value);
+            }
+            _this.props.onFocus(e);
+        });
+    };
+    CurrencyFormat.prototype.render = function () {
+        var _a = this.props, type = _a.type, displayType = _a.displayType, customInput = _a.customInput, renderText = _a.renderText;
+        var value = this.state.value;
+        var otherProps = omit(this.props, propTypes);
+        var inputProps = Object.assign({}, otherProps, {
+            type: type,
+            value: value,
+            onChange: this.onChange,
+            onKeyDown: this.onKeyDown,
+            onMouseUp: this.onMouseUp,
+            onFocus: this.onFocus,
+            onBlur: this.onBlur,
+        });
+        if (displayType === "text") {
+            return renderText ? renderText(value) || null : React.createElement("span", __assign({}, otherProps), value);
+        }
+        else if (customInput) {
+            var CustomInput = customInput;
+            return React.createElement(CustomInput, __assign({}, inputProps));
+        }
+        return React.createElement("input", __assign({}, inputProps));
+    };
+    return CurrencyFormat;
+}(Component));
+CurrencyFormat.defaultProps = defaultProps;
+module.exports = CurrencyFormat;
+//# sourceMappingURL=index.js.map