@skbkontur/react-ui 5.6.7 → 5.6.9-5e213.0

package/cjs/components/MaskedInput/react-imask/imask/masked/pattern.js

@@ -0,0 +1,624 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;Object.defineProperty(exports, "__esModule", { value: true });exports.MaskedPattern = void 0;var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));var _isNativeReflectConstruct2 = _interopRequireDefault(require("@babel/runtime/helpers/isNativeReflectConstruct"));var _set2 = _interopRequireDefault(require("@babel/runtime/helpers/set"));var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _changeDetails = require("../core/change-details");
+
+var _utils = require("../core/utils");
+
+var _base = require("./base");
+var _factory = require("./factory");
+
+
+
+
+
+
+
+var _chunkTailDetails = require("./patterns/chunk-tail-details");
+var _cursor = require("./patterns/cursor");
+var _fixedDefinition = require("./patterns/fixed-definition");
+var _inputDefinition = require("./patterns/input-definition");
+require("./regexp");var _excluded = ["expose"],_excluded2 = ["_blocks"];function _callSuper(t, o, e) {return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, (0, _isNativeReflectConstruct2.default)() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e));} /* eslint-disable eqeqeq */ // support for default definitions which are regexp's
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** Pattern mask */var
+MaskedPattern = exports.MaskedPattern = /*#__PURE__*/function (_Masked) {
+
+
+
+
+
+
+
+
+
+
+
+  /** */
+
+  /** */
+
+  /** Single char for empty input */
+
+  /** Single char for filled input */
+
+  /** Show placeholder only when needed */
+
+  /** Enable characters overwriting */
+
+  /** */
+
+  /** */
+
+  /** */
+
+
+
+
+
+
+
+  function MaskedPattern(opts) {(0, _classCallCheck2.default)(this, MaskedPattern);return _callSuper(this, MaskedPattern, [(0, _objectSpread2.default)((0, _objectSpread2.default)((0, _objectSpread2.default)({},
+
+    MaskedPattern.DEFAULTS),
+    opts), {}, {
+      definitions: Object.assign({}, _inputDefinition.PatternInputDefinition.DEFAULT_DEFINITIONS, opts === null || opts === void 0 ? void 0 : opts.definitions) })]);
+
+  }(0, _inherits2.default)(MaskedPattern, _Masked);return (0, _createClass2.default)(MaskedPattern, [{ key: "updateOptions", value:
+
+    function updateOptions(opts) {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "updateOptions", this).call(this, opts);
+    } }, { key: "_update", value:
+
+    function _update(opts) {
+      opts.definitions = Object.assign({}, this.definitions, opts.definitions);
+      (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "_update", this).call(this, opts);
+      this._rebuildMask();
+    } }, { key: "_rebuildMask", value:
+
+    function _rebuildMask() {var _this = this;
+      var defs = this.definitions;
+      this._blocks = [];
+      this.exposeBlock = undefined;
+      this._stops = [];
+      this._maskedBlocks = {};
+
+      var pattern = this.mask;
+      if (!pattern || !defs) {
+        return;
+      }
+
+      var unmaskingBlock = false;
+      var optionalBlock = false;var _loop = function _loop(_i)
+
+        {
+          if (_this.blocks) {
+            var p = pattern.slice(_i);
+            var bNames = Object.keys(_this.blocks).filter(function (bName) {return p.indexOf(bName) === 0;});
+            // order by key length
+            bNames.sort(function (a, b) {return b.length - a.length;});
+            // use block name with max length
+            var bName = bNames[0];
+            if (bName) {
+              var _ref = (0, _factory.normalizeOpts)(_this.blocks[bName]),expose = _ref.expose,bOpts = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+              // TODO type Opts<Arg & Extra>
+              var blockOpts = (0, _objectSpread2.default)((0, _objectSpread2.default)({
+                lazy: _this.lazy,
+                eager: _this.eager,
+                placeholderChar: _this.placeholderChar,
+                displayChar: _this.displayChar,
+                overwrite: _this.overwrite,
+                autofix: _this.autofix },
+              bOpts), {}, {
+                parent: _this });
+
+              var maskedBlock = (0, _factory.createMask)(blockOpts);
+
+              if (maskedBlock) {
+                _this._blocks.push(maskedBlock);
+                if (expose) {
+                  _this.exposeBlock = maskedBlock;
+                }
+
+                // store block index
+                if (!_this._maskedBlocks[bName]) {
+                  _this._maskedBlocks[bName] = [];
+                }
+                _this._maskedBlocks[bName].push(_this._blocks.length - 1);
+              }
+
+              _i += bName.length - 1;i = _i;return 0; // continue
+
+            }
+          }
+
+          var char = pattern[_i];
+          var isInput = (char in defs);
+
+          if (char === MaskedPattern.STOP_CHAR) {
+            _this._stops.push(_this._blocks.length);i = _i;return 0; // continue
+
+          }
+
+          if (char === '{' || char === '}') {
+            unmaskingBlock = !unmaskingBlock;i = _i;return 0; // continue
+
+          }
+
+          if (char === '[' || char === ']') {
+            optionalBlock = !optionalBlock;i = _i;return 0; // continue
+
+          }
+
+          if (char === MaskedPattern.ESCAPE_CHAR) {
+            ++_i;
+            char = pattern[_i];
+            if (!char) {i = _i;return 1; // break
+
+            }
+            isInput = false;
+          }
+
+          var def = isInput ?
+          new _inputDefinition.PatternInputDefinition((0, _objectSpread2.default)((0, _objectSpread2.default)({
+            isOptional: optionalBlock,
+            lazy: _this.lazy,
+            eager: _this.eager,
+            placeholderChar: _this.placeholderChar,
+            displayChar: _this.displayChar },
+          (0, _factory.normalizeOpts)(defs[char])), {}, {
+            parent: _this })
+          ) :
+          new _fixedDefinition.PatternFixedDefinition({
+            char: char,
+            eager: _this.eager,
+            isUnmasking: unmaskingBlock
+          });
+
+          _this._blocks.push(def);i = _i;
+        },_ret;for (var i = 0; i < pattern.length; ++i) {_ret = _loop(i);if (_ret === 0) continue;if (_ret === 1) break;}
+    } }, { key: "state", get:
+
+    function get() {
+      return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "state", this)), {}, {
+
+
+        _blocks: this._blocks.map(function (b) {return b.state;}) });
+
+    }, set:
+
+    function set(state) {
+      if (!state) {
+        this.reset();
+        return;
+      }
+
+      var _blocks = state._blocks,maskedState = (0, _objectWithoutProperties2.default)(state, _excluded2);
+      this._blocks.forEach(function (b, bi) {return b.state = _blocks[bi];});
+      // @ts-expect-error - super.state is protected
+      (0, _set2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "state", maskedState, this, true);
+    } }, { key: "reset", value:
+
+    function reset() {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "reset", this).call(this);
+      this._blocks.forEach(function (b) {return b.reset();});
+    } }, { key: "isComplete", get:
+
+    function get() {
+      return this.exposeBlock ? this.exposeBlock.isComplete : this._blocks.every(function (b) {return b.isComplete;});
+    } }, { key: "isFilled", get:
+
+    function get() {
+      return this._blocks.every(function (b) {return b.isFilled;});
+    } }, { key: "isFixed", get:
+
+    function get() {
+      return this._blocks.every(function (b) {return b.isFixed;});
+    } }, { key: "isOptional", get:
+
+    function get() {
+      return this._blocks.every(function (b) {return b.isOptional;});
+    } }, { key: "doCommit", value:
+
+    function doCommit() {
+      this._blocks.forEach(function (b) {return b.doCommit();});
+      (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "doCommit", this).call(this);
+    } }, { key: "unmaskedValue", get:
+
+    function get() {
+      return this.exposeBlock ?
+      this.exposeBlock.unmaskedValue :
+      // eslint-disable-next-line no-param-reassign
+      this._blocks.reduce(function (str, b) {return str += b.unmaskedValue;}, '');
+    }, set:
+
+    function set(unmaskedValue) {
+      if (this.exposeBlock) {
+        var tail = this.extractTail(
+          this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length
+        );
+        this.exposeBlock.unmaskedValue = unmaskedValue;
+        this.appendTail(tail);
+        this.doCommit();
+      } else {
+        // @ts-expect-error - super.unmaskedValue is protected
+        (0, _set2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "unmaskedValue", unmaskedValue, this, true);
+      }
+    } }, { key: "value", get:
+
+    function get() {
+      return this.exposeBlock ?
+      this.exposeBlock.value :
+      // TODO return _value when not in change?
+      // eslint-disable-next-line no-param-reassign
+      this._blocks.reduce(function (str, b) {return str += b.value;}, '');
+    }, set:
+
+    function set(value) {
+      if (this.exposeBlock) {
+        var tail = this.extractTail(
+          this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length
+        );
+        this.exposeBlock.value = value;
+        this.appendTail(tail);
+        this.doCommit();
+      } else {
+        // @ts-expect-error - super.value is protected
+        (0, _set2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "value", value, this, true);
+      }
+    } }, { key: "typedValue", get:
+
+    function get() {
+      // @ts-expect-error - super.typedValue is protected
+      return this.exposeBlock ? this.exposeBlock.typedValue : (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "typedValue", this);
+    }, set:
+
+    function set(value) {
+      if (this.exposeBlock) {
+        var tail = this.extractTail(
+          this._blockStartPos(this._blocks.indexOf(this.exposeBlock)) + this.exposeBlock.displayValue.length
+        );
+        this.exposeBlock.typedValue = value;
+        this.appendTail(tail);
+        this.doCommit();
+      } else {
+        // @ts-expect-error - super.typedValue is protected
+        (0, _set2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "typedValue", value, this, true);
+      }
+    } }, { key: "displayValue", get:
+
+    function get() {
+      // eslint-disable-next-line no-param-reassign
+      return this._blocks.reduce(function (str, b) {return str += b.displayValue;}, '');
+    } }, { key: "appendTail", value:
+
+    function appendTail(tail) {
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "appendTail", this).call(this, tail).aggregate(this._appendPlaceholder());
+    } }, { key: "_appendEager", value:
+
+    function _appendEager() {var _this$_mapPosToBlock;
+      var details = new _changeDetails.ChangeDetails();
+
+      var startBlockIndex = (_this$_mapPosToBlock = this._mapPosToBlock(this.displayValue.length)) === null || _this$_mapPosToBlock === void 0 ? void 0 : _this$_mapPosToBlock.index;
+      if (startBlockIndex == null) {
+        return details;
+      }
+
+      // TODO test if it works for nested pattern masks
+      if (this._blocks[startBlockIndex].isFilled) {
+        ++startBlockIndex;
+      }
+
+      for (var bi = startBlockIndex; bi < this._blocks.length; ++bi) {
+        var d = this._blocks[bi]._appendEager();
+        if (!d.inserted) {
+          break;
+        }
+
+        details.aggregate(d);
+      }
+
+      return details;
+    } }, { key: "_appendCharRaw", value:
+
+    function _appendCharRaw(ch) {var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var blockIter = this._mapPosToBlock(this.displayValue.length);
+      var details = new _changeDetails.ChangeDetails();
+      if (!blockIter) {
+        return details;
+      }
+
+      for (var bi = blockIter.index, block; block = this._blocks[bi]; ++bi) {var _flags$_beforeTailSta;
+        var blockDetails = block._appendChar(ch, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, flags), {}, { _beforeTailState: (_flags$_beforeTailSta = flags._beforeTailState) === null || _flags$_beforeTailSta === void 0 || (_flags$_beforeTailSta = _flags$_beforeTailSta._blocks) === null || _flags$_beforeTailSta === void 0 ? void 0 : _flags$_beforeTailSta[bi] }));
+
+        details.aggregate(blockDetails);
+
+        if (blockDetails.consumed) {
+          break;
+        } // go next char
+      }
+
+      return details;
+    } }, { key: "extractTail", value:
+
+    function extractTail() {var _this2 = this;var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.displayValue.length;
+      var chunkTail = new _chunkTailDetails.ChunksTailDetails();
+      if (fromPos === toPos) {
+        return chunkTail;
+      }
+
+      this._forEachBlocksInRange(fromPos, toPos, function (b, bi, bFromPos, bToPos) {
+        var blockChunk = b.extractTail(bFromPos, bToPos);
+        blockChunk.stop = _this2._findStopBefore(bi);
+        blockChunk.from = _this2._blockStartPos(bi);
+        if (blockChunk instanceof _chunkTailDetails.ChunksTailDetails) {
+          blockChunk.blockIndex = bi;
+        }
+
+        chunkTail.extend(blockChunk);
+      });
+
+      return chunkTail;
+    } }, { key: "extractInput", value:
+
+    function extractInput()
+
+
+
+    {var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.displayValue.length;var flags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (fromPos === toPos) {
+        return '';
+      }
+
+      var input = '';
+
+      this._forEachBlocksInRange(fromPos, toPos, function (b, _, fromPos, toPos) {
+        input += b.extractInput(fromPos, toPos, flags);
+      });
+
+      return input;
+    } }, { key: "_findStopBefore", value:
+
+    function _findStopBefore(blockIndex) {
+      var stopBefore;
+      for (var si = 0; si < this._stops.length; ++si) {
+        var stop = this._stops[si];
+        if (stop <= blockIndex) {
+          stopBefore = stop;
+        } else {
+          break;
+        }
+      }
+      return stopBefore;
+    }
+
+    /** Appends placeholder depending on laziness */ }, { key: "_appendPlaceholder", value:
+    function _appendPlaceholder(toBlockIndex) {
+      var details = new _changeDetails.ChangeDetails();
+      if (this.lazy && toBlockIndex == null) {
+        return details;
+      }
+
+      var startBlockIter = this._mapPosToBlock(this.displayValue.length);
+      if (!startBlockIter) {
+        return details;
+      }
+
+      var startBlockIndex = startBlockIter.index;
+      var endBlockIndex = toBlockIndex != null ? toBlockIndex : this._blocks.length;
+
+      this._blocks.slice(startBlockIndex, endBlockIndex).forEach(function (b) {
+        if (!b.lazy || toBlockIndex != null) {var _blocks2;
+          details.aggregate(b._appendPlaceholder((_blocks2 = b._blocks) === null || _blocks2 === void 0 ? void 0 : _blocks2.length));
+        }
+      });
+
+      return details;
+    }
+
+    /** Finds block in pos */ }, { key: "_mapPosToBlock", value:
+    function _mapPosToBlock(pos) {
+      var accVal = '';
+      for (var bi = 0; bi < this._blocks.length; ++bi) {
+        var block = this._blocks[bi];
+        var blockStartPos = accVal.length;
+
+        accVal += block.displayValue;
+
+        if (pos <= accVal.length) {
+          return {
+            index: bi,
+            offset: pos - blockStartPos
+          };
+        }
+      }
+      return;
+    } }, { key: "_blockStartPos", value:
+
+    function _blockStartPos(blockIndex) {
+      // eslint-disable-next-line no-param-reassign
+      return this._blocks.slice(0, blockIndex).reduce(function (pos, b) {return pos += b.displayValue.length;}, 0);
+    } }, { key: "_forEachBlocksInRange", value:
+
+    function _forEachBlocksInRange(
+    fromPos)
+
+
+
+    {var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.displayValue.length;var fn = arguments.length > 2 ? arguments[2] : undefined;
+      var fromBlockIter = this._mapPosToBlock(fromPos);
+
+      if (fromBlockIter) {
+        var toBlockIter = this._mapPosToBlock(toPos);
+        // process first block
+        var isSameBlock = toBlockIter && fromBlockIter.index === toBlockIter.index;
+        var fromBlockStartPos = fromBlockIter.offset;
+        var fromBlockEndPos =
+        toBlockIter && isSameBlock ? toBlockIter.offset : this._blocks[fromBlockIter.index].displayValue.length;
+        fn(this._blocks[fromBlockIter.index], fromBlockIter.index, fromBlockStartPos, fromBlockEndPos);
+
+        if (toBlockIter && !isSameBlock) {
+          // process intermediate blocks
+          for (var bi = fromBlockIter.index + 1; bi < toBlockIter.index; ++bi) {
+            fn(this._blocks[bi], bi, 0, this._blocks[bi].displayValue.length);
+          }
+
+          // process last block
+          fn(this._blocks[toBlockIter.index], toBlockIter.index, 0, toBlockIter.offset);
+        }
+      }
+    } }, { key: "remove", value:
+
+    function remove() {var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.displayValue.length;
+      var removeDetails = (0, _get2.default)((0, _getPrototypeOf2.default)(MaskedPattern.prototype), "remove", this).call(this, fromPos, toPos);
+      this._forEachBlocksInRange(fromPos, toPos, function (b, _, bFromPos, bToPos) {
+        removeDetails.aggregate(b.remove(bFromPos, bToPos));
+      });
+      return removeDetails;
+    } }, { key: "nearestInputPos", value:
+
+    function nearestInputPos(cursorPos) {var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _utils.DIRECTION.NONE;
+      if (!this._blocks.length) {
+        return 0;
+      }
+      var cursor = new _cursor.PatternCursor(this, cursorPos);
+
+      if (direction === _utils.DIRECTION.NONE) {
+        // -------------------------------------------------
+        // NONE should only go out from fixed to the right!
+        // -------------------------------------------------
+        if (cursor.pushRightBeforeInput()) {
+          return cursor.pos;
+        }
+        cursor.popState();
+        if (cursor.pushLeftBeforeInput()) {
+          return cursor.pos;
+        }
+        return this.displayValue.length;
+      }
+
+      // FORCE is only about a|* otherwise is 0
+      if (direction === _utils.DIRECTION.LEFT || direction === _utils.DIRECTION.FORCE_LEFT) {
+        // try to break fast when *|a
+        if (direction === _utils.DIRECTION.LEFT) {
+          cursor.pushRightBeforeFilled();
+          if (cursor.ok && cursor.pos === cursorPos) {
+            return cursorPos;
+          }
+          cursor.popState();
+        }
+
+        // forward flow
+        cursor.pushLeftBeforeInput();
+        cursor.pushLeftBeforeRequired();
+        cursor.pushLeftBeforeFilled();
+
+        // backward flow
+        if (direction === _utils.DIRECTION.LEFT) {
+          cursor.pushRightBeforeInput();
+          cursor.pushRightBeforeRequired();
+          if (cursor.ok && cursor.pos <= cursorPos) {
+            return cursor.pos;
+          }
+          cursor.popState();
+          if (cursor.ok && cursor.pos <= cursorPos) {
+            return cursor.pos;
+          }
+          cursor.popState();
+        }
+        if (cursor.ok) {
+          return cursor.pos;
+        }
+        if (direction === _utils.DIRECTION.FORCE_LEFT) {
+          return 0;
+        }
+
+        cursor.popState();
+        if (cursor.ok) {
+          return cursor.pos;
+        }
+
+        cursor.popState();
+        if (cursor.ok) {
+          return cursor.pos;
+        }
+
+        return 0;
+      }
+
+      if (direction === _utils.DIRECTION.RIGHT || direction === _utils.DIRECTION.FORCE_RIGHT) {
+        // forward flow
+        cursor.pushRightBeforeInput();
+        cursor.pushRightBeforeRequired();
+
+        if (cursor.pushRightBeforeFilled()) {
+          return cursor.pos;
+        }
+        if (direction === _utils.DIRECTION.FORCE_RIGHT) {
+          return this.displayValue.length;
+        }
+
+        // backward flow
+        cursor.popState();
+        if (cursor.ok) {
+          return cursor.pos;
+        }
+
+        cursor.popState();
+        if (cursor.ok) {
+          return cursor.pos;
+        }
+
+        return this.nearestInputPos(cursorPos, _utils.DIRECTION.LEFT);
+      }
+
+      return cursorPos;
+    } }, { key: "totalInputPositions", value:
+
+    function totalInputPositions() {var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.displayValue.length;
+      var total = 0;
+      this._forEachBlocksInRange(fromPos, toPos, function (b, _, bFromPos, bToPos) {
+        total += b.totalInputPositions(bFromPos, bToPos);
+      });
+      return total;
+    }
+
+    /** Get block by name */ }, { key: "maskedBlock", value:
+    function maskedBlock(name) {
+      return this.maskedBlocks(name)[0];
+    }
+
+    /** Get all blocks by name */ }, { key: "maskedBlocks", value:
+    function maskedBlocks(name) {var _this3 = this;
+      var indices = this._maskedBlocks[name];
+      if (!indices) {
+        return [];
+      }
+      return indices.map(function (gi) {return _this3._blocks[gi];});
+    } }, { key: "pad", value:
+
+    function pad(flags) {
+      var details = new _changeDetails.ChangeDetails();
+      this._forEachBlocksInRange(0, this.displayValue.length, function (b) {return details.aggregate(b.pad(flags));});
+      return details;
+    } }]);}(_base.Masked);MaskedPattern.DEFAULTS = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _base.Masked.DEFAULTS), {}, { lazy: true, placeholderChar: '_' });MaskedPattern.STOP_CHAR = '`';MaskedPattern.ESCAPE_CHAR = '\\';MaskedPattern.InputDefinition = _inputDefinition.PatternInputDefinition;MaskedPattern.FixedDefinition = _fixedDefinition.PatternFixedDefinition;