@salutejs/plasma-new-hope 0.139.0-canary.1417.10685487591.0 → 0.139.0-canary.1418.10685382771.0

package/styled-components/cjs/components/Mask/Mask.js

@@ -0,0 +1,233 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.composeMask = void 0;
+var _react = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("react"));
+var _plasmaCore = /*#__PURE__*/require("@salutejs/plasma-core");
+var _createMask = /*#__PURE__*/require("./utils/createMask");
+var _constants = /*#__PURE__*/require("./utils/constants");
+var _excluded = ["mask", "maskChar", "alwaysShowMask", "maskString", "showPrefix", "value", "defaultValue", "showMask", "onChange", "getApplyValueCallback", "onValueChange", "onBlur", "onFocus", "reformat"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+var composeMask = exports.composeMask = function composeMask(InputComponent) {
+  return /*#__PURE__*/(0, _react.forwardRef)(function (props, outerRef) {
+    var maskValue = props.mask,
+      maskChar = props.maskChar,
+      alwaysShowMask = props.alwaysShowMask,
+      maskString = props.maskString,
+      showPrefix = props.showPrefix,
+      value = props.value,
+      defaultValue = props.defaultValue,
+      showMaskedValue = props.showMask,
+      onChange = props.onChange,
+      getApplyValueCallback = props.getApplyValueCallback,
+      onValueChange = props.onValueChange,
+      onBlur = props.onBlur,
+      onFocus = props.onFocus,
+      reformat = props.reformat,
+      rest = _objectWithoutProperties(props, _excluded);
+    var mask = (0, _react.useMemo)(function () {
+      return (0, _createMask.createMask)({
+        value: String(value) || String(defaultValue) || '',
+        maskChar: maskChar || _createMask.defaults.maskChar,
+        mask: maskValue,
+        maskString: maskString,
+        showPrefix: showPrefix || _createMask.defaults.showPrefix,
+        reformat: reformat
+      });
+    }, []);
+    var firstRender = (0, _react.useRef)(true);
+    var canSetSelection = (0, _react.useRef)(false);
+    var inputRef = (0, _react.useRef)(null);
+    var innerRef = (0, _plasmaCore.useForkRef)(inputRef, outerRef);
+    var _useState = (0, _react.useState)(alwaysShowMask || showMaskedValue),
+      _useState2 = _slicedToArray(_useState, 2),
+      showMask = _useState2[0],
+      setShowMask = _useState2[1];
+    var getSelection = (0, _react.useCallback)(function () {
+      var _inputRef$current, _inputRef$current2;
+      mask.setSelection = {
+        start: (inputRef === null || inputRef === void 0 || (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.selectionStart) || 0,
+        end: (inputRef === null || inputRef === void 0 || (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.selectionEnd) || 0
+      };
+    }, [mask]);
+    var setSelection = (0, _react.useCallback)(function () {
+      var _inputRef$current3;
+      if (!canSetSelection.current) {
+        return;
+      }
+      var selection = mask.getSelection;
+      inputRef === null || inputRef === void 0 || (_inputRef$current3 = inputRef.current) === null || _inputRef$current3 === void 0 || _inputRef$current3.setSelectionRange(selection.start, selection.end);
+      var raf = function raf(fn) {
+        return setTimeout(fn, 0);
+      };
+      if (typeof window !== 'undefined' && window.requestAnimationFrame) {
+        raf = window.requestAnimationFrame;
+      }
+      raf(function () {
+        var _inputRef$current4;
+        return inputRef === null || inputRef === void 0 || (_inputRef$current4 = inputRef.current) === null || _inputRef$current4 === void 0 ? void 0 : _inputRef$current4.setSelectionRange(selection.start, selection.end);
+      });
+    }, [mask]);
+    var showValue = (0, _react.useCallback)(function () {
+      if (!(inputRef !== null && inputRef !== void 0 && inputRef.current)) {
+        return;
+      }
+      if (showMask && (canSetSelection.current || alwaysShowMask)) {
+        inputRef.current.value = mask.getState().maskedValue;
+        return;
+      }
+      inputRef.current.value = mask.getState().visibleValue;
+    }, [showMask, alwaysShowMask, mask]);
+    var keyPressPropName = (0, _react.useCallback)(function () {
+      if (typeof navigator !== 'undefined' && navigator.userAgent.match(/Android/i)) {
+        return 'onBeforeInput';
+      }
+      return 'onKeyPress';
+    }, []);
+    var dispatchEvent = function dispatchEvent(e) {
+      onChange && onChange(e);
+      var _mask$getState = mask.getState(),
+        maskedValue = _mask$getState.maskedValue,
+        visibleValue = _mask$getState.visibleValue;
+      onValueChange && onValueChange({
+        maskedValue: maskedValue,
+        value: visibleValue
+      });
+    };
+    var onPaste = function onPaste(e) {
+      e.preventDefault();
+      getSelection();
+      if (!(e !== null && e !== void 0 && e.clipboardData)) {
+        return;
+      }
+      mask.paste(e.clipboardData.getData('Text'));
+      setTimeout(setSelection, 0);
+      dispatchEvent(e);
+    };
+    var handleChange = function handleChange(e) {
+      var currentValue;
+      if (showMask && (canSetSelection.current || alwaysShowMask)) {
+        currentValue = mask.getState().maskedValue;
+      } else {
+        currentValue = mask.getState().visibleValue;
+      }
+      if (e.target.value !== currentValue) {
+        getSelection();
+        mask.setValue = e.target.value;
+        setTimeout(setSelection, 0);
+      }
+      dispatchEvent(e);
+    };
+    var onKeyPress = function onKeyPress(e) {
+      if (e.metaKey || e.altKey || e.ctrlKey || e.key === 'Enter') {
+        return;
+      }
+      e.preventDefault();
+      getSelection();
+      mask.input(e.key || String.fromCharCode(e.which));
+      setSelection();
+      dispatchEvent(e);
+    };
+    var onKeyDown = function onKeyDown(e) {
+      if (e.keyCode === _constants.KEYBOARD.BACKSPACE) {
+        e.preventDefault();
+        getSelection();
+        mask.removePreviosOrSelected();
+        setSelection();
+        dispatchEvent(e);
+      }
+      if (e.keyCode === _constants.KEYBOARD.DELETE) {
+        e.preventDefault();
+        getSelection();
+        mask.removeNextOrSelected();
+        setSelection();
+        dispatchEvent(e);
+      }
+    };
+    var handleFocus = function handleFocus(e) {
+      canSetSelection.current = true;
+      onFocus && onFocus(e);
+    };
+    var handleBlur = function handleBlur(e) {
+      canSetSelection.current = false;
+      onBlur && onBlur(e);
+    };
+    var keyPressEvent = _defineProperty({}, keyPressPropName(), onKeyPress);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current) {
+        setShowMask(alwaysShowMask || showMask);
+      }
+    }, [alwaysShowMask, showMask]);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current && reformat) {
+        mask.setReformat(reformat);
+      }
+    }, [reformat]);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current) {
+        mask.setMask(String(mask));
+      }
+    }, [mask]);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current) {
+        mask.setMaskString(String(maskString));
+      }
+    }, [maskString]);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current) {
+        mask.setMaskChar(String(maskChar));
+      }
+    }, [maskChar]);
+    (0, _react.useEffect)(function () {
+      if (!firstRender.current) {
+        mask.setValue = String(value);
+      }
+    }, [value]);
+    (0, _react.useEffect)(function () {
+      firstRender.current = false;
+      showValue();
+    }, [firstRender.current, mask]);
+    (0, _react.useEffect)(function () {
+      getApplyValueCallback && getApplyValueCallback(function (str) {
+        mask.setValue = str;
+        showValue();
+      });
+    }, [getApplyValueCallback, showValue]);
+    (0, _react.useEffect)(function () {
+      var subscriber = function subscriber() {
+        showValue();
+        setSelection();
+      };
+      mask.subscribe(subscriber);
+      return function () {
+        mask.unsubscribe(subscriber);
+      };
+    }, [mask, showValue, setSelection]);
+    return /*#__PURE__*/_react["default"].createElement(InputComponent, _extends({}, rest, {
+      onChange: handleChange,
+      onKeyDown: onKeyDown,
+      onPaste: onPaste,
+      onFocus: handleFocus,
+      onBlur: handleBlur
+    }, keyPressEvent, {
+      ref: innerRef,
+      autoComplete: "off"
+    }));
+  });
+};

