@helpdice/ui 1.7.5 → 1.7.8

package/esm/CurrencyInput/components/CurrencyInput.js

@@ -0,0 +1,342 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["allowDecimals", "allowNegativeValue", "id", "name", "className", "customInput", "decimalsLimit", "defaultValue", "disabled", "maxLength", "value", "onValueChange", "fixedDecimalLength", "placeholder", "decimalScale", "prefix", "suffix", "intlConfig", "step", "min", "max", "disableGroupSeparators", "disableAbbreviations", "decimalSeparator", "groupSeparator", "onChange", "onFocus", "onBlur", "onKeyDown", "onKeyUp", "transformRawValue", "formatValueOnBlur", "children"];
+import React, { useState, useEffect, useRef, forwardRef, useMemo, useImperativeHandle } from 'react';
+import { isNumber, cleanValue, fixedDecimalValue, formatValue, getLocaleConfig, padTrimValue, getSuffix, repositionCursor } from './utils';
+import { useTheme } from '@helpdice/theme';
+export var InputCurrency = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var _ref$allowDecimals = _ref.allowDecimals,
+    allowDecimals = _ref$allowDecimals === void 0 ? true : _ref$allowDecimals,
+    _ref$allowNegativeVal = _ref.allowNegativeValue,
+    allowNegativeValue = _ref$allowNegativeVal === void 0 ? true : _ref$allowNegativeVal,
+    id = _ref.id,
+    name = _ref.name,
+    className = _ref.className,
+    customInput = _ref.customInput,
+    decimalsLimit = _ref.decimalsLimit,
+    defaultValue = _ref.defaultValue,
+    _ref$disabled = _ref.disabled,
+    disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+    userMaxLength = _ref.maxLength,
+    userValue = _ref.value,
+    onValueChange = _ref.onValueChange,
+    fixedDecimalLength = _ref.fixedDecimalLength,
+    placeholder = _ref.placeholder,
+    decimalScale = _ref.decimalScale,
+    prefix = _ref.prefix,
+    suffix = _ref.suffix,
+    intlConfig = _ref.intlConfig,
+    step = _ref.step,
+    min = _ref.min,
+    max = _ref.max,
+    _ref$disableGroupSepa = _ref.disableGroupSeparators,
+    disableGroupSeparators = _ref$disableGroupSepa === void 0 ? false : _ref$disableGroupSepa,
+    _ref$disableAbbreviat = _ref.disableAbbreviations,
+    disableAbbreviations = _ref$disableAbbreviat === void 0 ? false : _ref$disableAbbreviat,
+    _decimalSeparator = _ref.decimalSeparator,
+    _groupSeparator = _ref.groupSeparator,
+    onChange = _ref.onChange,
+    onFocus = _ref.onFocus,
+    onBlur = _ref.onBlur,
+    onKeyDown = _ref.onKeyDown,
+    onKeyUp = _ref.onKeyUp,
+    transformRawValue = _ref.transformRawValue,
+    _ref$formatValueOnBlu = _ref.formatValueOnBlur,
+    formatValueOnBlur = _ref$formatValueOnBlu === void 0 ? true : _ref$formatValueOnBlu,
+    children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var theme = useTheme();
+  if (_decimalSeparator && isNumber(_decimalSeparator)) {
+    throw new Error('decimalSeparator cannot be a number');
+  }
+  if (_groupSeparator && isNumber(_groupSeparator)) {
+    throw new Error('groupSeparator cannot be a number');
+  }
+  var localeConfig = useMemo(function () {
+    return getLocaleConfig(intlConfig);
+  }, [intlConfig]);
+  var decimalSeparator = _decimalSeparator || localeConfig.decimalSeparator || '';
+  var groupSeparator = _groupSeparator || localeConfig.groupSeparator || '';
+  if (decimalSeparator && groupSeparator && decimalSeparator === groupSeparator && disableGroupSeparators === false) {
+    throw new Error('decimalSeparator cannot be the same as groupSeparator');
+  }
+  var formatValueOptions = {
+    decimalSeparator: decimalSeparator,
+    groupSeparator: groupSeparator,
+    disableGroupSeparators: disableGroupSeparators,
+    intlConfig: intlConfig,
+    prefix: prefix || localeConfig.prefix,
+    suffix: suffix
+  };
+  var cleanValueOptions = {
+    decimalSeparator: decimalSeparator,
+    groupSeparator: groupSeparator,
+    allowDecimals: allowDecimals,
+    decimalsLimit: decimalsLimit || fixedDecimalLength || 2,
+    allowNegativeValue: allowNegativeValue,
+    disableAbbreviations: disableAbbreviations,
+    prefix: prefix || localeConfig.prefix,
+    transformRawValue: transformRawValue
+  };
+  var _useState = useState(function () {
+      return defaultValue != null ? formatValue(_extends({}, formatValueOptions, {
+        decimalScale: decimalScale,
+        value: String(defaultValue)
+      })) : userValue != null ? formatValue(_extends({}, formatValueOptions, {
+        decimalScale: decimalScale,
+        value: String(userValue)
+      })) : '';
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    stateValue = _useState2[0],
+    setStateValue = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    dirty = _useState4[0],
+    setDirty = _useState4[1];
+  var _useState5 = useState(0),
+    _useState6 = _slicedToArray(_useState5, 2),
+    cursor = _useState6[0],
+    setCursor = _useState6[1];
+  var _useState7 = useState(0),
+    _useState8 = _slicedToArray(_useState7, 2),
+    changeCount = _useState8[0],
+    setChangeCount = _useState8[1];
+  var _useState9 = useState(null),
+    _useState10 = _slicedToArray(_useState9, 2),
+    lastKeyStroke = _useState10[0],
+    setLastKeyStroke = _useState10[1];
+  var inputRef = useRef(null);
+  useImperativeHandle(ref, function () {
+    return inputRef.current;
+  });
+
+  /**
+   * Process change in value
+   */
+  var processChange = function processChange(value, selectionStart) {
+    setDirty(true);
+    var _repositionCursor = repositionCursor({
+        selectionStart: selectionStart,
+        value: value,
+        lastKeyStroke: lastKeyStroke,
+        stateValue: stateValue,
+        groupSeparator: groupSeparator
+      }),
+      modifiedValue = _repositionCursor.modifiedValue,
+      cursorPosition = _repositionCursor.cursorPosition;
+    var stringValue = cleanValue(_extends({
+      value: modifiedValue
+    }, cleanValueOptions));
+    if (userMaxLength && stringValue.replace(/-/g, '').length > userMaxLength) {
+      return;
+    }
+    if (stringValue === '' || stringValue === '-' || stringValue === decimalSeparator) {
+      onValueChange && onValueChange(undefined, name, {
+        "float": null,
+        formatted: '',
+        value: ''
+      });
+      setStateValue(stringValue);
+      // Always sets cursor after '-' or decimalSeparator input
+      setCursor(1);
+      return;
+    }
+    var stringValueWithoutSeparator = decimalSeparator ? stringValue.replace(decimalSeparator, '.') : stringValue;
+    var numberValue = parseFloat(stringValueWithoutSeparator);
+    var formattedValue = formatValue(_extends({
+      value: stringValue
+    }, formatValueOptions));
+    if (cursorPosition != null) {
+      // Prevent cursor jumping
+      var newCursor = cursorPosition + (formattedValue.length - value.length);
+      newCursor = newCursor <= 0 ? prefix ? prefix.length : 0 : newCursor;
+      setCursor(newCursor);
+      setChangeCount(changeCount + 1);
+    }
+    setStateValue(formattedValue);
+    if (onValueChange) {
+      var values = {
+        "float": numberValue,
+        formatted: formattedValue,
+        value: stringValue
+      };
+      onValueChange(stringValue, name, values);
+    }
+  };
+
+  /**
+   * Handle change event
+   */
+  var handleOnChange = function handleOnChange(event) {
+    var _event$target = event.target,
+      value = _event$target.value,
+      selectionStart = _event$target.selectionStart;
+    processChange(value, selectionStart);
+    onChange && onChange(event);
+  };
+
+  /**
+   * Handle focus event
+   */
+  var handleOnFocus = function handleOnFocus(event) {
+    onFocus && onFocus(event);
+    return stateValue ? stateValue.length : 0;
+  };
+
+  /**
+   * Handle blur event
+   *
+   * Format value by padding/trimming decimals if required by
+   */
+  var handleOnBlur = function handleOnBlur(event) {
+    var value = event.target.value;
+    var valueOnly = cleanValue(_extends({
+      value: value
+    }, cleanValueOptions));
+    if (valueOnly === '-' || valueOnly === decimalSeparator || !valueOnly) {
+      setStateValue('');
+      onBlur && onBlur(event);
+      return;
+    }
+    var fixedDecimals = fixedDecimalValue(valueOnly, decimalSeparator, fixedDecimalLength);
+    var newValue = padTrimValue(fixedDecimals, decimalSeparator, decimalScale !== undefined ? decimalScale : fixedDecimalLength);
+    var numberValue = parseFloat(newValue.replace(decimalSeparator, '.'));
+    var formattedValue = formatValue(_extends({}, formatValueOptions, {
+      value: newValue
+    }));
+    if (onValueChange && formatValueOnBlur) {
+      onValueChange(newValue, name, {
+        "float": numberValue,
+        formatted: formattedValue,
+        value: newValue
+      });
+    }
+    setStateValue(formattedValue);
+    onBlur && onBlur(event);
+  };
+
+  /**
+   * Handle key down event
+   *
+   * Increase or decrease value by step
+   */
+  var handleOnKeyDown = function handleOnKeyDown(event) {
+    var key = event.key;
+    setLastKeyStroke(key);
+    if (step && (key === 'ArrowUp' || key === 'ArrowDown')) {
+      event.preventDefault();
+      setCursor(stateValue.length);
+      var currentValue = parseFloat(userValue != null ? String(userValue).replace(decimalSeparator, '.') : cleanValue(_extends({
+        value: stateValue
+      }, cleanValueOptions))) || 0;
+      var newValue = key === 'ArrowUp' ? currentValue + step : currentValue - step;
+      if (min !== undefined && newValue < Number(min)) {
+        return;
+      }
+      if (max !== undefined && newValue > Number(max)) {
+        return;
+      }
+      var fixedLength = String(step).includes('.') ? Number(String(step).split('.')[1].length) : undefined;
+      processChange(String(fixedLength ? newValue.toFixed(fixedLength) : newValue).replace('.', decimalSeparator));
+    }
+    onKeyDown && onKeyDown(event);
+  };
+
+  /**
+   * Handle key up event
+   *
+   * Move cursor if there is a suffix to prevent user typing past suffix
+   */
+  var handleOnKeyUp = function handleOnKeyUp(event) {
+    var key = event.key,
+      selectionStart = event.currentTarget.selectionStart;
+    if (key !== 'ArrowUp' && key !== 'ArrowDown' && stateValue !== '-') {
+      var _suffix = getSuffix(stateValue, {
+        groupSeparator: groupSeparator,
+        decimalSeparator: decimalSeparator
+      });
+      if (_suffix && selectionStart && selectionStart > stateValue.length - _suffix.length) {
+        /* istanbul ignore else */
+        if (inputRef.current) {
+          var newCursor = stateValue.length - _suffix.length;
+          inputRef.current.setSelectionRange(newCursor, newCursor);
+        }
+      }
+    }
+    onKeyUp && onKeyUp(event);
+  };
+
+  // Update state if userValue changes to undefined
+  useEffect(function () {
+    if (userValue == null && defaultValue == null) {
+      setStateValue('');
+    }
+  }, [defaultValue, userValue]);
+  useEffect(function () {
+    // prevent cursor jumping if editing value
+    if (dirty && stateValue !== '-' && inputRef.current && document.activeElement === inputRef.current) {
+      inputRef.current.setSelectionRange(cursor, cursor);
+    }
+  }, [stateValue, cursor, inputRef, dirty, changeCount]);
+
+  /**
+   * If user has only entered "-" or decimal separator,
+   * keep the char to allow them to enter next value
+   */
+  var getRenderValue = function getRenderValue() {
+    if (userValue != null && stateValue !== '-' && (!decimalSeparator || stateValue !== decimalSeparator)) {
+      return formatValue(_extends({}, formatValueOptions, {
+        decimalScale: dirty ? undefined : decimalScale,
+        value: String(userValue)
+      }));
+    }
+    return stateValue;
+  };
+  var inputProps = _extends({
+    type: 'text',
+    inputMode: 'decimal',
+    id: id,
+    name: name,
+    className: className,
+    onChange: handleOnChange,
+    onBlur: handleOnBlur,
+    onFocus: handleOnFocus,
+    onKeyDown: handleOnKeyDown,
+    onKeyUp: handleOnKeyUp,
+    placeholder: placeholder,
+    disabled: disabled,
+    value: getRenderValue(),
+    ref: inputRef
+  }, props);
+  if (customInput) {
+    var CustomInput = customInput;
+    return /*#__PURE__*/React.createElement(CustomInput, inputProps);
+  }
+  return /*#__PURE__*/React.createElement("div", null, children && /*#__PURE__*/React.createElement("label", {
+    style: {
+      display: 'block',
+      marginBottom: '0.7rem',
+      fontSize: '14px',
+      fontWeight: 'light'
+    }
+  }, children), /*#__PURE__*/React.createElement("input", _extends({}, inputProps, {
+    style: {
+      textAlign: 'right',
+      border: "1px solid ".concat(theme.palette.border),
+      fontSize: '14px',
+      borderRadius: '5px',
+      height: '35px',
+      padding: '5px 10px',
+      fontWeight: 'light',
+      width: 'auto',
+      background: 'transparent',
+      minWidth: '200px'
+    }
+  })));
+});
+
+// CurrencyInput.displayName = 'CurrencyInput';
+
+export default InputCurrency;

