|
|
"use strict";
|
|
|
|
|
|
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
|
|
|
|
|
|
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
|
|
|
|
|
|
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
|
|
|
|
|
|
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
|
|
|
|
|
|
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
|
|
|
|
|
|
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
|
|
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
|
|
|
|
|
|
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
|
|
|
|
|
|
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, descriptor.key, descriptor); } }
|
|
|
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
|
|
|
|
|
var AbstractSmartDatePart =
|
|
|
/*#__PURE__*/
|
|
|
function () {
|
|
|
function AbstractSmartDatePart(placeholder, isStatic) {
|
|
|
_classCallCheck(this, AbstractSmartDatePart);
|
|
|
|
|
|
this._state = AbstractSmartDatePart.STATE_NONE;
|
|
|
this._cleanedValue = '';
|
|
|
this._parsedValue = '';
|
|
|
this._scanned = '';
|
|
|
this._placeholder = placeholder;
|
|
|
this._static = isStatic;
|
|
|
}
|
|
|
|
|
|
_createClass(AbstractSmartDatePart, [{
|
|
|
key: "state",
|
|
|
value: function state() {
|
|
|
return this._state;
|
|
|
}
|
|
|
}, {
|
|
|
key: "isNoState",
|
|
|
value: function isNoState() {
|
|
|
return this._state === AbstractSmartDatePart.STATE_NONE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "isIncomplete",
|
|
|
value: function isIncomplete() {
|
|
|
return this._state === AbstractSmartDatePart.STATE_INCOMPLETE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "isComplete",
|
|
|
value: function isComplete() {
|
|
|
return this._state === AbstractSmartDatePart.STATE_COMPLETE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "resetState",
|
|
|
value: function resetState() {
|
|
|
this._state = AbstractSmartDatePart.STATE_NONE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "cleanedValue",
|
|
|
value: function cleanedValue() {
|
|
|
return this._cleanedValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "parsedValue",
|
|
|
value: function parsedValue() {
|
|
|
return this._parsedValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "placeHolder",
|
|
|
value: function placeHolder() {
|
|
|
return this._placeholder;
|
|
|
}
|
|
|
}, {
|
|
|
key: "isStatic",
|
|
|
value: function isStatic() {
|
|
|
return this._static;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_isNumericSymbol",
|
|
|
value: function _isNumericSymbol(symbol) {
|
|
|
return '0' <= symbol && symbol <= '9';
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
* @returns {Boolean}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "check",
|
|
|
value: function check(state) {
|
|
|
return false;
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return AbstractSmartDatePart;
|
|
|
}();
|
|
|
|
|
|
;
|
|
|
AbstractSmartDatePart.STATE_NONE = 0;
|
|
|
AbstractSmartDatePart.STATE_INCOMPLETE = 1;
|
|
|
AbstractSmartDatePart.STATE_COMPLETE = 2;
|
|
|
|
|
|
var SmartDateStaticPart =
|
|
|
/*#__PURE__*/
|
|
|
function (_AbstractSmartDatePar) {
|
|
|
_inherits(SmartDateStaticPart, _AbstractSmartDatePar);
|
|
|
|
|
|
function SmartDateStaticPart(placeholder) {
|
|
|
var _this2;
|
|
|
|
|
|
_classCallCheck(this, SmartDateStaticPart);
|
|
|
|
|
|
_this2 = _possibleConstructorReturn(this, _getPrototypeOf(SmartDateStaticPart).call(this, placeholder, true));
|
|
|
_this2._cleanedValue = placeholder;
|
|
|
return _this2;
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
* @returns {Boolean}
|
|
|
*/
|
|
|
|
|
|
|
|
|
_createClass(SmartDateStaticPart, [{
|
|
|
key: "parse",
|
|
|
value: function parse(state) {
|
|
|
var value = state.value();
|
|
|
var index = state.valueIndex();
|
|
|
|
|
|
while (index < value.length && !this._isNumericSymbol(value[index])) {
|
|
|
index++;
|
|
|
}
|
|
|
|
|
|
this._parsedValue = value.substring(state.valueIndex(), index);
|
|
|
this._state = AbstractSmartDatePart.STATE_COMPLETE;
|
|
|
state.setValueIndex(index);
|
|
|
return true;
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateStaticPart;
|
|
|
}(AbstractSmartDatePart);
|
|
|
|
|
|
var AbstractSmartDateNumericPart =
|
|
|
/*#__PURE__*/
|
|
|
function (_AbstractSmartDatePar2) {
|
|
|
_inherits(AbstractSmartDateNumericPart, _AbstractSmartDatePar2);
|
|
|
|
|
|
function AbstractSmartDateNumericPart(placeholder, size) {
|
|
|
var _this3;
|
|
|
|
|
|
_classCallCheck(this, AbstractSmartDateNumericPart);
|
|
|
|
|
|
_this3 = _possibleConstructorReturn(this, _getPrototypeOf(AbstractSmartDateNumericPart).call(this, placeholder, false));
|
|
|
_this3._numericValue = 0;
|
|
|
_this3._size = size;
|
|
|
return _this3;
|
|
|
}
|
|
|
|
|
|
_createClass(AbstractSmartDateNumericPart, [{
|
|
|
key: "numericValue",
|
|
|
value: function numericValue() {
|
|
|
return this._numericValue;
|
|
|
}
|
|
|
/**
|
|
|
* @param {Date} date
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "formatDate",
|
|
|
value: function formatDate(date) {
|
|
|
return '';
|
|
|
}
|
|
|
}, {
|
|
|
key: "formatValue",
|
|
|
value: function formatValue(value) {
|
|
|
var stringValue = String(this._correctValue(value));
|
|
|
|
|
|
if (stringValue === '0') {
|
|
|
return stringValue;
|
|
|
}
|
|
|
|
|
|
if (stringValue.length > this._size) {
|
|
|
return stringValue.substring(0, this._size);
|
|
|
}
|
|
|
|
|
|
if (stringValue.length < this._size) {
|
|
|
return stringValue.padStart(this._size, '0');
|
|
|
}
|
|
|
|
|
|
return stringValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_correctValue",
|
|
|
value: function _correctValue(value) {
|
|
|
return Math.round(value);
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "scanStringNumber",
|
|
|
value: function scanStringNumber(state) {
|
|
|
var index = state.valueIndex();
|
|
|
var value = state.value();
|
|
|
|
|
|
while (index < value.length && this._isNumericSymbol(value[index])) {
|
|
|
index++;
|
|
|
}
|
|
|
|
|
|
var stringValue = value.substring(state.valueIndex(), index);
|
|
|
state.setValueIndex(index);
|
|
|
return stringValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "calculateNumericValue",
|
|
|
value: function calculateNumericValue(stringValue, maximalNumber) {
|
|
|
var startIndex = 0;
|
|
|
var endIndex = 0;
|
|
|
var numericValue = 0;
|
|
|
|
|
|
while (startIndex < stringValue.length && stringValue[startIndex] === 0) {
|
|
|
startIndex++;
|
|
|
}
|
|
|
|
|
|
endIndex = startIndex;
|
|
|
|
|
|
while (endIndex < stringValue.length && numericValue < maximalNumber) {
|
|
|
numericValue = numericValue * 10 + Number(stringValue[endIndex]);
|
|
|
endIndex++;
|
|
|
}
|
|
|
|
|
|
if (numericValue > maximalNumber) {
|
|
|
endIndex--;
|
|
|
}
|
|
|
|
|
|
return Number(stringValue.substring(startIndex, endIndex));
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
* @param {Number} maximalValue
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "scanValue",
|
|
|
value: function scanValue(state, maximalValue) {
|
|
|
var index = state.valueIndex();
|
|
|
var value = state.value();
|
|
|
var numericValue = 0;
|
|
|
|
|
|
while (index < value.length && this._isNumericSymbol(value[index]) && numericValue < maximalValue) {
|
|
|
numericValue = numericValue * 10 + Number(value[index]);
|
|
|
index++;
|
|
|
}
|
|
|
|
|
|
if (numericValue > maximalValue) {
|
|
|
index--;
|
|
|
}
|
|
|
|
|
|
var stringValue = value.substring(state.valueIndex(), index);
|
|
|
state.setValueIndex(index);
|
|
|
return stringValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_defineParsingState",
|
|
|
value: function _defineParsingState(maximalValue, isAtEnd) {
|
|
|
if (this._numericValue > 0 && (this._parsedValue.length >= this._size || !isAtEnd)) {
|
|
|
this._state = AbstractSmartDatePart.STATE_COMPLETE;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (this._numericValue * 10 > maximalValue) {
|
|
|
this._state = AbstractSmartDatePart.STATE_COMPLETE;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._state = AbstractSmartDatePart.STATE_INCOMPLETE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_defineCleanValue",
|
|
|
value: function _defineCleanValue() {
|
|
|
this._cleanedValue = '';
|
|
|
|
|
|
if (this.isNoState()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (this.isComplete()) {
|
|
|
this._cleanedValue = this.formatValue(this._numericValue);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (this._parsedValue.length > 0) {
|
|
|
this._cleanedValue = String(this._numericValue);
|
|
|
}
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return AbstractSmartDateNumericPart;
|
|
|
}(AbstractSmartDatePart);
|
|
|
|
|
|
var SmartDateDayPart =
|
|
|
/*#__PURE__*/
|
|
|
function (_AbstractSmartDateNum) {
|
|
|
_inherits(SmartDateDayPart, _AbstractSmartDateNum);
|
|
|
|
|
|
function SmartDateDayPart() {
|
|
|
var _this4;
|
|
|
|
|
|
_classCallCheck(this, SmartDateDayPart);
|
|
|
|
|
|
_this4 = _possibleConstructorReturn(this, _getPrototypeOf(SmartDateDayPart).call(this, SmartDateFormat.DAY_PLACEHOLDER, 2));
|
|
|
_this4.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
|
|
|
return _this4;
|
|
|
}
|
|
|
|
|
|
_createClass(SmartDateDayPart, [{
|
|
|
key: "resetState",
|
|
|
value: function resetState() {
|
|
|
_get(_getPrototypeOf(SmartDateDayPart.prototype), "resetState", this).call(this);
|
|
|
|
|
|
this.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "setMaximalValue",
|
|
|
value: function setMaximalValue(value) {
|
|
|
if (value != value
|
|
|
/* isNaN */
|
|
|
|| value < SmartDateDayPart.MAXIMAL_VALUE_LOW_LIMIT || SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT < value) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this.maximalValue = value;
|
|
|
|
|
|
if (this._numericValue <= this.maximalValue) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._numericValue = this.maximalValue;
|
|
|
|
|
|
this._defineCleanValue();
|
|
|
}
|
|
|
}, {
|
|
|
key: "resetMaximalValue",
|
|
|
value: function resetMaximalValue() {
|
|
|
this.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
|
|
|
}
|
|
|
/**
|
|
|
* @param {Date} date
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "formatDate",
|
|
|
value: function formatDate(date) {
|
|
|
return this.formatValue(date.getDate());
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "parse",
|
|
|
value: function parse(state) {
|
|
|
this._parsedValue = this.scanStringNumber(state);
|
|
|
this._numericValue = this.calculateNumericValue(this._parsedValue, this.maximalValue);
|
|
|
|
|
|
this._defineParsingState(this.maximalValue, state.isOver());
|
|
|
|
|
|
this._defineCleanValue();
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateDayPart;
|
|
|
}(AbstractSmartDateNumericPart);
|
|
|
|
|
|
SmartDateDayPart.MAXIMAL_VALUE_LOW_LIMIT = 28;
|
|
|
SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT = 31;
|
|
|
SmartDateDayPart.MAXIMAL_VALUE = SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT;
|
|
|
|
|
|
var SmartDateMonthPart =
|
|
|
/*#__PURE__*/
|
|
|
function (_AbstractSmartDateNum2) {
|
|
|
_inherits(SmartDateMonthPart, _AbstractSmartDateNum2);
|
|
|
|
|
|
function SmartDateMonthPart() {
|
|
|
_classCallCheck(this, SmartDateMonthPart);
|
|
|
|
|
|
return _possibleConstructorReturn(this, _getPrototypeOf(SmartDateMonthPart).call(this, SmartDateFormat.MONTH_PLACEHOLDER, 2));
|
|
|
}
|
|
|
/**
|
|
|
* @param {Date} date
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
|
|
|
_createClass(SmartDateMonthPart, [{
|
|
|
key: "formatDate",
|
|
|
value: function formatDate(date) {
|
|
|
return this.formatValue(date.getMonth() + 1);
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "parse",
|
|
|
value: function parse(state) {
|
|
|
this._parsedValue = this.scanStringNumber(state);
|
|
|
this._numericValue = this.calculateNumericValue(this._parsedValue, SmartDateMonthPart.MAXIMAL_VALUE);
|
|
|
|
|
|
this._defineParsingState(SmartDateMonthPart.MAXIMAL_VALUE, state.isOver());
|
|
|
|
|
|
this._defineCleanValue();
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateMonthPart;
|
|
|
}(AbstractSmartDateNumericPart);
|
|
|
|
|
|
SmartDateMonthPart.MAXIMAL_VALUE = 12;
|
|
|
|
|
|
var SmartDateYearPart =
|
|
|
/*#__PURE__*/
|
|
|
function (_AbstractSmartDateNum3) {
|
|
|
_inherits(SmartDateYearPart, _AbstractSmartDateNum3);
|
|
|
|
|
|
function SmartDateYearPart() {
|
|
|
_classCallCheck(this, SmartDateYearPart);
|
|
|
|
|
|
return _possibleConstructorReturn(this, _getPrototypeOf(SmartDateYearPart).call(this, SmartDateFormat.YEAR_PLACEHOLDER, 4));
|
|
|
}
|
|
|
/**
|
|
|
* @param {Date} date
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
|
|
|
_createClass(SmartDateYearPart, [{
|
|
|
key: "formatDate",
|
|
|
value: function formatDate(date) {
|
|
|
return this.formatValue(date.getFullYear());
|
|
|
}
|
|
|
/**
|
|
|
* @param {SmartDateCheckState} state
|
|
|
* @returns {Boolean}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "parse",
|
|
|
value: function parse(state) {
|
|
|
this._parsedValue = this.scanStringNumber(state);
|
|
|
this._numericValue = Number(this._parsedValue);
|
|
|
|
|
|
this._defineParsingState();
|
|
|
|
|
|
if (this._numericValue > SmartDateYearPart.MAXIMAL_VALUE) {
|
|
|
this._numericValue = SmartDateYearPart.MAXIMAL_VALUE;
|
|
|
}
|
|
|
|
|
|
if (this.isComplete() && this._numericValue < SmartDateYearPart.MINIMAL_VALUE) {
|
|
|
this._numericValue = SmartDateYearPart.MINIMAL_VALUE;
|
|
|
}
|
|
|
|
|
|
this._defineCleanValue();
|
|
|
}
|
|
|
}, {
|
|
|
key: "_defineParsingState",
|
|
|
value: function _defineParsingState() {
|
|
|
if (this._numericValue > 0 && this._parsedValue.length >= this._size) {
|
|
|
this._state = AbstractSmartDatePart.STATE_COMPLETE;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._state = AbstractSmartDatePart.STATE_INCOMPLETE;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_defineCleanValue",
|
|
|
value: function _defineCleanValue() {
|
|
|
if (this._numericValue > 0) {
|
|
|
this._cleanedValue = String(this._numericValue);
|
|
|
} else {
|
|
|
this._cleanedValue = '';
|
|
|
}
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateYearPart;
|
|
|
}(AbstractSmartDateNumericPart);
|
|
|
|
|
|
SmartDateYearPart.MINIMAL_VALUE = 1000;
|
|
|
SmartDateYearPart.MAXIMAL_VALUE = 9999;
|
|
|
|
|
|
var SmartDateParseState =
|
|
|
/*#__PURE__*/
|
|
|
function () {
|
|
|
function SmartDateParseState() {
|
|
|
_classCallCheck(this, SmartDateParseState);
|
|
|
|
|
|
this._value = '';
|
|
|
this._valueIndex = 0;
|
|
|
}
|
|
|
|
|
|
_createClass(SmartDateParseState, [{
|
|
|
key: "start",
|
|
|
value: function start(value) {
|
|
|
this._value = value;
|
|
|
this._valueIndex = 0;
|
|
|
}
|
|
|
}, {
|
|
|
key: "current",
|
|
|
value: function current() {
|
|
|
return this.isOver() ? '' : this._value[this._valueIndex];
|
|
|
}
|
|
|
}, {
|
|
|
key: "next",
|
|
|
value: function next() {
|
|
|
if (this.isOver()) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
this._valueIndex++;
|
|
|
return !this.isOver();
|
|
|
}
|
|
|
}, {
|
|
|
key: "isOver",
|
|
|
value: function isOver() {
|
|
|
return this._valueIndex >= this._value.length;
|
|
|
}
|
|
|
}, {
|
|
|
key: "value",
|
|
|
value: function value() {
|
|
|
return this._value;
|
|
|
}
|
|
|
}, {
|
|
|
key: "valueIndex",
|
|
|
value: function valueIndex() {
|
|
|
return this._valueIndex;
|
|
|
}
|
|
|
}, {
|
|
|
key: "setValueIndex",
|
|
|
value: function setValueIndex(index) {
|
|
|
if (this._valueIndex < index) {
|
|
|
this._valueIndex = index;
|
|
|
}
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateParseState;
|
|
|
}();
|
|
|
|
|
|
var SmartDateFormat =
|
|
|
/*#__PURE__*/
|
|
|
function () {
|
|
|
function SmartDateFormat(format) {
|
|
|
_classCallCheck(this, SmartDateFormat);
|
|
|
|
|
|
this._day = null;
|
|
|
this._month = null;
|
|
|
this._year = null;
|
|
|
this.loadFormat(format);
|
|
|
this._parseState = new SmartDateParseState();
|
|
|
}
|
|
|
|
|
|
_createClass(SmartDateFormat, [{
|
|
|
key: "loadFormat",
|
|
|
value: function loadFormat(format) {
|
|
|
var index = 0;
|
|
|
var lowFormat = format.toLowerCase();
|
|
|
this._format = format;
|
|
|
this._parts = [];
|
|
|
|
|
|
while (index < format.length) {
|
|
|
index = this._scanPart(index, format, lowFormat);
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_scanPart",
|
|
|
value: function _scanPart(index, format, lowFormat) {
|
|
|
switch (lowFormat[index]) {
|
|
|
case SmartDateFormat.DAY_ANCHOR:
|
|
|
return this._scanDay(index, lowFormat);
|
|
|
|
|
|
case SmartDateFormat.MONTH_ANCHOR:
|
|
|
return this._scanMonth(index, lowFormat);
|
|
|
|
|
|
case SmartDateFormat.YEAR_ANCHOR:
|
|
|
return this._scanYear(index, lowFormat);
|
|
|
}
|
|
|
|
|
|
return this._scanStatic(index, format, lowFormat);
|
|
|
}
|
|
|
}, {
|
|
|
key: "_scanDay",
|
|
|
value: function _scanDay(startIndex, lowFormat) {
|
|
|
this._checkLastIsStatic();
|
|
|
|
|
|
this._day = new SmartDateDayPart();
|
|
|
|
|
|
this._parts.push(this._day);
|
|
|
|
|
|
return this._avoidAnchor(SmartDateFormat.DAY_ANCHOR, startIndex, lowFormat);
|
|
|
}
|
|
|
}, {
|
|
|
key: "_scanMonth",
|
|
|
value: function _scanMonth(startIndex, lowFormat) {
|
|
|
this._checkLastIsStatic();
|
|
|
|
|
|
this._month = new SmartDateMonthPart();
|
|
|
|
|
|
this._parts.push(this._month);
|
|
|
|
|
|
return this._avoidAnchor(SmartDateFormat.MONTH_ANCHOR, startIndex, lowFormat);
|
|
|
}
|
|
|
}, {
|
|
|
key: "_scanYear",
|
|
|
value: function _scanYear(startIndex, lowFormat) {
|
|
|
this._checkLastIsStatic();
|
|
|
|
|
|
this._year = new SmartDateYearPart();
|
|
|
|
|
|
this._parts.push(this._year);
|
|
|
|
|
|
return this._avoidAnchor(SmartDateFormat.YEAR_ANCHOR, startIndex, lowFormat);
|
|
|
}
|
|
|
}, {
|
|
|
key: "_avoidAnchor",
|
|
|
value: function _avoidAnchor(anchor, startIndex, lowFormat) {
|
|
|
var endingIndex = startIndex;
|
|
|
|
|
|
while (endingIndex < lowFormat.length && lowFormat[endingIndex] === anchor) {
|
|
|
endingIndex++;
|
|
|
}
|
|
|
|
|
|
return endingIndex;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_checkLastIsStatic",
|
|
|
value: function _checkLastIsStatic() {
|
|
|
if (this._parts.length === 0) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (!this._parts[this._parts.length - 1].isStatic()) {
|
|
|
throw new Error('Dynamic date parts must be separated by static substrings');
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_scanStatic",
|
|
|
value: function _scanStatic(startIndex, format, lowFormat) {
|
|
|
var endingIndex = startIndex;
|
|
|
|
|
|
while (endingIndex < format.length && this._isStaticAnchorSymbol(lowFormat[endingIndex])) {
|
|
|
endingIndex++;
|
|
|
}
|
|
|
|
|
|
this._parts.push(new SmartDateStaticPart(format.substring(startIndex, endingIndex)));
|
|
|
|
|
|
return endingIndex;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_isStaticAnchorSymbol",
|
|
|
value: function _isStaticAnchorSymbol(symbol) {
|
|
|
return symbol !== SmartDateFormat.DAY_ANCHOR && symbol !== SmartDateFormat.MONTH_ANCHOR && symbol !== SmartDateFormat.YEAR_ANCHOR;
|
|
|
}
|
|
|
}, {
|
|
|
key: "getPlaceHolder",
|
|
|
value: function getPlaceHolder() {
|
|
|
var placeHolder = '';
|
|
|
|
|
|
for (var i = 0; i < this._parts.length; i++) {
|
|
|
placeHolder += this._parts[i].placeHolder();
|
|
|
}
|
|
|
|
|
|
return placeHolder;
|
|
|
}
|
|
|
/**
|
|
|
* @param {Date} date
|
|
|
* @returns {String}
|
|
|
*/
|
|
|
|
|
|
}, {
|
|
|
key: "formatDate",
|
|
|
value: function formatDate(date) {
|
|
|
var formattedDate = '';
|
|
|
|
|
|
for (var i = 0; i < this._parts.length; i++) {
|
|
|
if (this._parts[i].isStatic()) {
|
|
|
formattedDate += this._parts[i].placeHolder();
|
|
|
} else {
|
|
|
formattedDate += this._parts[i].formatDate(date);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return formattedDate;
|
|
|
}
|
|
|
}, {
|
|
|
key: "parse",
|
|
|
value: function parse(value, autocomplete) {
|
|
|
this._resetParseState();
|
|
|
|
|
|
this._parseState.start(value);
|
|
|
|
|
|
this._parseParts(autocomplete);
|
|
|
|
|
|
this._correctDate();
|
|
|
}
|
|
|
}, {
|
|
|
key: "_resetParseState",
|
|
|
value: function _resetParseState() {
|
|
|
for (var i = 0; i < this._parts.length; i++) {
|
|
|
this._parts[i].resetState();
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_parseParts",
|
|
|
value: function _parseParts(autocomplete) {
|
|
|
var index = 0;
|
|
|
|
|
|
while (index < this._parts.length && (autocomplete || !this._parseState.isOver())) {
|
|
|
this._parts[index].parse(this._parseState);
|
|
|
|
|
|
if (!this._parts[index].isComplete()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
index++;
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_correctDate",
|
|
|
value: function _correctDate() {
|
|
|
if (!this._day.isComplete() || !this._month.isComplete()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._day.setMaximalValue(this._getMonthSize(this._month.numericValue() - 1, !this._year.isComplete() || this._isLeaPYear(this._year.numericValue())));
|
|
|
}
|
|
|
}, {
|
|
|
key: "getParsedDate",
|
|
|
value: function getParsedDate() {
|
|
|
if (!this.isComplete()) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
return new Date(this._year.numericValue(), this._month.numericValue() - 1, this._day.numericValue());
|
|
|
}
|
|
|
}, {
|
|
|
key: "_getMonthSize",
|
|
|
value: function _getMonthSize(monthIndex, isLeapYear) {
|
|
|
if (monthIndex < 0 || monthIndex >= SmartDateMonthPart.MAXIMAL_VALUE) {
|
|
|
return SmartDateMonthPart.MAXIMAL_VALUE;
|
|
|
}
|
|
|
|
|
|
if (monthIndex === 1 && isLeapYear) {
|
|
|
// February
|
|
|
return SmartDateFormat.BASIC_MONTH_SIZES[monthIndex] + 1;
|
|
|
}
|
|
|
|
|
|
return SmartDateFormat.BASIC_MONTH_SIZES[monthIndex];
|
|
|
}
|
|
|
}, {
|
|
|
key: "_isLeaPYear",
|
|
|
value: function _isLeaPYear(year) {
|
|
|
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
|
|
|
}
|
|
|
}, {
|
|
|
key: "getCorrectedValue",
|
|
|
value: function getCorrectedValue() {
|
|
|
var index = 0;
|
|
|
var value = '';
|
|
|
|
|
|
while (index < this._parts.length && !this._parts[index].isNoState()) {
|
|
|
value += this._parts[index].cleanedValue();
|
|
|
index++;
|
|
|
}
|
|
|
|
|
|
return value;
|
|
|
}
|
|
|
}, {
|
|
|
key: "isComplete",
|
|
|
value: function isComplete() {
|
|
|
return this._parts[this._parts.length - 1].isComplete();
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateFormat;
|
|
|
}();
|
|
|
|
|
|
SmartDateFormat.DAY_ANCHOR = 'd';
|
|
|
SmartDateFormat.DAY_PLACEHOLDER = 'ДД';
|
|
|
SmartDateFormat.MONTH_ANCHOR = 'm';
|
|
|
SmartDateFormat.MONTH_PLACEHOLDER = 'ММ';
|
|
|
SmartDateFormat.YEAR_ANCHOR = 'y';
|
|
|
SmartDateFormat.YEAR_PLACEHOLDER = 'ГГГГ';
|
|
|
SmartDateFormat.BASIC_MONTH_SIZES = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
|
|
|
|
|
|
var SmartDateField =
|
|
|
/*#__PURE__*/
|
|
|
function () {
|
|
|
function SmartDateField(field, options) {
|
|
|
_classCallCheck(this, SmartDateField);
|
|
|
|
|
|
this._dateYmdParser = new RegExp('^([0-9]{4})[,\._\/\-]+([0-9]{1,2})[,\._\/\-]+([0-9]{1,2})$');
|
|
|
this._dateDmyParser = new RegExp('^([0-9]{1,2})[,\._\/\-]+([0-9]{1,2})[,\._\/\-]+([0-9]{4})$');
|
|
|
|
|
|
this._loadOptions(options);
|
|
|
|
|
|
this._formatter = new SmartDateFormat(this._format, this._minimalDate, this._maximalDate);
|
|
|
this._lastCorrectValue = this._defaultDate === null ? null : this._formatter.formatDate(this._defaultDate);
|
|
|
|
|
|
this._initField(field);
|
|
|
|
|
|
this._subscribeEvents();
|
|
|
}
|
|
|
|
|
|
_createClass(SmartDateField, [{
|
|
|
key: "_loadDefaultOptions",
|
|
|
value: function _loadDefaultOptions() {
|
|
|
this._format = 'd.m.y';
|
|
|
this._minimalDate = new Date(1900, 0, 1);
|
|
|
this._maximalDate = new Date(2099, 11, 31);
|
|
|
this._defaultDate = null;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_loadOptions",
|
|
|
value: function _loadOptions(options) {
|
|
|
this._loadDefaultOptions();
|
|
|
|
|
|
if (_typeof(options) !== 'object' || options == null) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (typeof options.format === 'string' && options.format.indexOf('d') >= 0 && options.format.indexOf('m') >= 0 && options.format.indexOf('y') >= 0) {
|
|
|
this._format = options.format;
|
|
|
}
|
|
|
|
|
|
if (typeof options.minimal !== 'undefined') {
|
|
|
var date = this._parseDateValue(options.minimal);
|
|
|
|
|
|
this._minimalDate = date;
|
|
|
}
|
|
|
|
|
|
if (typeof options.maximal !== 'undefined') {
|
|
|
var _date = this._parseDateValue(options.maximal);
|
|
|
|
|
|
this._maximalDate = _date;
|
|
|
}
|
|
|
|
|
|
if (typeof options["default"] !== 'undefined') {
|
|
|
var _date2 = this._parseDateValue(options["default"]);
|
|
|
|
|
|
this._defaultDate = _date2;
|
|
|
}
|
|
|
|
|
|
this._correctDateOptions();
|
|
|
}
|
|
|
}, {
|
|
|
key: "_correctDateOptions",
|
|
|
value: function _correctDateOptions() {
|
|
|
if (this._minimalDate.valueOf() > this._maximalDate.valueOf()) {
|
|
|
var temporaryDate = this._minimalDate;
|
|
|
this._minimalDate = this._maximalDate;
|
|
|
this._maximalDate = temporaryDate;
|
|
|
}
|
|
|
|
|
|
if (this._defaultDate === null) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (this._defaultDate.valueOf() < this._minimalDate.valueOf()) {
|
|
|
this._defaultDate = this._minimalDate;
|
|
|
}
|
|
|
|
|
|
if (this._defaultDate.valueOf() > this._maximalDate.valueOf()) {
|
|
|
this._defaultDate = this._maximalDate;
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_parseDateValue",
|
|
|
value: function _parseDateValue(date) {
|
|
|
if (_typeof(date) === 'object' && date !== null && date instanceof Date) {
|
|
|
return date;
|
|
|
}
|
|
|
|
|
|
if (typeof date !== 'string' || date.trim() === '') {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
var parsed = this._dateYmdParser.exec(date);
|
|
|
|
|
|
if (parsed !== null) {
|
|
|
return new Date(Number(parsed[1]), Number(parsed[2]) - 1, Number(parsed[3]));
|
|
|
}
|
|
|
|
|
|
parsed = this._dateDmyParser.exec(date);
|
|
|
|
|
|
if (parsed === null) {
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
return new Date(Number(parsed[3]), Number(parsed[2]) - 1, Number(parsed[1]));
|
|
|
}
|
|
|
}, {
|
|
|
key: "_initField",
|
|
|
value: function _initField(field) {
|
|
|
this._field = field;
|
|
|
this._field.placeholder = this._formatter.getPlaceHolder();
|
|
|
|
|
|
if (this._isEmptyValue(this._field.value)) {
|
|
|
this._field.value = this._defaultDate === null ? '' : this._formatter.formatDate(this._defaultDate);
|
|
|
} else {
|
|
|
this.correctValue(true);
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "_subscribeEvents",
|
|
|
value: function _subscribeEvents() {
|
|
|
var _this = this;
|
|
|
|
|
|
var correct = function correct(event) {
|
|
|
if (event === null || event.type !== 'keyup') {
|
|
|
_this.correctValue(true);
|
|
|
}
|
|
|
|
|
|
if (_this._isServiceCode(event.keyCode)) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (event.keyCode === 27) {
|
|
|
// Escape
|
|
|
_this.returnLastCorrectValue();
|
|
|
}
|
|
|
|
|
|
_this.correctValue(true);
|
|
|
};
|
|
|
|
|
|
this._field.addEventListener('change', correct);
|
|
|
|
|
|
this._field.addEventListener('keyup', correct);
|
|
|
|
|
|
this._field.addEventListener('blur', function () {
|
|
|
_this.correctValue(true);
|
|
|
|
|
|
_this.returnLastCorrectValue();
|
|
|
});
|
|
|
}
|
|
|
}, {
|
|
|
key: "_isServiceCode",
|
|
|
value: function _isServiceCode(code) {
|
|
|
return code === 8
|
|
|
/* backspace */
|
|
|
|| code === 46
|
|
|
/* delete */
|
|
|
|| code === 16
|
|
|
/* shift */
|
|
|
|| code === 17
|
|
|
/* shift */
|
|
|
|| code === 18
|
|
|
/* shift */
|
|
|
|| code === 20
|
|
|
/* caps lock */
|
|
|
|| code === 35
|
|
|
/* end */
|
|
|
|| code === 36
|
|
|
/* home */
|
|
|
|| code === 37
|
|
|
/* left */
|
|
|
|| code === 39
|
|
|
/* right */
|
|
|
|| code === 46
|
|
|
/* delete */
|
|
|
;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_isEmptyValue",
|
|
|
value: function _isEmptyValue(value) {
|
|
|
return value.trim() === '';
|
|
|
}
|
|
|
}, {
|
|
|
key: "getDefaultValue",
|
|
|
value: function getDefaultValue() {
|
|
|
return this._defaultDate === null ? '' : this._formatter.formatDate(this._defaultDate);
|
|
|
}
|
|
|
}, {
|
|
|
key: "correctValue",
|
|
|
value: function correctValue(autocomplete) {
|
|
|
this._formatter.parse(this._field.value, autocomplete);
|
|
|
|
|
|
var parsedValue = this._getLimitedParsedValue();
|
|
|
|
|
|
if (this._formatter.isComplete()) {
|
|
|
this._lastCorrectValue = parsedValue;
|
|
|
}
|
|
|
|
|
|
if (this._field.value === parsedValue) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._setValueToFieled(parsedValue);
|
|
|
}
|
|
|
}, {
|
|
|
key: "setValue",
|
|
|
value: function setValue(value) {
|
|
|
var date = this._parseDateValue(value);
|
|
|
|
|
|
if (date === null || date.valueOf() < this._minimalDate.valueOf() || date.valueOf() > this._maximalDate.valueOf()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
this._lastCorrectValue = this._formatter.formatDate(date);
|
|
|
this._field.value = this._lastCorrectValue;
|
|
|
}
|
|
|
}, {
|
|
|
key: "_getLimitedParsedValue",
|
|
|
value: function _getLimitedParsedValue() {
|
|
|
if (!this._formatter.isComplete()) {
|
|
|
return this._formatter.getCorrectedValue();
|
|
|
}
|
|
|
|
|
|
var date = this._formatter.getParsedDate();
|
|
|
|
|
|
if (date.valueOf() < this._minimalDate.valueOf()) {
|
|
|
return this._formatter.formatDate(this._minimalDate);
|
|
|
} else if (date.valueOf() > this._maximalDate.valueOf()) {
|
|
|
return this._formatter.formatDate(this._maximalDate);
|
|
|
}
|
|
|
|
|
|
return this._formatter.getCorrectedValue();
|
|
|
}
|
|
|
}, {
|
|
|
key: "_setValueToFieled",
|
|
|
value: function _setValueToFieled(newValue) {
|
|
|
var position = this._field.selectionStart;
|
|
|
var isAtEnd = position === this._field.value.length;
|
|
|
this._field.value = newValue;
|
|
|
|
|
|
if (!isAtEnd && position < this._field.value.length) {
|
|
|
this._field.selectionStart = position;
|
|
|
this._field.selectionEnd = position;
|
|
|
}
|
|
|
}
|
|
|
}, {
|
|
|
key: "returnLastCorrectValue",
|
|
|
value: function returnLastCorrectValue() {
|
|
|
if (this._lastCorrectValue !== null) {
|
|
|
this._field.value = this._lastCorrectValue;
|
|
|
}
|
|
|
}
|
|
|
}]);
|
|
|
|
|
|
return SmartDateField;
|
|
|
}();
|
|
|
|
|
|
SmartDateField.initBy = function (id) {
|
|
|
return SmartDateField.initFor(document.getElementById(id));
|
|
|
};
|
|
|
|
|
|
SmartDateField.initFor = function (field, options) {
|
|
|
if (_typeof(field) !== 'object' || field === null || field.tagName.toLowerCase() !== 'input' || field.type.toLowerCase() !== 'text') {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (_typeof(field._smartDate) === 'object' && field._smartDate !== null && field._smartDate instanceof SmartDateField) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
field._smartDate = new SmartDateField(field, options);
|
|
|
};
|
|
|
|
|
|
jQuery.fn.smartdate = function (options) {
|
|
|
var collection = [];
|
|
|
var field = null;
|
|
|
|
|
|
for (var i = 0; i < this.length; i++) {
|
|
|
field = SmartDateField.initFor(this[i], options);
|
|
|
|
|
|
if (field !== null) {
|
|
|
collection.push(field);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return jQuery(this);
|
|
|
};
|
|
|
|
|
|
jQuery.fn.setDateValue = function (value) {
|
|
|
for (var i = 0; i < this.length; i++) {
|
|
|
if (_typeof(this[i]._smartDate) === 'object' && this[i]._smartDate !== null && this[i]._smartDate instanceof SmartDateField) {
|
|
|
this[i]._smartDate.setValue(value);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return jQuery(this);
|
|
|
};
|