@i-novus/n2o-components 1.0.0

package/lib/inputs/Input.js

@@ -0,0 +1,200 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Input = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _isObject = _interopRequireDefault(require("lodash/isObject"));
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _omit = _interopRequireDefault(require("lodash/omit"));
+
+var _isString = _interopRequireDefault(require("lodash/isString"));
+
+var _excluded = ["autoFocus", "className", "disabled", "id", "inputRef", "label", "name", "onBlur", "onClick", "onFocus", "onPaste", "placeholder", "readonly", "style", "type", "value"];
+
+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; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var Input = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(Input, _React$Component);
+
+  var _super = _createSuper(Input);
+
+  function Input(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, Input);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "handleKeyDown", function (evt) {
+      var onKeyDown = _this.props.onKeyDown;
+
+      if (onKeyDown) {
+        onKeyDown(evt);
+      }
+
+      if (evt.target.tagName === 'INPUT' && evt.target.type === 'checkbox' && evt.key === 'Enter') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _this.handleChange(evt);
+      }
+    });
+    _this.input = null;
+    _this.handleChange = _this.handleChange.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.setRef = _this.setRef.bind((0, _assertThisInitialized2["default"])(_this));
+    return _this;
+  }
+
+  (0, _createClass2["default"])(Input, [{
+    key: "focus",
+    value: function focus() {
+      var _this$input;
+
+      (_this$input = this.input) === null || _this$input === void 0 ? void 0 : _this$input.focus();
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      var _this$input2;
+
+      (_this$input2 = this.input) === null || _this$input2 === void 0 ? void 0 : _this$input2.blur();
+    }
+  }, {
+    key: "handleChange",
+    value: function handleChange(e) {
+      var props = this.props,
+          input = this.input;
+
+      if (props.disabled) {
+        return;
+      }
+
+      var value = (0, _isObject["default"])(props.value) || (0, _isArray["default"])(props.value) ? props.value : e.target.value;
+
+      if (props.onChange) {
+        props.onChange({
+          target: _objectSpread(_objectSpread({}, props), {}, {
+            value: value
+          }),
+          stopPropagation: function stopPropagation() {
+            e.stopPropagation();
+          },
+          preventDefault: function preventDefault() {
+            e.preventDefault();
+          },
+          getElement: function getElement() {
+            return input;
+          },
+          getNormalizeValue: function getNormalizeValue() {
+            return (0, _defineProperty2["default"])({}, props.name, props.value);
+          },
+          nativeEvent: e
+        });
+      }
+    }
+  }, {
+    key: "setRef",
+    value: function setRef(node) {
+      this.input = node;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          autoFocus = _this$props.autoFocus,
+          className = _this$props.className,
+          disabled = _this$props.disabled,
+          id = _this$props.id,
+          inputRef = _this$props.inputRef,
+          label = _this$props.label,
+          name = _this$props.name,
+          onBlur = _this$props.onBlur,
+          onClick = _this$props.onClick,
+          onFocus = _this$props.onFocus,
+          onPaste = _this$props.onPaste,
+          placeholder = _this$props.placeholder,
+          readonly = _this$props.readonly,
+          style = _this$props.style,
+          type = _this$props.type,
+          value = _this$props.value,
+          restProps = (0, _objectWithoutProperties2["default"])(_this$props, _excluded);
+      return /*#__PURE__*/_react["default"].createElement("input", (0, _extends2["default"])({
+        ref: inputRef,
+        className: (0, _classnames["default"])('n2o-input', className),
+        style: style,
+        id: id,
+        name: name,
+        type: type,
+        disabled: disabled
+        /* eslint-disable-next-line jsx-a11y/no-autofocus */
+        ,
+        autoFocus: autoFocus,
+        value: value,
+        onPaste: onPaste // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ,
+        onFocus: onFocus // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ,
+        onBlur: onBlur,
+        onClick: onClick,
+        onKeyDown: this.handleKeyDown,
+        placeholder: placeholder,
+        readOnly: readonly
+      }, (0, _omit["default"])(restProps, ['length', 'onChange', 'onKeyDown']), {
+        onChange: this.handleChange,
+        title: (0, _isString["default"])(value) ? value : label
+      }));
+    }
+  }]);
+  return Input;
+}(_react["default"].Component);
+
+exports.Input = Input;
+(0, _defineProperty2["default"])(Input, "defaultProps", {
+  id: '',
+  value: null,
+  name: '',
+  disabled: false,
+  autoFocus: false,
+  checked: false,
+  className: '',
+  tabIndex: 0,
+  style: {},
+  type: 'text',
+  onFocus: function onFocus() {},
+  onBlur: function onBlur() {},
+  onChange: function onChange() {},
+  onPaste: function onPaste() {},
+  onClick: function onClick() {},
+  onKeyDown: function onKeyDown() {}
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/inputs/Input.tsx"],"names":["Input","props","evt","onKeyDown","target","tagName","type","key","handleChange","input","bind","setRef","focus","blur","e","disabled","value","onChange","stopPropagation","preventDefault","getElement","getNormalizeValue","name","nativeEvent","node","autoFocus","className","id","inputRef","label","onBlur","onClick","onFocus","onPaste","placeholder","readonly","style","restProps","handleKeyDown","React","Component","checked","tabIndex"],"mappings":"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","sourcesContent":["import React, { ChangeEvent, KeyboardEvent, LegacyRef } from 'react'\nimport classNames from 'classnames'\nimport isObject from 'lodash/isObject'\nimport isArray from 'lodash/isArray'\nimport omit from 'lodash/omit'\nimport isString from 'lodash/isString'\n\nimport { TBaseInputProps, TBaseProps } from '../types'\n\n/**\n * Контрол Input\n * @reactProps {boolean} length - максимальная длина значения\n * @reactProps {string} value - значение поля\n * @reactProps {string} placeholder - плэйсхолдер\n * @reactProps {boolean} disabled - флаг неактивности поля\n * @reactProps {boolean} disabled - флаг только для чтения\n * @reactProps {boolean} autoFocus - автофокус\n * @reactProps {function} onFocus - callback на фокус\n * @reactProps {function} onClick - callback на клик\n * @reactProps {function} onPaste - callback при вставке в инпут\n * @reactProps {function} onBlur - callback при блюре инпута\n * @reactProps {function} onChange - callback при изменение инпута\n * @reactProps {function} onKeyDown - callback при нажатии на кнопку клавиатуры\n * @reactProps {boolean} autoFocus - флаг автофокуса\n * @reactProps {string} className - css-класс\n * @reactProps {object} style - объект стилей\n * @reactProps {boolean} disabled - флаг неактивности поля\n * @reactProps {string} type - тип поля\n */\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Props = TBaseProps & TBaseInputProps<any> & {\n    autoFocus: boolean,\n    checked: boolean,\n    inputRef?: LegacyRef<HTMLInputElement>,\n    label?: string,\n    length?: string,\n    max?: number,\n    min?: number,\n    name: string,\n    onClick(): void,\n    onKeyDown(arg: KeyboardEvent): void,\n    onPaste(): void,\n    placeholder?: string,\n    step?: string | number,\n    tabIndex: number,\n    type: string\n}\n\nexport class Input extends React.Component<Props> {\n    input: HTMLInputElement | null\n\n    constructor(props: Props) {\n        super(props)\n        this.input = null\n        this.handleChange = this.handleChange.bind(this)\n        this.setRef = this.setRef.bind(this)\n    }\n\n    focus() {\n        this.input?.focus()\n    }\n\n    blur() {\n        this.input?.blur()\n    }\n\n    handleChange(e: ChangeEvent<HTMLInputElement>) {\n        const { props, input } = this\n\n        if (props.disabled) {\n            return\n        }\n        const value = isObject(props.value) || isArray(props.value)\n            ? props.value\n            : (e.target as HTMLInputElement).value\n\n        if (props.onChange) {\n            props.onChange({\n                target: {\n                    ...props,\n                    value,\n                },\n                stopPropagation() {\n                    e.stopPropagation()\n                },\n                preventDefault() {\n                    e.preventDefault()\n                },\n                getElement() {\n                    return input\n                },\n                getNormalizeValue() {\n                    return { [props.name]: props.value }\n                },\n                nativeEvent: e,\n            })\n        }\n    }\n\n    setRef(node: HTMLInputElement) {\n        this.input = node\n    }\n\n    handleKeyDown = (evt: KeyboardEvent<HTMLInputElement>) => {\n        const { onKeyDown } = this.props\n\n        if (onKeyDown) {\n            onKeyDown(evt)\n        }\n\n        if ((evt.target as HTMLInputElement).tagName === 'INPUT' && (evt.target as HTMLInputElement).type === 'checkbox' && evt.key === 'Enter') {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            this.handleChange(evt as any)\n        }\n    }\n\n    render() {\n        const {\n            autoFocus,\n            className,\n            disabled,\n            id,\n            inputRef,\n            label,\n            name,\n            onBlur,\n            onClick,\n            onFocus,\n            onPaste,\n            placeholder,\n            readonly,\n            style,\n            type,\n            value,\n            ...restProps\n        } = this.props\n\n        return (\n            <input\n                ref={inputRef}\n                className={classNames('n2o-input', className)}\n                style={style}\n                id={id}\n                name={name}\n                type={type}\n                disabled={disabled}\n                /* eslint-disable-next-line jsx-a11y/no-autofocus */\n                autoFocus={autoFocus}\n                value={value}\n                onPaste={onPaste}\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                onFocus={onFocus as any}\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                onBlur={onBlur as any}\n                onClick={onClick}\n                onKeyDown={this.handleKeyDown}\n                placeholder={placeholder}\n                readOnly={readonly}\n                {...omit(restProps, ['length', 'onChange', 'onKeyDown'])}\n                onChange={this.handleChange}\n                title={isString(value) ? value : label}\n            />\n        )\n    }\n\n    static defaultProps = {\n        id: '',\n        value: null,\n        name: '',\n        disabled: false,\n        autoFocus: false,\n        checked: false,\n        className: '',\n        tabIndex: 0,\n        style: {},\n        type: 'text',\n        onFocus: () => {},\n        onBlur: () => {},\n        onChange: () => {},\n        onPaste: () => {},\n        onClick: () => {},\n        onKeyDown: () => {},\n    } as Props\n}\n"]}

package/lib/inputs/InputMask/InputMask.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { TBaseInputProps, TBaseProps } from '../../types';
+export declare type PresetType = 'phone' | 'post-code' | 'date' | 'money' | 'percentage' | 'card';
+declare type MaskType = string | Array<string | RegExp> | ((val?: unknown) => Array<string | RegExp>);
+export declare const InputMask: {
+    ({ measure, ...props }: TBaseProps & Omit<TBaseInputProps<string>, "onBlur"> & {
+        clearOnBlur?: boolean | undefined;
+        dictionary?: Record<string, RegExp> | undefined;
+        guide?: boolean | undefined;
+        keepCharPositions?: boolean | undefined;
+        mask?: MaskType | undefined;
+        onBlur?(value: string): void;
+        onChange?(value: string): void;
+        placeholder?: string | undefined;
+        placeholderChar?: string | undefined;
+        preset?: PresetType | undefined;
+        presetConfig?: Record<string, unknown> | undefined;
+    } & {
+        measure?: string | undefined;
+    }): JSX.Element;
+    displayName: string;
+};
+export {};

package/lib/inputs/InputMask/InputMask.js

@@ -0,0 +1,310 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InputMask = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactTextMask = _interopRequireDefault(require("react-text-mask"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _createNumberMask = _interopRequireDefault(require("text-mask-addons/dist/createNumberMask"));
+
+var _lodash = require("lodash");
+
+var _withRightPlaceholder = require("../../helpers/withRightPlaceholder");
+
+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; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var InputMaskComponent = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(InputMaskComponent, _React$Component);
+
+  var _super = _createSuper(InputMaskComponent);
+
+  function InputMaskComponent(props) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, InputMaskComponent);
+    _this = _super.call(this, props);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mask", function () {
+      var mask = _this.props.mask;
+
+      if ((0, _lodash.isArray)(mask)) {
+        return mask;
+      }
+
+      if ((0, _lodash.isFunction)(mask)) {
+        return mask();
+      }
+
+      return _this.mapToArray(mask);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "preset", function (preset) {
+      var _this$props$presetCon = _this.props.presetConfig,
+          presetConfig = _this$props$presetCon === void 0 ? {} : _this$props$presetCon;
+
+      switch (preset) {
+        case 'phone':
+          return _this.mapToArray('+9 (999)-999-99-99');
+
+        case 'post-code':
+          return _this.mapToArray('999999');
+
+        case 'date':
+          return _this.mapToArray('99.99.9999');
+
+        case 'money':
+          return (0, _createNumberMask["default"])(presetConfig);
+
+        case 'percentage':
+          return (0, _createNumberMask["default"])({
+            prefix: '',
+            suffix: '%'
+          });
+
+        case 'card':
+          return _this.mapToArray('9999 9999 9999 9999');
+
+        default:
+          return undefined;
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "indexOfFirstPlaceHolder", function () {
+      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var placeholderChar = _this.props.placeholderChar;
+
+      if (!placeholderChar) {
+        return null;
+      }
+
+      return value.toString().indexOf(placeholderChar);
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "indexOfLastPlaceholder", function (mask) {
+      if (typeof mask === 'function') {
+        return mask().map(function (item) {
+          return item instanceof RegExp;
+        }).lastIndexOf(true);
+      }
+
+      if (typeof mask === 'string') {
+        return Math.max.apply(Math, (0, _toConsumableArray2["default"])(Object.keys(_this.dict).map(function (_char) {
+          return mask.lastIndexOf(_char);
+        })));
+      }
+
+      if ((0, _lodash.isArray)(mask)) {
+        return mask.map(function (item) {
+          return item instanceof RegExp;
+        }).lastIndexOf(true);
+      }
+
+      return -1;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "isValid", function (value) {
+      var _this$props = _this.props,
+          preset = _this$props.preset,
+          mask = _this$props.mask,
+          _this$props$guide = _this$props.guide,
+          guide = _this$props$guide === void 0 ? true : _this$props$guide;
+
+      if (guide) {
+        return value && _this.indexOfFirstPlaceHolder(value) === -1;
+      }
+
+      if (preset) {
+        return value.length > _this.indexOfLastPlaceholder(_this.preset(preset) || mask);
+      }
+
+      return false;
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "mapToArray", function () {
+      var mask = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return mask.split('').map(function (_char2) {
+        return _this.dict[_char2] ? _this.dict[_char2] : _char2;
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onChange", function (e) {
+      var _ref = e.target,
+          value = _ref.value;
+      var _this$props2 = _this.props,
+          _this$props2$guide = _this$props2.guide,
+          guide = _this$props2$guide === void 0 ? true : _this$props2$guide,
+          _this$props2$onChange = _this$props2.onChange,
+          onChange = _this$props2$onChange === void 0 ? function () {} : _this$props2$onChange;
+      _this.valid = _this.isValid(value);
+
+      _this.setState({
+        value: value,
+        guide: guide
+      }, function () {
+        if (_this.valid || value === '') {
+          onChange(value);
+        }
+      });
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onBlur", function (e) {
+      var _ref2 = e.nativeEvent.target,
+          value = _ref2.value;
+      var _this$props3 = _this.props,
+          _this$props3$onBlur = _this$props3.onBlur,
+          onBlur = _this$props3$onBlur === void 0 ? function () {} : _this$props3$onBlur,
+          clearOnBlur = _this$props3.clearOnBlur,
+          _this$props3$onChange = _this$props3.onChange,
+          onChange = _this$props3$onChange === void 0 ? function () {} : _this$props3$onChange;
+      _this.valid = _this.isValid(value);
+      onBlur(value);
+
+      if (!_this.valid) {
+        var newValue = clearOnBlur ? '' : value;
+
+        _this.setState({
+          value: newValue,
+          guide: false
+        }, function () {
+          return newValue === '' && onChange(newValue);
+        });
+      }
+    });
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onFocus", function () {
+      var _this$props$guide2 = _this.props.guide,
+          guide = _this$props$guide2 === void 0 ? true : _this$props$guide2;
+      var value = _this.state.value;
+      _this.valid = _this.isValid(value);
+
+      if (!_this.valid) {
+        _this.setState({
+          guide: guide
+        });
+      }
+    });
+    _this.state = {
+      value: props.value || '',
+      guide: false
+    };
+    _this.valid = false;
+    _this.dict = _objectSpread({
+      9: /\d/,
+      S: /[A-Za-z]/,
+      Б: /[А-я]/
+    }, props.dictionary);
+    return _this;
+  }
+  /**
+   * преобразует маску-функцию, маску-строку в массив-маску (с regexp вместо символов) при помощи _mapToArray
+   */
+
+
+  (0, _createClass2["default"])(InputMaskComponent, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var valueFromState = this.state.value;
+      var _this$props4 = this.props,
+          _this$props4$value = _this$props4.value,
+          valueFromProps = _this$props4$value === void 0 ? '' : _this$props4$value,
+          _this$props4$dictiona = _this$props4.dictionary,
+          dictionary = _this$props4$dictiona === void 0 ? {} : _this$props4$dictiona;
+
+      if (!(0, _isEqual["default"])(prevProps.value, valueFromProps) && !(0, _isEqual["default"])(valueFromProps, valueFromState)) {
+        this.setState({
+          value: this.isValid(valueFromProps) ? valueFromProps : ''
+        });
+      }
+
+      this.dict = _objectSpread(_objectSpread({}, this.dict), dictionary);
+      this.valid = this.isValid(valueFromState);
+    }
+    /**
+     * базовый рендер компонента
+     */
+
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props5 = this.props,
+          preset = _this$props5.preset,
+          _this$props5$placehol = _this$props5.placeholderChar,
+          placeholderChar = _this$props5$placehol === void 0 ? '_' : _this$props5$placehol,
+          placeholder = _this$props5.placeholder,
+          className = _this$props5.className,
+          autoFocus = _this$props5.autoFocus,
+          disabled = _this$props5.disabled,
+          keepCharPositions = _this$props5.keepCharPositions;
+      var _this$state = this.state,
+          guide = _this$state.guide,
+          value = _this$state.value;
+      var mask = this.preset(preset);
+      return /*#__PURE__*/_react["default"].createElement(_reactTextMask["default"], {
+        disabled: disabled,
+        className: (0, _classnames["default"])(['form-control', 'n2o-input-mask', className]),
+        placeholderChar: placeholderChar,
+        placeholder: placeholder,
+        guide: guide,
+        mask: mask || this.mask,
+        value: value,
+        onBlur: this.onBlur,
+        onChange: this.onChange,
+        onFocus: this.onFocus,
+        keepCharPositions: keepCharPositions,
+        render: function render(_ref3, props) {
+          return /*#__PURE__*/_react["default"].createElement("input", (0, _extends2["default"])({
+            ref: function ref(input) {
+              return _ref3(input);
+            }
+          }, props, {
+            /* eslint-disable-next-line jsx-a11y/no-autofocus */
+            autoFocus: autoFocus
+          }));
+        }
+      });
+    }
+  }]);
+  return InputMaskComponent;
+}(_react["default"].Component);
+
+(0, _defineProperty2["default"])(InputMaskComponent, "defaultProps", {
+  onChange: function onChange() {},
+  placeholderChar: '_',
+  guide: true,
+  keepCharPositions: false,
+  clearOnBlur: false,
+  value: '',
+  dictionary: {},
+  mask: '',
+  presetConfig: {},
+  onBlur: function onBlur() {},
+  disabled: false
+});
+var InputMask = (0, _withRightPlaceholder.withRightPlaceholder)(InputMaskComponent);
+exports.InputMask = InputMask;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/InputMask/InputMask.tsx"],"names":["InputMaskComponent","props","mask","mapToArray","preset","presetConfig","prefix","suffix","undefined","value","placeholderChar","toString","indexOf","map","item","RegExp","lastIndexOf","Math","max","Object","keys","dict","char","guide","indexOfFirstPlaceHolder","length","indexOfLastPlaceholder","split","e","target","onChange","valid","isValid","setState","nativeEvent","onBlur","clearOnBlur","newValue","state","S","Б","dictionary","prevProps","valueFromState","valueFromProps","placeholder","className","autoFocus","disabled","keepCharPositions","onFocus","ref","input","React","Component","InputMask"],"mappings":"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","sourcesContent":["import React, { SyntheticEvent, ChangeEventHandler } from 'react'\nimport MaskedInput from 'react-text-mask'\nimport cn from 'classnames'\nimport isEqual from 'lodash/isEqual'\nimport createNumberMask from 'text-mask-addons/dist/createNumberMask'\nimport { isArray, isFunction } from 'lodash'\n\nimport { withRightPlaceholder } from '../../helpers/withRightPlaceholder'\nimport { TBaseInputProps, TBaseProps } from '../../types'\n\nexport type PresetType = 'phone' | 'post-code' | 'date' | 'money' | 'percentage' | 'card'\ntype MaskType = string | Array<string | RegExp> | ((val?: unknown) => Array<string | RegExp>)\ntype InputMaskProps = TBaseProps & Omit<TBaseInputProps<string>, 'onBlur'> & {\n    clearOnBlur?: boolean,\n    dictionary?: Record<string, RegExp>,\n    // https://github.com/text-mask/text-mask/blob/master/componentDocumentation.md#guide\n    guide?: boolean,\n    // https://github.com/text-mask/text-mask/blob/master/componentDocumentation.md#keepcharpositions\n    keepCharPositions?: boolean,\n    // Стандартная конфигурация: 9 - цифра, S - английская буква, Б - русская буква. Дополнительную конфигурацию можно осуществить, используя dictionary\n    mask?: MaskType\n    onBlur?(value: string): void,\n    onChange?(value: string): void,\n    placeholder?: string,\n    // символ, который будет на месте незаполненного символа маски\n    placeholderChar?: string,\n    preset?: PresetType,\n    // настройки пресета для InputMoney\n    presetConfig?: Record<string, unknown>,\n}\n\ntype InputMaskState = {\n    guide: boolean,\n    value: string\n}\n\nclass InputMaskComponent extends React.Component<InputMaskProps, InputMaskState> {\n    valid: string | boolean\n\n    dict: Record<string | number, RegExp>\n\n    constructor(props: InputMaskProps) {\n        super(props)\n        this.state = {\n            value: props.value || '',\n            guide: false,\n        }\n        this.valid = false\n        this.dict = {\n            9: /\\d/,\n            S: /[A-Za-z]/,\n            Б: /[А-я]/,\n            ...props.dictionary,\n        }\n    }\n\n    /**\n     * преобразует маску-функцию, маску-строку в массив-маску (с regexp вместо символов) при помощи _mapToArray\n     */\n    mask = () => {\n        const { mask } = this.props\n\n        if (isArray(mask)) {\n            return mask\n        }\n\n        if (isFunction(mask)) {\n            return mask()\n        }\n\n        return this.mapToArray(mask)\n    }\n\n    /**\n     * возвращает маску для пресета\n     * @returns (number) возвращает массив-маску для пресета-аргумента\n     */\n    // eslint-disable-next-line consistent-return\n    preset = (preset?: PresetType) => {\n        const { presetConfig = {} } = this.props\n\n        switch (preset) {\n            case 'phone':\n                return this.mapToArray('+9 (999)-999-99-99')\n            case 'post-code':\n                return this.mapToArray('999999')\n            case 'date':\n                return this.mapToArray('99.99.9999')\n            case 'money':\n                return createNumberMask(presetConfig)\n            case 'percentage':\n                return createNumberMask({ prefix: '', suffix: '%' })\n            case 'card':\n                return this.mapToArray('9999 9999 9999 9999')\n            default:\n                return undefined\n        }\n    }\n\n    /**\n     * возвращает индекс первого символа маски, который еще не заполнен\n     * @returns (number) индекс первого символа маски, который еще не заполнен\n     */\n    indexOfFirstPlaceHolder = (value = '') => {\n        const { placeholderChar } = this.props\n\n        if (!placeholderChar) {\n            return null\n        }\n\n        return value.toString().indexOf(placeholderChar)\n    }\n\n    /**\n     * возвращает индекс последнего символа маски, который еще не заполнен\n     * @returns (number) индекс последнего символа маски, который еще не заполнен\n     */\n    indexOfLastPlaceholder = (mask: MaskType) => {\n        if (typeof mask === 'function') {\n            return mask()\n                .map(item => item instanceof RegExp)\n                .lastIndexOf(true)\n        }\n\n        if (typeof mask === 'string') {\n            return Math.max(\n                ...Object.keys(this.dict).map(char => mask.lastIndexOf(char)),\n            )\n        }\n\n        if (isArray(mask)) {\n            return mask.map(item => item instanceof RegExp).lastIndexOf(true)\n        }\n\n        return -1\n    }\n\n    isValid = (value: string) => {\n        const { preset, mask, guide = true } = this.props\n\n        if (guide) {\n            return value && this.indexOfFirstPlaceHolder(value) === -1\n        }\n\n        if (preset) {\n            return (\n                value.length > this.indexOfLastPlaceholder(this.preset(preset) || mask)\n            )\n        }\n\n        return false\n    }\n\n    /**\n     * преобразование строки маски в массив (уже с регулярными выражениями)\n     */\n    mapToArray = (mask = '') => mask.split('').map(char => (this.dict[char] ? this.dict[char] : char))\n\n    onChange: ChangeEventHandler = (e) => {\n        const { value } = e.target as HTMLInputElement\n        const { guide = true, onChange = () => {} } = this.props\n\n        this.valid = this.isValid(value)\n\n        this.setState({ value, guide }, () => {\n            if (this.valid || value === '') {\n                onChange(value)\n            }\n        })\n    }\n\n    onBlur = (e: SyntheticEvent) => {\n        const { value } = e.nativeEvent.target as HTMLInputElement\n        const { onBlur = () => {}, clearOnBlur, onChange = () => {} } = this.props\n\n        this.valid = this.isValid(value)\n        onBlur(value)\n        if (!this.valid) {\n            const newValue = clearOnBlur ? '' : value\n\n            this.setState(\n                { value: newValue, guide: false },\n                () => newValue === '' && onChange(newValue),\n            )\n        }\n    }\n\n    onFocus = () => {\n        const { guide = true } = this.props\n        const { value } = this.state\n\n        this.valid = this.isValid(value)\n        if (!this.valid) {\n            this.setState({ guide })\n        }\n    }\n\n    componentDidUpdate(prevProps: InputMaskProps) {\n        const { value: valueFromState } = this.state\n        const { value: valueFromProps = '', dictionary = {} } = this.props\n\n        if (\n            !isEqual(prevProps.value, valueFromProps) &&\n            !isEqual(valueFromProps, valueFromState)\n        ) {\n            this.setState({\n                value: this.isValid(valueFromProps) ? valueFromProps : '',\n            })\n        }\n\n        this.dict = { ...this.dict, ...dictionary }\n        this.valid = this.isValid(valueFromState)\n    }\n\n    /**\n     * базовый рендер компонента\n     */\n    render() {\n        const {\n            preset,\n            placeholderChar = '_',\n            placeholder,\n            className,\n            autoFocus,\n            disabled,\n            keepCharPositions,\n        } = this.props\n        const { guide, value } = this.state\n        const mask = this.preset(preset)\n\n        return (\n            <MaskedInput\n                disabled={disabled}\n                className={cn([\n                    'form-control',\n                    'n2o-input-mask',\n                    className,\n                ])}\n                placeholderChar={placeholderChar}\n                placeholder={placeholder}\n                guide={guide}\n                mask={mask || this.mask}\n                value={value}\n                onBlur={this.onBlur}\n                onChange={this.onChange}\n                onFocus={this.onFocus}\n                keepCharPositions={keepCharPositions}\n                render={(ref, props) => (\n                    <input\n                        ref={(input: HTMLInputElement) => ref(input)}\n                        {...props}\n                        /* eslint-disable-next-line jsx-a11y/no-autofocus */\n                        autoFocus={autoFocus}\n                    />\n                )}\n            />\n        )\n    }\n\n    static defaultProps = {\n        onChange: () => {},\n        placeholderChar: '_',\n        guide: true,\n        keepCharPositions: false,\n        clearOnBlur: false,\n        value: '',\n        dictionary: {},\n        mask: '',\n        presetConfig: {},\n        onBlur: () => {},\n        disabled: false,\n    } as InputMaskProps\n}\n\nexport const InputMask = withRightPlaceholder<InputMaskProps>(InputMaskComponent)\n"]}