package/esm/CurrencyInput/components/CurrencyInputProps.js

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

package/esm/CurrencyInput/components/utils/addSeparators.js

@@ -0,0 +1,7 @@
+/**
+ * Add group separator to value eg. 1000 > 1,000
+ */
+export var addSeparators = function addSeparators(value) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ',';
+  return value.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+};

package/esm/CurrencyInput/components/utils/cleanValue.js

@@ -0,0 +1,69 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { parseAbbrValue } from './parseAbbrValue';
+import { removeSeparators } from './removeSeparators';
+import { removeInvalidChars } from './removeInvalidChars';
+import { escapeRegExp } from './escapeRegExp';
+/**
+ * Remove prefix, separators and extra decimals from value
+ */
+export var cleanValue = function cleanValue(_ref) {
+  var value = _ref.value,
+    _ref$groupSeparator = _ref.groupSeparator,
+    groupSeparator = _ref$groupSeparator === void 0 ? ',' : _ref$groupSeparator,
+    _ref$decimalSeparator = _ref.decimalSeparator,
+    decimalSeparator = _ref$decimalSeparator === void 0 ? '.' : _ref$decimalSeparator,
+    _ref$allowDecimals = _ref.allowDecimals,
+    allowDecimals = _ref$allowDecimals === void 0 ? true : _ref$allowDecimals,
+    _ref$decimalsLimit = _ref.decimalsLimit,
+    decimalsLimit = _ref$decimalsLimit === void 0 ? 2 : _ref$decimalsLimit,
+    _ref$allowNegativeVal = _ref.allowNegativeValue,
+    allowNegativeValue = _ref$allowNegativeVal === void 0 ? true : _ref$allowNegativeVal,
+    _ref$disableAbbreviat = _ref.disableAbbreviations,
+    disableAbbreviations = _ref$disableAbbreviat === void 0 ? false : _ref$disableAbbreviat,
+    _ref$prefix = _ref.prefix,
+    prefix = _ref$prefix === void 0 ? '' : _ref$prefix,
+    _ref$transformRawValu = _ref.transformRawValue,
+    transformRawValue = _ref$transformRawValu === void 0 ? function (rawValue) {
+      return rawValue;
+    } : _ref$transformRawValu;
+  var transformedValue = transformRawValue(value);
+  if (transformedValue === '-') {
+    return transformedValue;
+  }
+  var abbreviations = disableAbbreviations ? [] : ['k', 'm', 'b'];
+  var reg = new RegExp("((^|\\D)-\\d)|(-".concat(escapeRegExp(prefix), ")"));
+  var isNegative = reg.test(transformedValue);
+
+  // Is there a digit before the prefix? eg. 1$
+  var _ref2 = RegExp("(\\d+)-?".concat(escapeRegExp(prefix))).exec(value) || [],
+    _ref3 = _slicedToArray(_ref2, 2),
+    prefixWithValue = _ref3[0],
+    preValue = _ref3[1];
+  var withoutPrefix = prefix ? prefixWithValue ? transformedValue.replace(prefixWithValue, '').concat(preValue) : transformedValue.replace(prefix, '') : transformedValue;
+  var withoutSeparators = removeSeparators(withoutPrefix, groupSeparator);
+  var withoutInvalidChars = removeInvalidChars(withoutSeparators, [groupSeparator, decimalSeparator].concat(abbreviations));
+  var valueOnly = withoutInvalidChars;
+  if (!disableAbbreviations) {
+    // disallow letter without number
+    if (abbreviations.some(function (letter) {
+      return letter === withoutInvalidChars.toLowerCase().replace(decimalSeparator, '');
+    })) {
+      return '';
+    }
+    var parsed = parseAbbrValue(withoutInvalidChars, decimalSeparator);
+    if (parsed) {
+      valueOnly = String(parsed);
+    }
+  }
+  var includeNegative = isNegative && allowNegativeValue ? '-' : '';
+  if (decimalSeparator && valueOnly.includes(decimalSeparator)) {
+    var _withoutInvalidChars$ = withoutInvalidChars.split(decimalSeparator),
+      _withoutInvalidChars$2 = _slicedToArray(_withoutInvalidChars$, 2),
+      _int = _withoutInvalidChars$2[0],
+      decimals = _withoutInvalidChars$2[1];
+    var trimmedDecimals = decimalsLimit && decimals ? decimals.slice(0, decimalsLimit) : decimals;
+    var includeDecimals = allowDecimals ? "".concat(decimalSeparator).concat(trimmedDecimals) : '';
+    return "".concat(includeNegative).concat(_int).concat(includeDecimals);
+  }
+  return "".concat(includeNegative).concat(valueOnly);
+};