package/styled-components/cjs/components/Mask/Mask.types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/styled-components/cjs/components/Mask/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "composeMask", {
+  enumerable: true,
+  get: function get() {
+    return _Mask.composeMask;
+  }
+});
+var _Mask = /*#__PURE__*/require("./Mask");

package/styled-components/cjs/components/Mask/utils/constants.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeChar = exports.defaultFormatChars = exports.KEYBOARD = exports.CharTypes = void 0;
+var CharTypes = exports.CharTypes = /*#__PURE__*/function (CharTypes) {
+  CharTypes[CharTypes["USER"] = 1] = "USER";
+  CharTypes[CharTypes["CHAR"] = 2] = "CHAR";
+  CharTypes[CharTypes["MASK"] = 3] = "MASK";
+  return CharTypes;
+}({});
+var escapeChar = exports.escapeChar = '\\';
+var defaultFormatChars = exports.defaultFormatChars = [{
+  str: '0',
+  regexp: /[0-9]/
+}, {
+  str: '*',
+  regexp: /./
+}, {
+  str: 'a',
+  regexp: /[a-zA-Z]/
+}, {
+  str: 'я',
+  regexp: /[а-яА-ЯёЁ]/
+}];
+var KEYBOARD = exports.KEYBOARD = {
+  BACKSPACE: 8,
+  DELETE: 46
+};

