+Фильтр для поля для ввода корректных дат

es6/smart-date.js

@@ -0,0 +1,997 @@
+
+class AbstractSmartDatePart
+{
+    constructor(placeholder, isStatic)
+    {
+        this._state = AbstractSmartDatePart.STATE_NONE;
+        this._cleanedValue = '';
+        this._parsedValue = '';
+        
+        this._scanned = '';
+        this._placeholder = placeholder;
+        this._static = isStatic;
+    }
+    
+    state()
+    {
+        return this._state;
+    }
+    
+    isNoState()
+    {
+        return this._state === AbstractSmartDatePart.STATE_NONE;
+    }
+    
+    isIncomplete()
+    {
+        return this._state === AbstractSmartDatePart.STATE_INCOMPLETE;
+    }
+    
+    isComplete()
+    {
+        return this._state === AbstractSmartDatePart.STATE_COMPLETE;
+    }
+    
+    resetState()
+    {
+        this._state = AbstractSmartDatePart.STATE_NONE;
+    }
+    
+    cleanedValue()
+    {
+        return this._cleanedValue;
+    }
+    
+    parsedValue()
+    {
+        return this._parsedValue;
+    }
+    
+    placeHolder()
+    {
+        return this._placeholder;
+    }
+    
+    isStatic()
+    {
+        return this._static;
+    }
+    
+    _isNumericSymbol(symbol)
+    {
+        return '0' <= symbol && symbol <= '9';
+    }
+
+    /**
+     * @param {SmartDateCheckState} state
+     * @returns {Boolean}
+     */
+    check(state)
+    {
+        return false;
+    }
+};
+
+AbstractSmartDatePart.STATE_NONE = 0;
+AbstractSmartDatePart.STATE_INCOMPLETE = 1;
+AbstractSmartDatePart.STATE_COMPLETE = 2;
+
+class SmartDateStaticPart extends AbstractSmartDatePart
+{
+    constructor(placeholder)
+    {
+        super(placeholder, true);
+        this._cleanedValue = placeholder;
+    }
+    
+    /**
+     * @param {SmartDateCheckState} state
+     * @returns {Boolean}
+     */
+    parse(state)
+    {
+        let value = state.value();
+        let 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;
+    }
+}
+
+class AbstractSmartDateNumericPart extends AbstractSmartDatePart
+{
+    constructor(placeholder, size)
+    {
+        super(placeholder, false);
+        this._numericValue = 0;
+        this._size = size;
+    }
+    
+    numericValue()
+    {
+        return this._numericValue;
+    }
+    
+    /**
+     * @param {Date} date
+     * @returns {String}
+     */
+    formatDate(date)
+    {
+        return '';
+    }
+    
+    formatValue(value)
+    {
+        let 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;
+    }
+    
+    _correctValue(value)
+    {
+        return Math.round(value);
+    }
+    
+    /**
+     * @param {SmartDateCheckState} state
+     * @returns {String}
+     */
+    scanStringNumber(state)
+    {
+        let index = state.valueIndex();
+        let value = state.value();
+        
+        while (index < value.length && this._isNumericSymbol(value[index])) {
+            index++;
+        }
+        
+        let stringValue = value.substring(state.valueIndex(), index);
+        
+        state.setValueIndex(index);
+        
+        return stringValue;
+    }
+    
+    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
+     */
+    scanValue(state, maximalValue)
+    {
+        let index = state.valueIndex();
+        let value = state.value();
+        
+        let numericValue = 0;
+        
+        while (index < value.length && this._isNumericSymbol(value[index]) && numericValue < maximalValue) {
+            numericValue = numericValue * 10 + Number(value[index]);
+            index++;
+        }
+        
+        if (numericValue > maximalValue) {
+            index--;
+        }
+        
+        let stringValue = value.substring(state.valueIndex(), index);
+        
+        state.setValueIndex(index);
+        
+        return stringValue;
+    }
+    
+    _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;
+    }
+    
+    _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);
+        }
+    }
+}
+
+class SmartDateDayPart extends AbstractSmartDateNumericPart
+{
+    constructor()
+    {
+        super(SmartDateFormat.DAY_PLACEHOLDER, 2);
+        this.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
+    }
+    
+    resetState()
+    {
+        super.resetState();
+        this.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
+    }
+    
+    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();
+    }
+    
+    resetMaximalValue()
+    {
+        this.maximalValue = SmartDateDayPart.MAXIMAL_VALUE;
+    }
+    
+    /**
+     * @param {Date} date
+     * @returns {String}
+     */
+    formatDate(date)
+    {
+        return this.formatValue(date.getDate());
+    }
+
+    /**
+     * @param {SmartDateCheckState} state
+     */
+    parse(state)
+    {
+        this._parsedValue = this.scanStringNumber(state);
+        this._numericValue = this.calculateNumericValue(this._parsedValue, this.maximalValue);
+        
+        this._defineParsingState(this.maximalValue, state.isOver());
+        this._defineCleanValue();
+    }
+}
+
+SmartDateDayPart.MAXIMAL_VALUE_LOW_LIMIT = 28;
+SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT = 31;
+
+SmartDateDayPart.MAXIMAL_VALUE = SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT;
+
+class SmartDateMonthPart extends AbstractSmartDateNumericPart
+{
+    constructor()
+    {
+        super(SmartDateFormat.MONTH_PLACEHOLDER, 2);
+    }
+    
+    /**
+     * @param {Date} date
+     * @returns {String}
+     */
+    formatDate(date)
+    {
+        return this.formatValue(date.getMonth() + 1);
+    }
+
+    /**
+     * @param {SmartDateCheckState} state
+     */
+    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();
+    }
+}
+
+SmartDateMonthPart.MAXIMAL_VALUE = 12;
+
+class SmartDateYearPart extends AbstractSmartDateNumericPart
+{
+    constructor()
+    {
+        super(SmartDateFormat.YEAR_PLACEHOLDER, 4);
+    }
+    
+    /**
+     * @param {Date} date
+     * @returns {String}
+     */
+    formatDate(date)
+    {
+        return this.formatValue(date.getFullYear());
+    }
+
+    /**
+     * @param {SmartDateCheckState} state
+     * @returns {Boolean}
+     */
+    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();
+    }
+    
+    _defineParsingState()
+    {
+        if (this._numericValue > 0 && this._parsedValue.length >= this._size) {
+            this._state = AbstractSmartDatePart.STATE_COMPLETE;
+            return;
+        }
+        
+        this._state = AbstractSmartDatePart.STATE_INCOMPLETE;
+    }
+    
+    _defineCleanValue()
+    {
+        if (this._numericValue > 0) {
+            this._cleanedValue = String(this._numericValue);
+        }
+        else {
+            this._cleanedValue = '';
+        }
+    }
+}
+
+SmartDateYearPart.MINIMAL_VALUE = 1000;
+SmartDateYearPart.MAXIMAL_VALUE = 9999;
+
+class SmartDateParseState
+{
+    constructor()
+    {
+        this._value = '';
+        this._valueIndex = 0;
+    }
+    
+    start(value)
+    {
+        this._value = value;
+        this._valueIndex = 0;
+    }
+    
+    current()
+    {
+        return this.isOver() ? '' : this._value[this._valueIndex];
+    }
+    
+    next()
+    {
+        if (this.isOver()) {
+            return false;
+        }
+        
+        this._valueIndex++;
+        
+        return !this.isOver();
+    }
+    
+    isOver()
+    {
+        return this._valueIndex >= this._value.length;
+    }
+    
+    value()
+    {
+        return this._value;
+    }
+    
+    valueIndex()
+    {
+        return this._valueIndex;
+    }
+    
+    setValueIndex(index)
+    {
+        if (this._valueIndex < index) {
+            this._valueIndex = index;
+        }
+    }
+}
+
+class SmartDateFormat
+{
+    constructor(format)
+    {
+        this._day = null;
+        this._month = null;
+        this._year = null;
+        
+        this.loadFormat(format);
+        
+        this._parseState = new SmartDateParseState();
+    }
+    
+    loadFormat(format)
+    {
+        let index = 0;
+        let lowFormat = format.toLowerCase();
+        
+        this._format = format;
+        this._parts = [];
+        
+        while (index < format.length) {
+            index = this._scanPart(index, format, lowFormat);
+        }
+    }
+    
+    _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);
+    }
+    
+    _scanDay(startIndex, lowFormat)
+    {
+        this._checkLastIsStatic();
+        
+        this._day = new SmartDateDayPart();
+        
+        this._parts.push(this._day);
+        
+        return this._avoidAnchor(SmartDateFormat.DAY_ANCHOR, startIndex, lowFormat);
+    }
+    
+    _scanMonth(startIndex, lowFormat)
+    {
+        this._checkLastIsStatic();
+        
+        this._month = new SmartDateMonthPart();
+        
+        this._parts.push(this._month);
+        
+        return this._avoidAnchor(SmartDateFormat.MONTH_ANCHOR, startIndex, lowFormat);
+    }
+    
+    _scanYear(startIndex, lowFormat)
+    {
+        this._checkLastIsStatic();
+        
+        this._year = new SmartDateYearPart();
+        
+        this._parts.push(this._year);
+        
+        return this._avoidAnchor(SmartDateFormat.YEAR_ANCHOR, startIndex, lowFormat);
+    }
+    
+    _avoidAnchor(anchor, startIndex, lowFormat)
+    {
+        let endingIndex = startIndex;
+        
+        while (endingIndex < lowFormat.length && lowFormat[endingIndex] === anchor) {
+            endingIndex++;
+        }
+        
+        return endingIndex;
+    }
+    
+    _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');
+        }
+    }
+    
+    _scanStatic(startIndex, format, lowFormat)
+    {
+        let endingIndex = startIndex;
+        
+        while (endingIndex < format.length && this._isStaticAnchorSymbol(lowFormat[endingIndex])) {
+            endingIndex++;
+        }
+        
+        this._parts.push(new SmartDateStaticPart(format.substring(startIndex, endingIndex)));
+        
+        return endingIndex;
+    }
+    
+    _isStaticAnchorSymbol(symbol)
+    {
+        return symbol !== SmartDateFormat.DAY_ANCHOR
+            && symbol !== SmartDateFormat.MONTH_ANCHOR
+            && symbol !== SmartDateFormat.YEAR_ANCHOR;
+    }
+    
+    getPlaceHolder()
+    {
+        let placeHolder = '';
+        
+        for (let i = 0; i < this._parts.length; i++) {
+            placeHolder += this._parts[i].placeHolder();
+        }
+        
+        return placeHolder;
+    }
+    
+    /**
+     * @param {Date} date
+     * @returns {String}
+     */
+    formatDate(date)
+    {
+        var formattedDate = '';
+        
+        for (let 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;
+    }
+    
+    parse(value, autocomplete)
+    {
+        this._resetParseState();
+        
+        this._parseState.start(value);
+        
+        this._parseParts(autocomplete);
+        
+        this._correctDate();
+    }
+    
+    _resetParseState()
+    {
+        for (let i = 0; i < this._parts.length; i++) {
+            this._parts[i].resetState();
+        }
+    }
+    
+    _parseParts(autocomplete)
+    {
+        let index = 0;
+        
+        while (index < this._parts.length && (autocomplete || !this._parseState.isOver())) {
+            this._parts[index].parse(this._parseState);
+            
+            if (!this._parts[index].isComplete()) {
+                return;
+            }
+            
+            index++;
+        }
+    }
+    
+    _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())));
+    }
+    
+    getParsedDate()
+    {
+        if (!this.isComplete()) {
+            return null;
+        }
+        
+        return new Date(this._year.numericValue(), this._month.numericValue() - 1, this._day.numericValue());
+    }
+    
+    _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];
+    }
+    
+    _isLeaPYear(year)
+    {
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    }
+    
+    getCorrectedValue()
+    {
+        let index = 0;
+        let value = '';
+        
+        while (index < this._parts.length && !this._parts[index].isNoState()) {
+            value += this._parts[index].cleanedValue();
+            index++;
+        }
+        
+        return value;
+    }
+    
+    isComplete()
+    {
+        return this._parts[this._parts.length - 1].isComplete();
+    }
+}
+
+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];
+class SmartDateField
+{
+    constructor(field, options)
+    {
+        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();
+    }
+    
+    
+    _loadDefaultOptions()
+    {
+        this._format = 'd.m.y';
+        this._minimalDate = new Date(1900, 0, 1);
+        this._maximalDate = new Date(2099, 11, 31);
+        this._defaultDate = null;
+    }
+    
+    _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') {
+            let date = this._parseDateValue(options.minimal);
+            this._minimalDate = date;
+        }
+        
+        if (typeof(options.maximal) !== 'undefined') {
+            let date = this._parseDateValue(options.maximal);
+            this._maximalDate = date;
+        }
+        
+        if (typeof(options.default) !== 'undefined') {
+            let date = this._parseDateValue(options.default);
+            this._defaultDate = date;
+        }
+        
+        this._correctDateOptions();
+    }
+    
+    _correctDateOptions()
+    {
+        if (this._minimalDate.valueOf() > this._maximalDate.valueOf()) {
+            let 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;
+        }
+    }
+    
+    _parseDateValue(date)
+    {
+        if (typeof(date) === 'object' && date !== null && date instanceof Date) {
+            return date;
+        }
+        
+        if (typeof(date) !== 'string' || date.trim() === '') {
+            return null;
+        }
+        
+        let 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]));
+    }
+ 
+    _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);
+        }
+    }
+    
+    _subscribeEvents()
+    {
+        let _this = this;
+        
+        let correct = function (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();
+        });
+    }
+    
+    _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 */;
+    }
+    
+    _isEmptyValue(value)
+    {
+        return value.trim() === '';
+    }
+    
+    getDefaultValue()
+    {
+        return this._defaultDate === null ? '' : this._formatter.formatDate(this._defaultDate);
+    }
+    
+    correctValue(autocomplete)
+    {
+        this._formatter.parse(this._field.value, autocomplete);
+        
+        let parsedValue = this._getLimitedParsedValue();
+        
+        if (this._formatter.isComplete()) {
+            this._lastCorrectValue = parsedValue;
+        }
+        
+        if (this._field.value === parsedValue) {
+            return;
+        }
+        
+        this._setValueToFieled(parsedValue);
+    }
+    
+    setValue(value)
+    {
+        let 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;
+    }
+    
+    _getLimitedParsedValue()
+    {
+        if (!this._formatter.isComplete()) {
+            return this._formatter.getCorrectedValue();
+        }
+        
+        let 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();
+    }
+    
+    _setValueToFieled(newValue)
+    {
+        let position = this._field.selectionStart;
+        let 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;
+        }
+    }
+    
+    returnLastCorrectValue()
+    {
+        if (this._lastCorrectValue !== null) {
+            this._field.value = this._lastCorrectValue;
+        }
+    }
+}
+
+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) {
+    let collection = [];
+    let field = null;
+
+    for (let 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 (let 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);
+};

es6/smart-date.min.js

@@ -0,0 +1 @@
+class AbstractSmartDatePart{constructor(a,b){this._state=AbstractSmartDatePart.STATE_NONE,this._cleanedValue="",this._parsedValue="",this._scanned="",this._placeholder=a,this._static=b}state(){return this._state}isNoState(){return this._state===AbstractSmartDatePart.STATE_NONE}isIncomplete(){return this._state===AbstractSmartDatePart.STATE_INCOMPLETE}isComplete(){return this._state===AbstractSmartDatePart.STATE_COMPLETE}resetState(){this._state=AbstractSmartDatePart.STATE_NONE}cleanedValue(){return this._cleanedValue}parsedValue(){return this._parsedValue}placeHolder(){return this._placeholder}isStatic(){return this._static}_isNumericSymbol(a){return"0"<=a&&"9">=a}check(a){return!1}}AbstractSmartDatePart.STATE_NONE=0,AbstractSmartDatePart.STATE_INCOMPLETE=1,AbstractSmartDatePart.STATE_COMPLETE=2;class SmartDateStaticPart extends AbstractSmartDatePart{constructor(a){super(a,!0),this._cleanedValue=a}parse(a){let b=a.value(),c=a.valueIndex();for(;c<b.length&&!this._isNumericSymbol(b[c]);)c++;return this._parsedValue=b.substring(a.valueIndex(),c),this._state=AbstractSmartDatePart.STATE_COMPLETE,a.setValueIndex(c),!0}}class AbstractSmartDateNumericPart extends AbstractSmartDatePart{constructor(a,b){super(a,!1),this._numericValue=0,this._size=b}numericValue(){return this._numericValue}formatDate(a){return""}formatValue(a){let b=this._correctValue(a)+"";return"0"==b?b:b.length>this._size?b.substring(0,this._size):b.length<this._size?b.padStart(this._size,"0"):b}_correctValue(a){return Math.round(a)}scanStringNumber(a){let b=a.valueIndex(),c=a.value();for(;b<c.length&&this._isNumericSymbol(c[b]);)b++;let d=c.substring(a.valueIndex(),b);return a.setValueIndex(b),d}calculateNumericValue(a,b){for(var c=0,d=0,e=0;c<a.length&&0===a[c];)c++;for(d=c;d<a.length&&e<b;)e=10*e+ +a[d],d++;return e>b&&d--,+a.substring(c,d)}scanValue(a,b){let c=a.valueIndex(),d=a.value(),e=0;for(;c<d.length&&this._isNumericSymbol(d[c])&&e<b;)e=10*e+ +d[c],c++;e>b&&c--;let f=d.substring(a.valueIndex(),c);return a.setValueIndex(c),f}_defineParsingState(a,b){return 0<this._numericValue&&(this._parsedValue.length>=this._size||!b)?void(this._state=AbstractSmartDatePart.STATE_COMPLETE):10*this._numericValue>a?void(this._state=AbstractSmartDatePart.STATE_COMPLETE):void(this._state=AbstractSmartDatePart.STATE_INCOMPLETE)}_defineCleanValue(){return this._cleanedValue="",this.isNoState()?void 0:this.isComplete()?void(this._cleanedValue=this.formatValue(this._numericValue)):void(0<this._parsedValue.length&&(this._cleanedValue=this._numericValue+""))}}class SmartDateDayPart extends AbstractSmartDateNumericPart{constructor(){super(SmartDateFormat.DAY_PLACEHOLDER,2),this.maximalValue=SmartDateDayPart.MAXIMAL_VALUE}resetState(){super.resetState(),this.maximalValue=SmartDateDayPart.MAXIMAL_VALUE}setMaximalValue(a){a!=a||a<SmartDateDayPart.MAXIMAL_VALUE_LOW_LIMIT||SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT<a||(this.maximalValue=a,this._numericValue<=this.maximalValue||(this._numericValue=this.maximalValue,this._defineCleanValue()))}resetMaximalValue(){this.maximalValue=SmartDateDayPart.MAXIMAL_VALUE}formatDate(a){return this.formatValue(a.getDate())}parse(a){this._parsedValue=this.scanStringNumber(a),this._numericValue=this.calculateNumericValue(this._parsedValue,this.maximalValue),this._defineParsingState(this.maximalValue,a.isOver()),this._defineCleanValue()}}SmartDateDayPart.MAXIMAL_VALUE_LOW_LIMIT=28,SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT=31,SmartDateDayPart.MAXIMAL_VALUE=SmartDateDayPart.MAXIMAL_VALUE_HIGH_LIMIT;class SmartDateMonthPart extends AbstractSmartDateNumericPart{constructor(){super(SmartDateFormat.MONTH_PLACEHOLDER,2)}formatDate(a){return this.formatValue(a.getMonth()+1)}parse(a){this._parsedValue=this.scanStringNumber(a),this._numericValue=this.calculateNumericValue(this._parsedValue,SmartDateMonthPart.MAXIMAL_VALUE),this._defineParsingState(SmartDateMonthPart.MAXIMAL_VALUE,a.isOver()),this._defineCleanValue()}}SmartDateMonthPart.MAXIMAL_VALUE=12;class SmartDateYearPart extends AbstractSmartDateNumericPart{constructor(){super(SmartDateFormat.YEAR_PLACEHOLDER,4)}formatDate(a){return this.formatValue(a.getFullYear())}parse(a){this._parsedValue=this.scanStringNumber(a),this._numericValue=+this._parsedValue,this._defineParsingState(),this._numericValue>SmartDateYearPart.MAXIMAL_VALUE&&(this._numericValue=SmartDateYearPart.MAXIMAL_VALUE),this.isComplete()&&this._numericValue<SmartDateYearPart.MINIMAL_VALUE&&(this._numericValue=SmartDateYearPart.MINIMAL_VALUE),this._defineCleanValue()}_defineParsingState(){return 0<this._numericValue&&this._parsedValue.length>=this._size?void(this._state=AbstractSmartDatePart.STATE_COMPLETE):void(this._state=AbstractSmartDatePart.STATE_INCOMPLETE)}_defineCleanValue(){this._cleanedValue=0<this._numericValue?this._numericValue+"":""}}SmartDateYearPart.MINIMAL_VALUE=1e3,SmartDateYearPart.MAXIMAL_VALUE=9999;class SmartDateParseState{constructor(){this._value="",this._valueIndex=0}start(a){this._value=a,this._valueIndexLine truncated