package/esm/CurrencyInput/components/utils/escapeRegExp.js

@@ -0,0 +1,8 @@
+/**
+ * Escape regex char
+ *
+ * See: https://stackoverflow.com/questions/17885855/use-dynamic-variable-string-as-regex-pattern-in-javascript
+ */
+export var escapeRegExp = function escapeRegExp(stringToGoIntoTheRegex) {
+  return stringToGoIntoTheRegex.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+};

package/esm/CurrencyInput/components/utils/fixedDecimalValue.js

@@ -0,0 +1,29 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+export var fixedDecimalValue = function fixedDecimalValue(value, decimalSeparator, fixedDecimalLength) {
+  if (fixedDecimalLength !== undefined && value.length > 1) {
+    if (fixedDecimalLength === 0) {
+      return value.replace(decimalSeparator, '');
+    }
+    if (value.includes(decimalSeparator)) {
+      var _value$split = value.split(decimalSeparator),
+        _value$split2 = _slicedToArray(_value$split, 2),
+        _int = _value$split2[0],
+        decimals = _value$split2[1];
+      if (decimals.length === fixedDecimalLength) {
+        return value;
+      }
+      if (decimals.length > fixedDecimalLength) {
+        return "".concat(_int).concat(decimalSeparator).concat(decimals.slice(0, fixedDecimalLength));
+      }
+    }
+    var reg = value.length > fixedDecimalLength ? new RegExp("(\\d+)(\\d{".concat(fixedDecimalLength, "})")) : new RegExp("(\\d)(\\d+)");
+    var match = value.match(reg);
+    if (match) {
+      var _match = _slicedToArray(match, 3),
+        _int2 = _match[1],
+        _decimals = _match[2];
+      return "".concat(_int2).concat(decimalSeparator).concat(_decimals);
+    }
+  }
+  return value;
+};

