smart-date-js/es6/smart-date.js

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);

            if (!_this._isEmptyValue(_this._field.value)) {
                _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._setValueToField(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();
    }
    
    _setValueToField(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);
};