package/styled-components/cjs/components/Mask/utils/createMask.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaults = exports.createMask = void 0;
+var _constants = /*#__PURE__*/require("./constants");
+var _maskUtils = /*#__PURE__*/require("./maskUtils");
+var _parseMask = /*#__PURE__*/require("./parseMask");
+var _selection = /*#__PURE__*/require("./selection");
+var defaults = exports.defaults = {
+  maskFormat: _constants.defaultFormatChars,
+  maskChar: '',
+  showMask: false,
+  removeSelectedRange: _selection.removeSelectedRange,
+  showPrefix: false
+};
+var createMask = exports.createMask = function createMask(params) {
+  var _params$mask;
+  var maskString = params.maskString,
+    reformat = params.reformat,
+    _params$showPrefix = params.showPrefix,
+    showPrefix = _params$showPrefix === void 0 ? defaults.showPrefix : _params$showPrefix,
+    _params$maskChar = params.maskChar,
+    maskChar = _params$maskChar === void 0 ? defaults.maskChar : _params$maskChar;
+  var resReformat = reformat;
+  if (!reformat && !params.mask) {
+    resReformat = function resReformat(args) {
+      var str = args.value.map(function (item) {
+        return item["char"];
+      }).join('');
+      return {
+        value: args.value,
+        visibleValue: str,
+        maskedValue: str,
+        selection: args.selection
+      };
+    };
+  } else if (reformat && params.mask) {
+    params.mask = undefined;
+  }
+  if (maskString && maskString.length !== (params === null || params === void 0 || (_params$mask = params.mask) === null || _params$mask === void 0 ? void 0 : _params$mask.length)) {
+    throw new Error('maskString must have same length as mask');
+  }
+  if (maskChar.length > 1) {
+    throw new Error('maskChar must have only 1 char');
+  }
+  var maskUtils = new _maskUtils.MaskUtils(showPrefix, maskChar, maskString, resReformat);
+  maskUtils.setMaskFormat = defaults.maskFormat;
+  maskUtils.mask = (0, _parseMask.parseMask)(params.mask, maskUtils.maskFormatMap);
+  maskUtils.setValue = params.value;
+  return maskUtils;
+};

package/styled-components/cjs/components/Mask/utils/maskUtils.js