package/esm/CurrencyInput/components/utils/formatValue.js

@@ -0,0 +1,124 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+/* eslint-disable @typescript-eslint/no-use-before-define */
+
+import { escapeRegExp } from './escapeRegExp';
+import { getSuffix } from './getSuffix';
+/**
+ * Format value with decimal separator, group separator and prefix
+ */
+export var formatValue = function formatValue(options) {
+  var _value = options.value,
+    decimalSeparator = options.decimalSeparator,
+    intlConfig = options.intlConfig,
+    decimalScale = options.decimalScale,
+    _options$prefix = options.prefix,
+    prefix = _options$prefix === void 0 ? '' : _options$prefix,
+    _options$suffix = options.suffix,
+    suffix = _options$suffix === void 0 ? '' : _options$suffix;
+  if (_value === '' || _value === undefined) {
+    return '';
+  }
+  if (_value === '-') {
+    return '-';
+  }
+  var isNegative = new RegExp("^\\d?-".concat(prefix ? "".concat(escapeRegExp(prefix), "?") : '', "\\d")).test(_value);
+  var value = decimalSeparator !== '.' ? replaceDecimalSeparator(_value, decimalSeparator, isNegative) : _value;
+  if (decimalSeparator && decimalSeparator !== '-' && value.startsWith(decimalSeparator)) {
+    value = '0' + value;
+  }
+  var defaultNumberFormatOptions = {
+    minimumFractionDigits: decimalScale || 0,
+    maximumFractionDigits: 20
+  };
+  var numberFormatter = intlConfig ? new Intl.NumberFormat(intlConfig.locale, intlConfig.currency ? _extends({}, defaultNumberFormatOptions, {
+    style: 'currency',
+    currency: intlConfig.currency
+  }) : defaultNumberFormatOptions) : new Intl.NumberFormat(undefined, defaultNumberFormatOptions);
+  var parts = numberFormatter.formatToParts(Number(value));
+  var formatted = replaceParts(parts, options);
+
+  // Does intl formatting add a suffix?
+  var intlSuffix = getSuffix(formatted, _extends({}, options));
+
+  // Include decimal separator if user input ends with decimal separator
+  var includeDecimalSeparator = _value.slice(-1) === decimalSeparator ? decimalSeparator : '';
+  var _ref = value.match(RegExp('\\d+\\.(\\d+)')) || [],
+    _ref2 = _slicedToArray(_ref, 2),
+    decimals = _ref2[1];
+
+  // Keep original decimal padding if no decimalScale
+  if (decimalScale === undefined && decimals && decimalSeparator) {
+    if (formatted.includes(decimalSeparator)) {
+      formatted = formatted.replace(RegExp("(\\d+)(".concat(escapeRegExp(decimalSeparator), ")(\\d+)"), 'g'), "$1$2".concat(decimals));
+    } else {
+      if (intlSuffix && !suffix) {
+        formatted = formatted.replace(intlSuffix, "".concat(decimalSeparator).concat(decimals).concat(intlSuffix));
+      } else {
+        formatted = "".concat(formatted).concat(decimalSeparator).concat(decimals);
+      }
+    }
+  }
+  if (suffix && includeDecimalSeparator) {
+    return "".concat(formatted).concat(includeDecimalSeparator).concat(suffix);
+  }
+  if (intlSuffix && includeDecimalSeparator) {
+    return formatted.replace(intlSuffix, "".concat(includeDecimalSeparator).concat(intlSuffix));
+  }
+  if (intlSuffix && suffix) {
+    return formatted.replace(intlSuffix, "".concat(includeDecimalSeparator).concat(suffix));
+  }
+  return [formatted, includeDecimalSeparator, suffix].join('');
+};
+
+/**
+ * Before converting to Number, decimal separator has to be .
+ */
+var replaceDecimalSeparator = function replaceDecimalSeparator(value, decimalSeparator, isNegative) {
+  var newValue = value;
+  if (decimalSeparator && decimalSeparator !== '.') {
+    newValue = newValue.replace(RegExp(escapeRegExp(decimalSeparator), 'g'), '.');
+    if (isNegative && decimalSeparator === '-') {
+      newValue = "-".concat(newValue.slice(1));
+    }
+  }
+  return newValue;
+};
+var replaceParts = function replaceParts(parts, _ref3) {
+  var prefix = _ref3.prefix,
+    groupSeparator = _ref3.groupSeparator,
+    decimalSeparator = _ref3.decimalSeparator,
+    decimalScale = _ref3.decimalScale,
+    _ref3$disableGroupSep = _ref3.disableGroupSeparators,
+    disableGroupSeparators = _ref3$disableGroupSep === void 0 ? false : _ref3$disableGroupSep;
+  return parts.reduce(function (prev, _ref4, i) {
+    var type = _ref4.type,
+      value = _ref4.value;
+    if (i === 0 && prefix) {
+      if (type === 'minusSign') {
+        return [value, prefix];
+      }
+      if (type === 'currency') {
+        return [].concat(_toConsumableArray(prev), [prefix]);
+      }
+      return [prefix, value];
+    }
+    if (type === 'currency') {
+      return prefix ? prev : [].concat(_toConsumableArray(prev), [value]);
+    }
+    if (type === 'group') {
+      return !disableGroupSeparators ? [].concat(_toConsumableArray(prev), [groupSeparator !== undefined ? groupSeparator : value]) : prev;
+    }
+    if (type === 'decimal') {
+      if (decimalScale !== undefined && decimalScale === 0) {
+        return prev;
+      }
+      return [].concat(_toConsumableArray(prev), [decimalSeparator !== undefined ? decimalSeparator : value]);
+    }
+    if (type === 'fraction') {
+      return [].concat(_toConsumableArray(prev), [decimalScale !== undefined ? value.slice(0, decimalScale) : value]);
+    }
+    return [].concat(_toConsumableArray(prev), [value]);
+  }, ['']).join('');
+};

