intelicoreact 0.1.33 → 0.1.36

package/dist/Atomic/FormElements/InputMask/InputMask.js

@@ -0,0 +1,615 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = InputMask;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _reactFeather = require("react-feather");
+
+var _index = require("../../../Constants/index.constants");
+
+var _usePrevious = _interopRequireDefault(require("../../../Functions/useFormTools/functions/usePrevious"));
+
+var _InputCarretPosition = require("./InputCarretPosition");
+
+require("./InputMask.scss");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var UPPERCASE_LETTER_MASK_CHAR = 'L';
+var LOWERCASE_LETTER_MASK_CHAR = 'l';
+var DIGIT_MASK_CHAR = 'D';
+var EXCLUDED_KEYS = ["Tab"];
+var DEFAULT_ERRORS = {
+  onlyLetter: 'Type letter',
+  onlyDigit: 'Type digit',
+  onlyUpperCase: 'Type letter in UpperCase',
+  onlyLowerCase: 'Type letter in LowerCase',
+  default: null
+};
+
+function InputMask(_ref) {
+  var maskPattern = _ref.maskPattern,
+      maskPatternPlaceholder = _ref.maskPatternPlaceholder,
+      maskPlaceholder = _ref.maskPlaceholder,
+      maskDigitPlaceholder = _ref.maskDigitPlaceholder,
+      maskLetterPlaceholder = _ref.maskLetterPlaceholder,
+      usePatternPlaceholder = _ref.usePatternPlaceholder,
+      _ref$isFocusedDefault = _ref.isFocusedDefault,
+      isFocusedDefault = _ref$isFocusedDefault === void 0 ? false : _ref$isFocusedDefault,
+      isClearable = _ref.isClearable,
+      isCaseSensitive = _ref.isCaseSensitive,
+      adaptTextCase = _ref.adaptTextCase,
+      icon = _ref.icon,
+      showIcon = _ref.showIcon,
+      isIconLeft = _ref.isIconLeft,
+      isIconRight = _ref.isIconRight,
+      value = _ref.value,
+      _ref$onChange = _ref.onChange,
+      onChangeProp = _ref$onChange === void 0 ? function () {} : _ref$onChange,
+      _ref$blinkErrors = _ref.blinkErrors,
+      blinkErrors = _ref$blinkErrors === void 0 ? true : _ref$blinkErrors,
+      _ref$blinkDuration = _ref.blinkDuration,
+      blinkDuration = _ref$blinkDuration === void 0 ? 100 : _ref$blinkDuration,
+      _ref$showNativeErrors = _ref.showNativeErrors,
+      showNativeErrors = _ref$showNativeErrors === void 0 ? true : _ref$showNativeErrors,
+      _ref$className = _ref.className,
+      className = _ref$className === void 0 ? '' : _ref$className,
+      _ref$errors = _ref.errors,
+      customErrors = _ref$errors === void 0 ? DEFAULT_ERRORS : _ref$errors,
+      ref = _ref.ref,
+      _ref$onFocus = _ref.onFocus,
+      onFocusProp = _ref$onFocus === void 0 ? function () {} : _ref$onFocus,
+      _ref$onBlur = _ref.onBlur,
+      onBlurProp = _ref$onBlur === void 0 ? function () {} : _ref$onBlur;
+
+  var errors = _objectSpread(_objectSpread({}, DEFAULT_ERRORS), customErrors);
+
+  var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      isMaskRendered = _useState2[0],
+      setMaskRendered = _useState2[1];
+
+  var inputRef = (0, _react.useRef)(null);
+  var inputRefWrapper = (0, _react.useRef)(null);
+  var wrapperRef = (0, _react.useRef)(null);
+
+  var _useState3 = (0, _react.useState)(false),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      isFocused = _useState4[0],
+      setFocused = _useState4[1];
+
+  var _useState5 = (0, _react.useState)(false),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      isError = _useState6[0],
+      setError = _useState6[1];
+
+  var _useState7 = (0, _react.useState)(false),
+      _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+      blinkError = _useState8[0],
+      setBlinkError = _useState8[1];
+
+  var _useState9 = (0, _react.useState)(errors.default),
+      _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
+      errorMessage = _useState10[0],
+      setErrorMessage = _useState10[1];
+
+  var clearErrorMessage = function clearErrorMessage() {
+    return setErrorMessage(errors.default);
+  };
+
+  var _useState11 = (0, _react.useState)(null),
+      _useState12 = (0, _slicedToArray2.default)(_useState11, 2),
+      focusedItemRef = _useState12[0],
+      setFocusedItemRef = _useState12[1];
+
+  var _useState13 = (0, _react.useState)([]),
+      _useState14 = (0, _slicedToArray2.default)(_useState13, 2),
+      innerValue = _useState14[0],
+      setInnerValue = _useState14[1];
+
+  var addInnerValueChar = function addInnerValueChar(_ref2) {
+    var char = _ref2.char,
+        _ref2$i = _ref2.i,
+        i = _ref2$i === void 0 ? null : _ref2$i,
+        _ref2$data = _ref2.data,
+        data = _ref2$data === void 0 ? {} : _ref2$data;
+    setInnerValue(function (state) {
+      var stateCopy = (0, _toConsumableArray2.default)(state);
+      var charObj = getCharObj(char, data);
+
+      if (i !== null) {
+        stateCopy[i] = charObj;
+      } else {
+        stateCopy.push(charObj);
+      }
+
+      return stateCopy;
+    });
+  };
+
+  var updateInnerValueChar = function updateInnerValueChar(char, i) {
+    setInnerValue(function (state) {
+      var stateCopy = (0, _toConsumableArray2.default)(state);
+      if (!stateCopy[i].isSpecialSymbol) stateCopy[i].char = char;
+      return stateCopy;
+    });
+  };
+
+  var getPlaceholderCharByIndex = function getPlaceholderCharByIndex(i) {
+    var _getCharByIndex = getCharByIndex(i),
+        maskChar = _getCharByIndex.maskChar;
+
+    if (usePatternPlaceholder) {
+      return maskPatternPlaceholder[i] || maskPlaceholder;
+    } else {
+      if (isDigitMaskChar(maskChar) && maskDigitPlaceholder) return maskDigitPlaceholder;
+      if (isLetterMaskChar(maskChar) && maskLetterPlaceholder) return maskLetterPlaceholder;
+      return maskPlaceholder;
+    }
+  };
+
+  var getInnerValueAsString = function getInnerValueAsString() {
+    return innerValue.map(function (_ref3, i) {
+      var char = _ref3.char,
+          maskChar = _ref3.maskChar;
+      return char === '' ? getPlaceholderCharByIndex(i) || maskChar : char;
+    }).join('');
+  };
+
+  var getClearInnerValueAsString = function getClearInnerValueAsString() {
+    return innerValue.reduce(function (result, _ref4) {
+      var char = _ref4.char,
+          maskChar = _ref4.maskChar,
+          isSpecialSymbol = _ref4.isSpecialSymbol;
+      if (char !== maskChar && char !== '' || isSpecialSymbol) result += char;
+      return result;
+    }, '');
+  };
+
+  var isLetter = function isLetter(char) {
+    return char.length === 1 && char.match(/[a-z]/i);
+  };
+
+  var isUpperCaseLetter = function isUpperCaseLetter(char) {
+    return isLetter(char) ? char === char.slice().toUpperCase() : false;
+  };
+
+  var isLowerCaseLetter = function isLowerCaseLetter(char) {
+    return isLetter(char) ? char === char.slice().toLowerCase() : false;
+  };
+
+  var isDigit = function isDigit(char) {
+    return Number.isInteger(parseInt(char));
+  };
+
+  var isDigitMaskChar = function isDigitMaskChar(char) {
+    return char === DIGIT_MASK_CHAR;
+  };
+
+  var isLetterMaskChar = function isLetterMaskChar(char) {
+    return char === UPPERCASE_LETTER_MASK_CHAR || char === LOWERCASE_LETTER_MASK_CHAR;
+  };
+
+  var getCharObj = function getCharObj(char) {
+    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var isSpecialSymbol = !(isDigitMaskChar(char) || isLetterMaskChar(char));
+    if (char === ' ') char = "\xA0";
+    return _objectSpread({
+      char: isSpecialSymbol ? char : '',
+      maskChar: char,
+      isSpecialSymbol: isSpecialSymbol,
+      ref: /*#__PURE__*/(0, _react.createRef)()
+    }, data);
+  };
+
+  var getFirstChar = function getFirstChar() {
+    return innerValue[0] ? _objectSpread({}, innerValue[0]) : undefined;
+  };
+
+  var getLastChar = function getLastChar() {
+    return innerValue.length ? (0, _toConsumableArray2.default)(innerValue).pop() : undefined;
+  };
+
+  var getCharByIndex = function getCharByIndex(i) {
+    return innerValue[i] ? _objectSpread({}, innerValue[i]) : undefined;
+  };
+
+  var getMaskCharByIndex = function getMaskCharByIndex(i) {
+    return maskPattern[i] || undefined;
+  };
+
+  var setFocusOnChar = function setFocusOnChar(i, prevIndex) {
+    var charObj = getCharByIndex(i);
+    if (!charObj) return false;
+    var char = charObj.char,
+        maskChar = charObj.maskChar,
+        ref = charObj.ref,
+        isSpecialSymbol = charObj.isSpecialSymbol;
+    if (!ref) return false;
+
+    if (isSpecialSymbol && i < innerValue.length - 1) {
+      return prevIndex > i ? onArrowLeftDown(null, i) : onArrowRightDown(null, i);
+    }
+
+    ref.current.focus();
+    setTimeout(function () {
+      return (0, _InputCarretPosition.setCaretPosition)(ref.current, 0);
+    }, 10);
+    setFocusedItemRef(ref);
+
+    _onFocus(null, i);
+
+    return true;
+  };
+
+  var clearValue = function clearValue(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    innerValue.map(function (charObj, i) {
+      updateInnerValueChar('', i);
+    });
+    onHomeDown(null, 0);
+  }; ///--- Event Handlers ---///
+
+
+  var onArrowLeftDown = function onArrowLeftDown(e, i) {
+    return setFocusOnChar(i - 1, i);
+  };
+
+  var onArrowRightDown = function onArrowRightDown(e, i) {
+    return setFocusOnChar(i + 1, i);
+  };
+
+  var onBackspaceDown = function onBackspaceDown(e, i) {
+    var prevIndex = i - 1;
+    var charObj = getCharByIndex(prevIndex);
+    if (!charObj) return false;
+    var char = charObj.char,
+        isSpecialSymbol = charObj.isSpecialSymbol;
+    if (isSpecialSymbol) return onBackspaceDown(e, prevIndex);
+    setFocusOnChar(prevIndex, i);
+    updateInnerValueChar('', prevIndex);
+    return true;
+  };
+
+  var onDeleteDown = function onDeleteDown(e, i) {
+    var nextIndex = i + 1;
+    var charObj = getCharByIndex(i);
+    if (!charObj) return false;
+    var char = charObj.char,
+        isSpecialSymbol = charObj.isSpecialSymbol;
+    if (isSpecialSymbol) return onDeleteDown(e, i + 1);
+    setFocusOnChar(nextIndex, i);
+    updateInnerValueChar('', i);
+    return true;
+  };
+
+  var onHomeDown = function onHomeDown(e, i) {
+    return setFocusOnChar(0, -1);
+  };
+
+  var onEndDown = function onEndDown(e, i) {
+    return setFocusOnChar(innerValue.length - 1, 0);
+  };
+
+  var handleServiceKeyDown = function handleServiceKeyDown(e, i) {
+    var key = e.key;
+
+    switch (key) {
+      case 'ArrowLeft':
+        return onArrowLeftDown(e, i);
+        break;
+
+      case 'ArrowRight':
+        return onArrowRightDown(e, i);
+        break;
+
+      case 'Backspace':
+        return onBackspaceDown(e, i);
+        break;
+
+      case 'Delete':
+        return onDeleteDown(e, i);
+        break;
+
+      case 'Home':
+        return onHomeDown(e, i);
+        break;
+
+      case 'End':
+        return onEndDown(e, i);
+        break;
+
+      case 'Tab':
+        return onTabDown(e, i);
+        break;
+
+      default:
+        return true;
+        break;
+    }
+  };
+
+  var handleKeyDown = function handleKeyDown(e, i) {
+    e.stopPropagation();
+    e.preventDefault();
+    var key = e.key;
+    var charObj = getCharByIndex(i);
+    if (!charObj) return false;
+    var isSpecialSymbol = charObj.isSpecialSymbol,
+        maskChar = charObj.maskChar; //IF DEFAULT CHAR IS SPACE, SWITCH TO NEXT INPUT
+
+    if (maskChar === ' ') return handleKeyDown(e, i + 1);
+    if (isSpecialSymbol && maskChar !== key) return false;
+
+    switch (maskChar) {
+      case DIGIT_MASK_CHAR:
+        if (!isDigit(key)) {
+          setErrorMessage(errors.onlyDigit);
+          return false;
+        }
+
+        break;
+
+      case UPPERCASE_LETTER_MASK_CHAR:
+        if (adaptTextCase) key = key.toUpperCase();
+
+        if (!isLetter(key) && !isCaseSensitive) {
+          setErrorMessage(errors.onlyLetter);
+          return false;
+        }
+
+        if (isCaseSensitive && !isUpperCaseLetter(key)) {
+          setErrorMessage(errors.onlyUpperCase);
+          return false;
+        }
+
+        break;
+
+      case LOWERCASE_LETTER_MASK_CHAR:
+        if (adaptTextCase) key = key.toLowerCase();
+
+        if (!isLetter(key) && !isCaseSensitive) {
+          setErrorMessage(errors.onlyLetter);
+          return false;
+        }
+
+        if (isCaseSensitive && !isLowerCaseLetter(key)) {
+          setErrorMessage(errors.onlyLowerCase);
+          return false;
+        }
+
+        break;
+
+      default:
+        return false;
+        break;
+    }
+
+    updateInnerValueChar(key, i);
+    onArrowRightDown(e, i);
+    return true;
+  };
+
+  var _onKeyDown = function onKeyDown(e, i) {
+    var key = e.key;
+    var handleResult = _index.KEYBOARD_SERVICE_KEYS.includes(key) ? handleServiceKeyDown(e, i) : handleKeyDown(e, i);
+
+    if (blinkErrors && !handleResult) {
+      setBlinkError(true);
+    }
+  };
+
+  var _onClick = function onClick(e, cb) {
+    e.stopPropagation();
+    setFocused(true);
+    if (typeof cb === 'function') cb(e);
+  };
+
+  var onBlur = function onBlur(e) {
+    if (isFocused) onBlurProp();
+    setFocused(false);
+  };
+
+  var _onFocus = function onFocus(e, i) {
+    var charObj = getCharByIndex(i);
+    if (!charObj) return false;
+    var isSpecialSymbol = charObj.isSpecialSymbol,
+        ref = charObj.ref;
+    (0, _InputCarretPosition.setCaretPosition)(ref.current, 0);
+
+    if (isSpecialSymbol && i < innerValue.length - 1) {
+      _onFocus(e, i + 1);
+
+      return false;
+    }
+
+    if (!isFocused) onFocusProp(e);
+    setFocused(true);
+  };
+
+  var cancelDefaultAction = function cancelDefaultAction(e, cb) {
+    var key = e.key;
+
+    if (!EXCLUDED_KEYS.includes(key) && _index.KEYBOARD_SERVICE_KEYS.includes(key)) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+
+    if (typeof cb === 'function') cb(e);
+    return false;
+  }; ///--- OBSERVERS ---///
+  //Init InnerValue
+
+
+  (0, _react.useEffect)(function () {
+    if (!maskPattern) maskPattern = '';
+    var maskLength = maskPattern.length;
+    maskPattern.concat(' ').split('').map(function (char) {
+      return addInnerValueChar({
+        char: char
+      });
+    });
+
+    if (value !== '' && value.length === maskLength) {
+      value.split('').map(function (char, i) {
+        return updateInnerValueChar(char, i);
+      });
+    }
+
+    setMaskRendered(true);
+  }, []); // Focus Observer
+
+  (0, _react.useEffect)(function () {
+    if (!isFocused) setFocusedItemRef(null);
+  }, [isFocused]); // Default Focused
+
+  (0, _react.useEffect)(function () {
+    if (isFocusedDefault && isMaskRendered) {
+      setFocusOnChar(0, -1);
+    }
+  }, [isFocusedDefault, isMaskRendered]); // OnChange Observer
+
+  (0, _react.useEffect)(function () {
+    if (!isMaskRendered) return false;
+    clearErrorMessage();
+    onChangeProp(getInnerValueAsString(), getClearInnerValueAsString());
+  }, [innerValue, isMaskRendered]); // Blink Error
+
+  (0, _react.useEffect)(function () {
+    if (!blinkError) return false;
+    setTimeout(function () {
+      setBlinkError(false);
+    }, blinkDuration);
+  }, [blinkError]); ///--- RENDER ---///
+
+  var renderChar = function renderChar(obj, i) {
+    var className = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var char = obj.char,
+        ref = obj.ref,
+        maskChar = obj.maskChar,
+        isSpecialSymbol = obj.isSpecialSymbol;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      tabIndex: i === 0 ? 1 : -1,
+      key: i,
+      maxLength: 1,
+      "attr-char-id": i,
+      className: "input-mask_value_item ".concat(className, " ").concat(isDigitMaskChar(obj.maskChar) ? 'input-mask_value_item--digit' : '', " ").concat(isLetterMaskChar(obj.maskChar) ? 'input-mask_value_item--letter' : '', " ").concat(obj.isSpecialSymbol ? 'input-mask_value_item--spec' : ''),
+      onClick: function onClick(e) {
+        _onClick(e, function () {
+          return _onFocus(e, i);
+        });
+      },
+      onFocus: function onFocus(e) {
+        return _onFocus(e, i);
+      },
+      onBlur: onBlur,
+      onKeyPress: cancelDefaultAction,
+      onKeyDown: function onKeyDown(e) {
+        return _onKeyDown(e, i);
+      },
+      onChange: function onChange() {},
+      contentEditable: true,
+      inputMode: isDigitMaskChar(maskChar) ? 'numeric' : 'text',
+      suppressContentEditableWarning: true,
+      unselectable: true,
+      onSelect: cancelDefaultAction,
+      onMouseDown: cancelDefaultAction,
+      onPaste: cancelDefaultAction // TODO IF NEEDED
+      ,
+      ref: ref
+    }, isSpecialSymbol ? maskChar : char === '' ? getPlaceholderCharByIndex(i) : char);
+  };
+
+  var renderMaskChar = function renderMaskChar(obj, i) {
+    return renderChar(obj, i, 'input-mask_value_item_mask-char');
+  };
+
+  var renderValueChar = function renderValueChar(obj, i) {
+    return renderChar(obj, i, 'input-mask_value_item_value-char');
+  };
+
+  var renderSpecialChar = function renderSpecialChar(obj, i) {
+    return renderChar(obj, i, 'input-mask_value_item_spec-char');
+  };
+
+  var renderInputValue = function renderInputValue() {
+    return innerValue.map(function (obj, i) {
+      var char = obj.char,
+          maskChar = obj.maskChar,
+          isSpecialSymbol = obj.isSpecialSymbol;
+
+      if (isSpecialSymbol) {
+        return renderSpecialChar(obj, i);
+      }
+
+      var isMaskItem = function () {
+        return char === '';
+      }();
+
+      return isMaskItem ? renderMaskChar(obj, i) : renderValueChar(obj, i);
+    });
+  };
+
+  var renderSingleInputValue = function renderSingleInputValue() {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      onClick: function onClick() {
+        return setFocused(true);
+      }
+    }, getInnerValueAsString());
+  };
+
+  var render = function render() {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_wrapper ".concat(className),
+      onBlur: onBlur,
+      ref: wrapperRef
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask ".concat(isFocused ? 'input-mask_focus' : '', " ").concat(isError ? 'input-mask_error' : '', " ").concat(blinkError ? 'input-mask_blink-error' : ''),
+      ref: inputRefWrapper,
+      onClick: function onClick(e) {
+        return _onClick(e, onEndDown(e, 0));
+      },
+      onBlur: onBlur
+    }, isIconLeft && showIcon && /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_icon input-mask_icon--left"
+    }, icon), /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_value",
+      ref: inputRef,
+      onKeyUp: cancelDefaultAction,
+      onKeyDown: cancelDefaultAction,
+      onKeyPress: cancelDefaultAction,
+      onBlur: onBlur
+    }, renderInputValue()), isClearable && /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_clear"
+    }, /*#__PURE__*/_react.default.createElement(_reactFeather.X, {
+      onClick: clearValue
+    })), isIconRight && showIcon && /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_icon input-mask_icon--right"
+    }, icon)), showNativeErrors && errorMessage && /*#__PURE__*/_react.default.createElement("div", {
+      className: "input-mask_error-text"
+    }, errorMessage));
+  };
+
+  return render();
+}