@@ -0,0 +1,256 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MaskUtils = void 0;
+var _constants = /*#__PURE__*/require("./constants");
+var _parseMask = /*#__PURE__*/require("./parseMask");
+var _processInput = /*#__PURE__*/require("./processInput");
+var _selection = /*#__PURE__*/require("./selection");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var MaskUtils = exports.MaskUtils = /*#__PURE__*/function () {
+  function MaskUtils(showPrefix, maskChar, maskString, reformat) {
+    _classCallCheck(this, MaskUtils);
+    _defineProperty(this, "maskFormatMap", void 0);
+    _defineProperty(this, "selection", void 0);
+    _defineProperty(this, "value", void 0);
+    _defineProperty(this, "maskedValue", void 0);
+    _defineProperty(this, "visibleValue", void 0);
+    _defineProperty(this, "mask", void 0);
+    _defineProperty(this, "maskChar", void 0);
+    _defineProperty(this, "maskString", void 0);
+    _defineProperty(this, "showPrefix", void 0);
+    _defineProperty(this, "callbacks", void 0);
+    _defineProperty(this, "reformat", void 0);
+    this.maskFormatMap = {};
+    this.selection = {
+      start: 0,
+      end: 0
+    };
+    this.value = '';
+    this.maskedValue = '';
+    this.visibleValue = '';
+    this.mask = [];
+    this.showPrefix = showPrefix;
+    this.callbacks = [];
+    this.maskChar = maskChar;
+    this.maskString = maskString;
+    this.reformat = reformat;
+  }
+  return _createClass(MaskUtils, [{
+    key: "setShowStartChars",
+    set: function set(show) {
+      this.showPrefix = show;
+    }
+  }, {
+    key: "setMaskFormat",
+    set: function set(maskFormat) {
+      if (!maskFormat) {
+        return;
+      }
+      this.maskFormatMap = maskFormat.reduce(function (acc, current) {
+        acc[String(current.str)] = current;
+        return acc;
+      }, {});
+    }
+  }, {
+    key: "getSelection",
+    get: function get() {
+      var _this$selection = this.selection,
+        start = _this$selection.start,
+        end = _this$selection.end;
+      return {
+        start: start,
+        end: end
+      };
+    }
+  }, {
+    key: "setSelection",
+    set: function set(newSelection) {
+      this.selection = newSelection;
+    }
+  }, {
+    key: "setValue",
+    set: function set(data) {
+      var result;
+      if (this.reformat) {
+        result = this.reformat({
+          value: data,
+          selection: this.selection
+        });
+      } else {
+        var dataList;
+        if (Array.isArray(data)) {
+          dataList = data;
+        } else {
+          dataList = [];
+          for (var i = 0; i < data.length; i++) {
+            dataList.push({
+              "char": data[i],
+              type: _constants.CharTypes.USER
+            });
+          }
+        }
+        result = (0, _processInput.processInput)({
+          data: dataList,
+          selection: this.selection,
+          mask: this.mask,
+          maskChar: this.maskChar,
+          maskString: this.maskString,
+          showPrefix: this.showPrefix
+        });
+      }
+      this.applyChanges(result);
+    }
+  }, {
+    key: "getState",
+    value: function getState() {
+      return {
+        value: this.value,
+        maskedValue: this.maskedValue,
+        visibleValue: this.visibleValue,
+        selection: this.selection
+      };
+    }
+  }, {
+    key: "setMask",
+    value: function setMask(newMask) {
+      this.mask = (0, _parseMask.parseMask)(newMask, this.maskFormatMap);
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setMaskChar",
+    value: function setMaskChar(newMaskChar) {
+      if (this.maskChar.length > 1) {
+        throw new Error('maskChar must have only 1 char');
+      }
+      this.maskChar = newMaskChar;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setMaskString",
+    value: function setMaskString(newMaskString) {
+      if (newMaskString && newMaskString.length !== this.mask.length) {
+        throw new Error('maskString must have the same length as mask');
+      }
+      this.maskString = newMaskString;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "setReformat",
+    value: function setReformat(newReformat) {
+      this.reformat = newReformat;
+      this.setValue = this.value;
+    }
+  }, {
+    key: "backspace",
+    value: function backspace() {
+      this.removePreviosOrSelected();
+    }
+  }, {
+    key: "removePreviosOrSelected",
+    value: function removePreviosOrSelected() {
+      var _this$selection2 = this.selection,
+        start = _this$selection2.start,
+        end = _this$selection2.end;
+      if (start === end) {
+        var newStart = end - 1 < 0 ? 0 : end - 1;
+        this.setSelection = {
+          start: newStart,
+          end: end
+        };
+      }
+      this.input('');
+    }
+  }, {
+    key: "removeNextOrSelected",
+    value: function removeNextOrSelected() {
+      var _this$selection3 = this.selection,
+        start = _this$selection3.start,
+        end = _this$selection3.end;
+      if (start === end) {
+        this.setSelection = {
+          start: start,
+          end: end + 1
+        };
+      }
+      this.input('');
+    }
+  }, {
+    key: "subscribe",
+    value: function subscribe(callback) {
+      this.callbacks.push(callback);
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(callback) {
+      this.callbacks = this.callbacks.filter(function (item) {
+        return item !== callback;
+      });
+    }
+  }, {
+    key: "paste",
+    value: function paste(value) {
+      this.input(value);
+    }
+  }, {
+    key: "input",
+    value: function input(_input) {
+      var result;
+      if (this.reformat) {
+        result = this.reformat({
+          value: this.value,
+          input: _input,
+          selection: this.selection
+        });
+      } else {
+        var tmpValue = (0, _selection.removeSelectedRange)({
+          value: this.value,
+          selection: this.selection,
+          maskChar: this.maskChar,
+          maskString: String(this.maskString)
+        });
+        this.selection.end = this.selection.start;
+        result = (0, _processInput.processInput)({
+          data: tmpValue,
+          input: _input,
+          selection: this.selection,
+          mask: this.mask,
+          maskChar: this.maskChar,
+          maskString: this.maskString,
+          showPrefix: this.showPrefix
+        });
+      }
+      this.applyChanges(result);
+    }
+  }, {
+    key: "applyChanges",
+    value: function applyChanges(result) {
+      var oldMaskedValue = this.maskedValue;
+      var oldVisibleValue = this.visibleValue;
+      var oldSelection = this.selection;
+      this.value = result.value;
+      this.maskedValue = result.maskedValue;
+      this.visibleValue = result.visibleValue;
+      this.setSelection = result.selection;
+      if (oldMaskedValue !== this.maskedValue || oldVisibleValue !== this.visibleValue || oldSelection.start !== this.selection.start || oldSelection.end !== this.selection.end) {
+        this.notify();
+      }
+    }
+  }, {
+    key: "notify",
+    value: function notify() {
+      var state = this.getState();
+      this.callbacks.forEach(function (callback) {
+        callback(state);
+      });
+    }
+  }]);
+}();

package/styled-components/cjs/components/Mask/utils/parseMask.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseMask = void 0;
+var _constants = /*#__PURE__*/require("./constants");
+var parseMask = exports.parseMask = function parseMask(mask, format) {
+  if (!mask) {
+    return [];
+  }
+  var stack = [];
+  var escape = false;
+  mask.split('').forEach(function (maskChar) {
+    var item = format === null || format === void 0 ? void 0 : format[maskChar];
+    if (escape && item) {
+      item = undefined;
+      escape = false;
+    }
+    if (!item) {
+      if (!escape && maskChar === _constants.escapeChar) {
+        escape = true;
+        return;
+      }
+      escape = false;
+      stack.push({
+        "char": maskChar
+      });
+      return;
+    }
+    if (item.regexp) {
+      stack.push(item);
+    }
+  });
+  return stack;
+};

package/styled-components/cjs/components/Mask/utils/processInput.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processInput = void 0;
+var _constants = /*#__PURE__*/require("./constants");
+var _processMask2 = /*#__PURE__*/require("./processMask");
+var processInput = exports.processInput = function processInput(args) {
+  var data = args.data,
+    _args$input = args.input,
+    input = _args$input === void 0 ? '' : _args$input,
+    selection = args.selection,
+    mask = args.mask,
+    _args$maskChar = args.maskChar,
+    maskChar = _args$maskChar === void 0 ? '' : _args$maskChar,
+    _args$maskString = args.maskString,
+    maskString = _args$maskString === void 0 ? '' : _args$maskString,
+    showPrefix = args.showPrefix;
+  var _processMask = (0, _processMask2.processMask)(data, mask, input, maskChar, maskString, selection),
+    value = _processMask.value,
+    maskedValue = _processMask.maskedValue,
+    inputValuesApplied = _processMask.inputValuesApplied;
+  var selectionPosition = selection.start + inputValuesApplied;
+  var bound = value.length - 1;
+  var charsCount = 0;
+  while (bound >= 0 && value[bound].type !== _constants.CharTypes.USER) {
+    if (value[bound].type === _constants.CharTypes.MASK) {
+      charsCount = 0;
+    }
+    if (value[bound].type === _constants.CharTypes.CHAR) {
+      charsCount++;
+    }
+    bound--;
+  }
+  if (showPrefix || bound >= 0 || input && input.trim()) {
+    bound += charsCount;
+  }
+  var visibleValue = '';
+  for (var i = 0; i <= bound; i++) {
+    visibleValue += value[i]["char"];
+  }
+  return {
+    value: value,
+    visibleValue: visibleValue,
+    maskedValue: maskedValue,
+    selection: {
+      start: selectionPosition,
+      end: selectionPosition
+    }
+  };
+};