package/esm/CurrencyInput/components/utils/getLocaleConfig.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+var defaultConfig = {
+  currencySymbol: '',
+  groupSeparator: '',
+  decimalSeparator: '',
+  prefix: '',
+  suffix: ''
+};
+
+/**
+ * Get locale config from input or default
+ */
+export var getLocaleConfig = function getLocaleConfig(intlConfig) {
+  var _ref = intlConfig || {},
+    locale = _ref.locale,
+    currency = _ref.currency;
+  var numberFormatter = locale ? new Intl.NumberFormat(locale, currency ? {
+    currency: currency,
+    style: 'currency'
+  } : undefined) : new Intl.NumberFormat();
+  return numberFormatter.formatToParts(1000.1).reduce(function (prev, curr, i) {
+    if (curr.type === 'currency') {
+      if (i === 0) {
+        return _extends({}, prev, {
+          currencySymbol: curr.value,
+          prefix: curr.value
+        });
+      } else {
+        return _extends({}, prev, {
+          currencySymbol: curr.value,
+          suffix: curr.value
+        });
+      }
+    }
+    if (curr.type === 'group') {
+      return _extends({}, prev, {
+        groupSeparator: curr.value
+      });
+    }
+    if (curr.type === 'decimal') {
+      return _extends({}, prev, {
+        decimalSeparator: curr.value
+      });
+    }
+    return prev;
+  }, defaultConfig);
+};

package/esm/CurrencyInput/components/utils/getSuffix.js

@@ -0,0 +1,10 @@
+import { escapeRegExp } from './escapeRegExp';
+export var getSuffix = function getSuffix(value, _ref) {
+  var _ref$groupSeparator = _ref.groupSeparator,
+    groupSeparator = _ref$groupSeparator === void 0 ? ',' : _ref$groupSeparator,
+    _ref$decimalSeparator = _ref.decimalSeparator,
+    decimalSeparator = _ref$decimalSeparator === void 0 ? '.' : _ref$decimalSeparator;
+  var suffixReg = new RegExp("\\d([^".concat(escapeRegExp(groupSeparator)).concat(escapeRegExp(decimalSeparator), "0-9]+)"));
+  var suffixMatch = value.match(suffixReg);
+  return suffixMatch ? suffixMatch[1] : undefined;
+};

package/esm/CurrencyInput/components/utils/index.js

@@ -0,0 +1,8 @@
+export * from './cleanValue';
+export * from './fixedDecimalValue';
+export * from './formatValue';
+export * from './getLocaleConfig';
+export * from './getSuffix';
+export * from './isNumber';
+export * from './padTrimValue';
+export * from './repositionCursor';

package/esm/CurrencyInput/components/utils/isNumber.js

@@ -0,0 +1,3 @@
+export var isNumber = function isNumber(input) {
+  return RegExp(/\d/, 'gi').test(input);
+};