@progress/kendo-dateinputs-common 0.1.0 → 0.2.0-dev.202301061341

package/dist/es2015/common/dateobject.js

@@ -0,0 +1,1137 @@
+import { addMonths, cloneDate, createDate, isEqual, getDate, lastDayOfMonth } from '@progress/kendo-date-math';
+import { Mask } from './mask';
+import { dateSymbolMap, padZero, unpadZero } from '../dateinput/utils';
+import { extend, isPresent, cropTwoDigitYear, setYears, parseToInt, clamp, areDatePartsEqualTo, isNumber } from './utils';
+import { Constants } from './constants';
+const PREVIOUS_CENTURY_BASE = 1900;
+const CURRENT_CENTURY_BASE = 2000;
+const SHORT_PATTERN_LENGTH_REGEXP = /d|M|H|h|m|s/;
+const MONTH_PART_WITH_WORDS_THRESHOLD = 2;
+const MONTH_SYMBOL = "M";
+// JS months start from 0 (January) instead of 1 (January)
+const JS_MONTH_OFFSET = 1;
+export class DateObject {
+    constructor({ intlService, formatPlaceholder, format, cycleTime = false, twoDigitYearMax = Constants.twoDigitYearMax, value = null, autoCorrectParts = true }) {
+        this.year = true;
+        this.month = true;
+        this.date = true;
+        this.hours = true;
+        this.minutes = true;
+        this.seconds = true;
+        this.milliseconds = true;
+        this.leadingZero = null;
+        this.typedMonthPart = '';
+        this.knownParts = 'adHhmMsEyS';
+        this.symbols = {
+            'E': 'E',
+            'H': 'H',
+            'M': 'M',
+            'a': 'a',
+            'd': 'd',
+            'h': 'h',
+            'm': 'm',
+            's': 's',
+            'y': 'y',
+            'S': 'S'
+        };
+        this._value = getDate(new Date());
+        this.cycleTime = false;
+        this._partiallyInvalidDate = {
+            startDate: null,
+            invalidDateParts: {
+                'E': { value: null, date: null, startDateOffset: 0 },
+                'H': { value: null, date: null, startDateOffset: 0 },
+                'M': { value: null, date: null, startDateOffset: 0 },
+                'a': { value: null, date: null, startDateOffset: 0 },
+                'd': { value: null, date: null, startDateOffset: 0 },
+                'h': { value: null, date: null, startDateOffset: 0 },
+                'm': { value: null, date: null, startDateOffset: 0 },
+                's': { value: null, date: null, startDateOffset: 0 },
+                'y': { value: null, date: null, startDateOffset: 0 },
+                'S': { value: null, date: null, startDateOffset: 0 }
+            }
+        };
+        this.intl = intlService;
+        this.formatPlaceholder = formatPlaceholder || 'wide';
+        this.format = format;
+        this.cycleTime = cycleTime;
+        this.monthNames = this.allFormattedMonths(this.localeId);
+        this.dayPeriods = this.allDayPeriods(this.localeId);
+        this.twoDigitYearMax = twoDigitYearMax;
+        this.autoCorrectParts = autoCorrectParts;
+        if (!value) {
+            this._value = getDate(new Date());
+            const sampleFormat = this.dateFormatString(this.value, this.format).symbols;
+            for (let i = 0; i < sampleFormat.length; i++) {
+                this.setExisting(sampleFormat[i], false);
+            }
+        }
+        else {
+            this._value = cloneDate(value);
+        }
+    }
+    set value(value) {
+        if (value && !(value instanceof Date)) {
+            // throw new Error("The 'value' should be a valid JavaScript Date instance.");
+            return;
+        }
+        this._value = value;
+        this.resetInvalidDate();
+    }
+    get value() {
+        return this._value;
+    }
+    get localeId() {
+        let localeId = Constants.defaultLocaleId;
+        const cldrKeys = Object.keys(this.intl.cldr);
+        for (let i = 0; i < cldrKeys.length; i++) {
+            const key = cldrKeys[i];
+            const value = this.intl.cldr[key];
+            if (value.name && value.calendar && value.numbers &&
+                value.name !== Constants.defaultLocaleId) {
+                localeId = value.name;
+                break;
+            }
+        }
+        return localeId;
+    }
+    setValue(value) {
+        if (!value) {
+            this._value = getDate(new Date());
+            this.modifyExisting(false);
+        }
+        else if (!isEqual(value, this._value)) {
+            this._value = cloneDate(value);
+            this.modifyExisting(true);
+        }
+        this.resetInvalidDate();
+    }
+    /**
+     * @hidden
+     */
+    hasValue() {
+        const pred = (a, p) => a || p.type !== 'literal' && p.type !== 'dayperiod' && this.getExisting(p.pattern[0]);
+        return this.intl.splitDateFormat(this.format, this.localeId).reduce(pred, false);
+    }
+    /**
+     * @hidden
+     */
+    getValue() {
+        for (let i = 0; i < this.knownParts.length; i++) {
+            if (!this.getExisting(this.knownParts[i])) {
+                return null;
+            }
+        }
+        return cloneDate(this.value);
+    }
+    /**
+     * @hidden
+     */
+    getFormattedDate(format) {
+        return this.intl.formatDate(this.getValue(), format, this.localeId);
+    }
+    /**
+     * @hidden
+     */
+    getTextAndFormat(customFormat = "") {
+        const format = customFormat || this.format;
+        let text = this.intl.formatDate(this.value, format, this.localeId);
+        const mask = this.dateFormatString(this.value, format);
+        if (!this.autoCorrectParts && this._partiallyInvalidDate.startDate) {
+            let partiallyInvalidText = "";
+            const formattedDate = this.intl.formatDate(this.value, format, this.localeId);
+            const formattedDates = this.getFormattedInvalidDates(format);
+            for (let i = 0; i < formattedDate.length; i++) {
+                const symbol = mask.symbols[i];
+                if (mask.partMap[i].type === "literal") {
+                    partiallyInvalidText += text[i];
+                }
+                else if (this.getInvalidDatePartValue(symbol)) {
+                    if (symbol === "M") {
+                        if (mask.partMap[i].pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD) {
+                            partiallyInvalidText += formattedDates[symbol][i];
+                        }
+                        else {
+                            if (this.getInvalidDatePartValue(symbol)) {
+                                const month = parseToInt(this.getInvalidDatePartValue(symbol) + JS_MONTH_OFFSET).toString();
+                                const formattedMonth = padZero(Math.abs(mask.partMap[i].pattern.length - month.length)) + month;
+                                partiallyInvalidText += formattedMonth;
+                                i += Math.max(0, formattedMonth.length - 1);
+                            }
+                            else {
+                                partiallyInvalidText += formattedDates[symbol][i];
+                            }
+                        }
+                    }
+                    else {
+                        if (this.getInvalidDatePartValue(symbol)) {
+                            partiallyInvalidText += this.getInvalidDatePartValue(symbol);
+                            i += Math.max(0, this.getInvalidDatePartValue(symbol).toString().length - 1);
+                        }
+                        else {
+                            partiallyInvalidText += formattedDates[symbol][i];
+                        }
+                    }
+                }
+                else {
+                    partiallyInvalidText += text[i];
+                }
+            }
+            text = partiallyInvalidText;
+        }
+        const result = this.merge(text, mask);
+        return result;
+    }
+    /**
+     * @hidden
+     */
+    getFormattedInvalidDates(customFormat = "") {
+        const format = customFormat || this.format;
+        let formattedDatesForSymbol = {
+            'E': '',
+            'H': '',
+            'M': '',
+            'a': '',
+            'd': '',
+            'h': '',
+            'm': '',
+            's': '',
+            'y': '',
+            'S': ''
+        };
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(key => {
+            const date = this.getInvalidDatePart(key).date;
+            if (date) {
+                const formattedInvalidDate = this.intl.formatDate(date, format, this.localeId);
+                formattedDatesForSymbol[key] = formattedInvalidDate;
+            }
+        });
+        return formattedDatesForSymbol;
+    }
+    modifyExisting(value) {
+        const sampleFormat = this.dateFormatString(this.value, this.format).symbols;
+        for (let i = 0; i < sampleFormat.length; i++) {
+            this.setExisting(sampleFormat[i], value);
+        }
+    }
+    /**
+     * @hidden
+     */
+    getExisting(symbol) {
+        switch (symbol) {
+            case 'y': return this.year;
+            case 'M':
+            case 'L': return this.month;
+            case 'd': return this.date;
+            case 'E': return this.date && this.month && this.year;
+            case 'h':
+            case 'H': return this.hours;
+            case 'm': return this.minutes;
+            case 's': return this.seconds;
+            case "S": return this.milliseconds;
+            default:
+                return true;
+        }
+    }
+    setExisting(symbol, value) {
+        switch (symbol) {
+            case 'y':
+                // allow 2/29 dates
+                this.year = value;
+                if (value === false) {
+                    this._value.setFullYear(2000);
+                }
+                break;
+            case 'M':
+                // make sure you can type 31 in the day part
+                this.month = value;
+                if (value === false) {
+                    if (this.autoCorrectParts) {
+                        this._value.setMonth(0);
+                    }
+                }
+                break;
+            case 'd':
+                this.date = value;
+                break;
+            case 'h':
+            case 'H':
+                this.hours = value;
+                break;
+            case 'm':
+                this.minutes = value;
+                break;
+            case 's':
+                this.seconds = value;
+                break;
+            case "S":
+                this.milliseconds = value;
+                break;
+            default:
+                break;
+        }
+        if (this.getValue()) {
+            this.resetInvalidDate();
+        }
+    }
+    modifyPart(symbol, offset) {
+        let newValue = cloneDate(this.value);
+        let originalValue = cloneDate(this.value);
+        let timeModified = false;
+        let invalidDateFound;
+        let currentInvalidDatePartValue = 0;
+        if (!this.autoCorrectParts) {
+            const isMonth = symbol === "M";
+            const isDay = symbol === "d" || symbol === "E";
+            const invalidDateParts = this._partiallyInvalidDate.invalidDateParts || {};
+            const invalidDatePart = invalidDateParts[symbol];
+            let year = invalidDateParts.y.value || newValue.getFullYear();
+            let month = invalidDateParts.M.value || newValue.getMonth();
+            let day = invalidDateParts.d.value || invalidDateParts.E.value || newValue.getDate();
+            let hour = invalidDateParts.h.value || invalidDateParts.H.value || newValue.getHours();
+            let minutes = invalidDateParts.m.value || newValue.getMinutes();
+            let seconds = invalidDateParts.s.value || newValue.getSeconds();
+            let milliseconds = invalidDateParts.S.value || newValue.getMilliseconds();
+            switch (symbol) {
+                case 'y':
+                    year += offset;
+                    break;
+                case 'M':
+                    month += offset;
+                    break;
+                case 'd':
+                case 'E':
+                    day += offset;
+                    break;
+                case 'h':
+                case 'H':
+                    hour += offset;
+                    break;
+                case 'm':
+                    minutes += offset;
+                    break;
+                case 's':
+                    seconds += offset;
+                    break;
+                case 'S':
+                    milliseconds += offset;
+                    break;
+                // case 'a': newValue.setHours(newValue.getHours() + (12 * offset)); timeModified = true; break;
+                default: break;
+            }
+            if (symbol === "M") {
+                if ((month < 0 || month > 11) && this.getExisting(symbol)) {
+                    // do not cycle months
+                    this.setExisting(symbol, false);
+                    return;
+                }
+                // const mask = this.dateFormatString(this.value, this.format);
+                // const monthPart = mask.partMap.filter(x => x.type === "month");
+                // if (monthPart && monthPart[0] && monthPart[0].pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD) {
+                month = (12 + month) % 12;
+                // }
+            }
+            const dateCandidate = createDate(year, month, day, hour, minutes, seconds, milliseconds);
+            const newValueCandidate = isMonth || isDay ?
+                this.modifyDateSymbolWithValue(newValue, symbol, isMonth ? month : day) :
+                null;
+            const dateCandidateExists = areDatePartsEqualTo(dateCandidate, year, month, day, hour, minutes, seconds, milliseconds);
+            if (this.getValue() && areDatePartsEqualTo(dateCandidate, year, month, day, hour, minutes, seconds, milliseconds)) {
+                newValue = cloneDate(dateCandidate);
+                this.markDatePartsAsExisting();
+            }
+            else if (isMonth && newValueCandidate) {
+                if (newValueCandidate.getMonth() === month) {
+                    if (this.getExisting("d")) {
+                        if (dateCandidateExists) {
+                            newValue = cloneDate(dateCandidate);
+                            this.resetInvalidDateSymbol(symbol);
+                        }
+                        else {
+                            invalidDateFound = true;
+                            this.setInvalidDatePart(symbol, {
+                                value: month,
+                                date: cloneDate(newValueCandidate),
+                                startDateOffset: offset,
+                                startDate: cloneDate(this.value)
+                            });
+                            this.setExisting(symbol, false);
+                        }
+                    }
+                    else if (dateCandidateExists) {
+                        this.resetInvalidDateSymbol(symbol);
+                        newValue = cloneDate(dateCandidate);
+                        if (this.getExisting("M") && this.getExisting("y")) {
+                            // changing from 28/Feb to 29/Feb to 29/March
+                            this.setExisting("d", true);
+                            this.resetInvalidDateSymbol("d");
+                        }
+                    }
+                    else {
+                        this.resetInvalidDateSymbol(symbol);
+                        newValue = cloneDate(newValueCandidate);
+                    }
+                }
+                else {
+                    invalidDateFound = true;
+                    this.setInvalidDatePart(symbol, {
+                        value: month,
+                        date: cloneDate(newValueCandidate),
+                        startDateOffset: offset,
+                        startDate: cloneDate(this.value)
+                    });
+                    this.setExisting(symbol, false);
+                }
+            }
+            else if (isDay && newValueCandidate) {
+                if (newValueCandidate.getDate() === day) {
+                    if (this.getExisting("M")) {
+                        if (dateCandidateExists) {
+                            newValue = cloneDate(dateCandidate);
+                            this.resetInvalidDateSymbol(symbol);
+                        }
+                        else {
+                            invalidDateFound = true;
+                            this.setInvalidDatePart(symbol, {
+                                value: day,
+                                date: cloneDate(newValueCandidate),
+                                startDateOffset: offset,
+                                startDate: cloneDate(this.value)
+                            });
+                            this.setExisting(symbol, false);
+                        }
+                    }
+                    else if (dateCandidateExists) {
+                        newValue = cloneDate(dateCandidate);
+                        this.resetInvalidDateSymbol(symbol);
+                        if (this.getExisting("d") && this.getExisting("y")) {
+                            // changing from 31/Jan to 31/Feb to 28/Feb
+                            this.setExisting("M", true);
+                            this.resetInvalidDateSymbol("M");
+                        }
+                    }
+                    else {
+                        this.resetInvalidDateSymbol(symbol);
+                        newValue = cloneDate(newValueCandidate);
+                    }
+                }
+                else {
+                    invalidDateFound = true;
+                    this.setInvalidDatePart(symbol, {
+                        value: day,
+                        date: cloneDate(this.value),
+                        startDateOffset: offset,
+                        startDate: cloneDate(this.value)
+                    });
+                    this.setExisting(symbol, false);
+                }
+            }
+            else {
+                // this.modifyDateSymbol()
+                switch (symbol) {
+                    case 'y':
+                        newValue.setFullYear(newValue.getFullYear() + offset);
+                        break;
+                    case 'M':
+                        newValue = addMonths(this.value, offset);
+                        break;
+                    case 'd':
+                    case 'E':
+                        newValue.setDate(newValue.getDate() + offset);
+                        break;
+                    case 'h':
+                    case 'H':
+                        newValue.setHours(newValue.getHours() + offset);
+                        timeModified = true;
+                        break;
+                    case 'm':
+                        newValue.setMinutes(newValue.getMinutes() + offset);
+                        timeModified = true;
+                        break;
+                    case 's':
+                        newValue.setSeconds(newValue.getSeconds() + offset);
+                        timeModified = true;
+                        break;
+                    case "S":
+                        newValue.setMilliseconds(newValue.getMilliseconds() + offset);
+                        break;
+                    case 'a':
+                        newValue.setHours(newValue.getHours() + (12 * offset));
+                        timeModified = true;
+                        break;
+                    default: break;
+                }
+                invalidDateFound = true;
+                if (invalidDatePart && invalidDatePart.value) {
+                    currentInvalidDatePartValue = parseToInt(invalidDatePart.value);
+                }
+                else {
+                    if (!isPresent(invalidDatePart.value)) {
+                        newValue = cloneDate(originalValue);
+                        // this.modifyDateSymbol()
+                        switch (symbol) {
+                            case 'y':
+                                currentInvalidDatePartValue = originalValue.getFullYear();
+                                break;
+                            case 'M':
+                                currentInvalidDatePartValue = originalValue.getMonth();
+                                break;
+                            case 'd':
+                            case 'E':
+                                currentInvalidDatePartValue = originalValue.getDate();
+                                break;
+                            case 'h':
+                            case 'H':
+                                currentInvalidDatePartValue = originalValue.getHours();
+                                break;
+                            case 'm':
+                                currentInvalidDatePartValue = originalValue.getMinutes();
+                                break;
+                            case 's':
+                                currentInvalidDatePartValue = originalValue.getSeconds();
+                                break;
+                            case 'S':
+                                currentInvalidDatePartValue = originalValue.getMilliseconds();
+                                break;
+                            // case 'a': newValue.setHours(newValue.getHours() + (12 * offset)); timeModified = true; break;
+                            default: break;
+                        }
+                    }
+                    else {
+                    }
+                }
+                let invalidDatePartValue = Math.max(0, currentInvalidDatePartValue + offset);
+                if (symbol !== "y") {
+                    invalidDatePartValue = clamp(currentInvalidDatePartValue + offset, 0, 99);
+                }
+                this.setInvalidDatePart(symbol, {
+                    value: invalidDatePartValue,
+                    date: cloneDate(newValue),
+                    startDateOffset: (this.getInvalidDatePart(symbol).startDateOffset || 0) + offset,
+                    startDate: cloneDate(this.value)
+                });
+                this.setExisting(symbol, false);
+            }
+        }
+        else {
+            switch (symbol) {
+                case 'y':
+                    newValue.setFullYear(newValue.getFullYear() + offset);
+                    break;
+                case 'M':
+                    newValue = addMonths(this.value, offset);
+                    break;
+                case 'd':
+                case 'E':
+                    newValue.setDate(newValue.getDate() + offset);
+                    break;
+                case 'h':
+                case 'H':
+                    newValue.setHours(newValue.getHours() + offset);
+                    timeModified = true;
+                    break;
+                case 'm':
+                    newValue.setMinutes(newValue.getMinutes() + offset);
+                    timeModified = true;
+                    break;
+                case 's':
+                    newValue.setSeconds(newValue.getSeconds() + offset);
+                    timeModified = true;
+                    break;
+                case "S":
+                    newValue.setMilliseconds(newValue.getMilliseconds() + offset);
+                    break;
+                case 'a':
+                    newValue.setHours(newValue.getHours() + (12 * offset));
+                    timeModified = true;
+                    break;
+                default: break;
+            }
+        }
+        if (this.shouldNormalizeCentury()) {
+            newValue = this.normalizeCentury(newValue);
+        }
+        if (timeModified && !this.cycleTime && newValue.getDate() !== this._value.getDate()) {
+            // todo: blazor has this fix, but this fails a unit test
+            // newValue.setDate(this._value.getDate());
+            // newValue.setMonth(this._value.getMonth());
+            // newValue.setFullYear(this._value.getFullYear());
+        }
+        if (!invalidDateFound) {
+            this.setExisting(symbol, true);
+            this._value = newValue;
+            if (this.getValue()) {
+                this.resetInvalidDate();
+            }
+        }
+    }
+    /**
+     * @hidden
+     */
+    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue, isDeleting }) {
+        const isInCaretMode = !cycleSegmentValue;
+        const dateParts = this.dateFormatString(this.value, this.format);
+        const datePartsLiterals = dateParts.partMap
+            .filter(x => x.type === "literal")
+            .map((x, index) => {
+            return {
+                datePartIndex: index,
+                literal: x.pattern
+            };
+        });
+        let shouldResetPart = isInCaretMode && symbol === "M" && dateParts.partMap
+            .filter(x => x.type === "month")
+            .some(x => x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD);
+        let parseResult = {
+            value: null,
+            switchPart: false,
+            resetPart: shouldResetPart
+        };
+        if (!currentChar) {
+            if (isInCaretMode) {
+                for (let i = 0; i < datePartsLiterals.length; i++) {
+                    const literal = datePartsLiterals[i].literal;
+                    const rawValueStartsWithLiteral = rawTextValue.startsWith(literal);
+                    const rawValueEndsWithLiteral = rawTextValue.endsWith(literal);
+                    const rawValueHasConsecutiveLiterals = rawTextValue.indexOf(literal + literal) >= 0;
+                    if (rawValueStartsWithLiteral || rawValueEndsWithLiteral || rawValueHasConsecutiveLiterals) {
+                        this.resetLeadingZero();
+                        this.setExisting(symbol, false);
+                        this.resetInvalidDateSymbol(symbol);
+                        return extend(parseResult, { value: null, switchToNext: false });
+                    }
+                }
+            }
+            else {
+                this.resetLeadingZero();
+                this.setExisting(symbol, false);
+                this.resetInvalidDateSymbol(symbol);
+                // return extend(parseResult, { value: null, switchToNext: false });
+                return { value: null, switchToNext: false };
+            }
+        }
+        const baseDate = this.intl.formatDate(this.value, this.format, this.localeId);
+        const baseFormat = dateParts.symbols;
+        let replaced = false;
+        let prefix = '';
+        let current = '';
+        let datePartText = '';
+        let suffix = '';
+        if (isInCaretMode) {
+            let datePartIndex = 0;
+            let outOfDatePartBounds = false;
+            for (let i = 0; i < baseDate.length; i++) {
+                const datePartLiteral = datePartsLiterals[datePartIndex];
+                if (datePartLiteral && datePartLiteral === baseDate[i]) {
+                    datePartIndex++;
+                }
+                if (baseFormat[i] === symbol) {
+                    const existing = this.getExisting(symbol);
+                    current += existing ? baseDate[i] : '0';
+                    const rawInputChar = rawTextValue[i];
+                    if (rawInputChar !== baseDate[i] && rawInputChar === datePartsLiterals[datePartIndex].literal) {
+                        outOfDatePartBounds = true;
+                    }
+                    else if (!outOfDatePartBounds) {
+                        if (rawInputChar === undefined) {
+                            const formatOffset = Math.abs(this.format.length - baseFormat.length);
+                            datePartText += rawTextValue[i - formatOffset] || '';
+                        }
+                        else {
+                            datePartText += rawInputChar || '';
+                        }
+                    }
+                    replaced = true;
+                }
+                else if (!replaced) {
+                    prefix += baseDate[i];
+                }
+                else {
+                    suffix += baseDate[i];
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < baseDate.length; i++) {
+                if (baseFormat[i] === symbol) {
+                    const existing = this.getExisting(symbol);
+                    current += existing ? baseDate[i] : '0';
+                    replaced = true;
+                }
+                else if (!replaced) {
+                    prefix += baseDate[i];
+                }
+                else {
+                    suffix += baseDate[i];
+                }
+            }
+        }
+        let parsedDate = null;
+        const month = this.matchMonth(currentChar);
+        const dayPeriod = this.matchDayPeriod(currentChar, symbol);
+        const isZeroCurrentChar = currentChar === '0';
+        const leadingZero = this.leadingZero || {};
+        if (isZeroCurrentChar && !isInCaretMode) {
+            let valueNumber = parseInt(resetSegmentValue ? currentChar : current + currentChar, 10);
+            if (valueNumber === 0 && !this.isAbbrMonth(dateParts.partMap, symbol)) {
+                this.incrementLeadingZero(symbol);
+            }
+        }
+        else {
+            this.resetLeadingZero();
+        }
+        const partPattern = this.partPattern(dateParts.partMap, symbol);
+        const patternValue = partPattern ? partPattern.pattern : null;
+        if (isInCaretMode && isDeleting) {
+            const padPrefix = padZero(Math.abs(current.length - datePartText.length));
+            current = padPrefix + datePartText;
+        }
+        if (isInCaretMode) {
+            if (isDeleting && !datePartText) {
+                this.setExisting(symbol, false);
+                return extend(parseResult, { value: null, switchToNext: false });
+            }
+        }
+        const currentMaxLength = current.length - 3;
+        let tryParse = true;
+        for (let i = Math.max(0, currentMaxLength); i <= current.length; i++) {
+            if (!tryParse) {
+                break;
+            }
+            if (!this.autoCorrectParts) {
+                tryParse = false;
+            }
+            let middle = resetSegmentValue ? currentChar : (current.substring(i) + currentChar);
+            if (!tryParse && isInCaretMode) {
+                // try to make an exact match as there will be only 1 attempt
+                middle = unpadZero(middle);
+            }
+            let middleNumber = parseInt(middle, 10);
+            const candidateDateString = prefix + middle + suffix;
+            parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            const isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
+            if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable) {
+                if (symbol === MONTH_SYMBOL && !month) {
+                    // JS months start from 0 (January) instead of 1 (January)
+                    const monthNumber = middleNumber - JS_MONTH_OFFSET;
+                    if (monthNumber > -1 && monthNumber < 12) {
+                        parsedDate = cloneDate(this.value);
+                        parsedDate.setMonth(monthNumber);
+                        if (parsedDate.getMonth() !== monthNumber) {
+                            parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
+                        }
+                    }
+                }
+                if (symbol === 'y') {
+                    parsedDate = createDate(parseInt(middle, 10), this.month ? this.value.getMonth() : 0, this.date ? this.value.getDate() : 1, this.hours ? this.value.getHours() : 0, this.minutes ? this.value.getMinutes() : 0, this.seconds ? this.value.getSeconds() : 0, this.milliseconds ? this.value.getMilliseconds() : 0);
+                    if (this.date && parsedDate.getDate() !== this.value.getDate()) {
+                        parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
+                    }
+                }
+            }
+            if (parsedDate) {
+                // move to next segment if the part will overflow with next char
+                // when start from empty date (01, then 010), padded zeros should be trimmed
+                const peekDate = this.intl.parseDate(`${prefix}${this.peek(middle, patternValue)}${suffix}`, this.format, this.localeId);
+                const patternLength = this.patternLength(patternValue) || patternValue.length;
+                const patternSatisfied = (leadingZero + (unpadZero(middle) || currentChar).length) >= patternLength;
+                const switchToNext = peekDate === null || patternSatisfied;
+                if (this.shouldNormalizeCentury()) {
+                    parsedDate = this.normalizeCentury(parsedDate);
+                }
+                this._value = parsedDate;
+                this.setExisting(symbol, true);
+                return extend(parseResult, { value: this.value, switchToNext: switchToNext });
+            }
+        }
+        if (month) {
+            parsedDate = this.intl.parseDate(prefix + month + suffix, this.format, this.localeId);
+            if (parsedDate) {
+                this._value = parsedDate;
+                this.setExisting(symbol, true);
+                return extend(parseResult, { value: this.value, switchToNext: false });
+            }
+        }
+        if (dayPeriod) {
+            parsedDate = this.intl.parseDate(prefix + dayPeriod + suffix, this.format);
+            if (parsedDate) {
+                this._value = parsedDate;
+                return extend(parseResult, { value: this.value, switchToNext: true });
+            }
+        }
+        if (isZeroCurrentChar) {
+            this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? { [symbol]: true } : null;
+            this.setExisting(symbol, false);
+        }
+        if (!this.autoCorrectParts) {
+            this.setExisting(symbol, false);
+            // todo check if string is better
+            // const padPrefix = padZero(Math.abs(current.length - datePartText.length));
+            // const paddedDatePartText = padPrefix + datePartText;
+            let datePartValue;
+            const textToParse = isInCaretMode ? datePartText : current;
+            const parsedValue = parseToInt(textToParse);
+            if (isNumber(parsedValue)) {
+                datePartValue = symbol === "M" ?
+                    clamp(parsedValue - JS_MONTH_OFFSET, 0, 12 - JS_MONTH_OFFSET) :
+                    parsedValue;
+            }
+            if (isNumber(datePartValue)) {
+                const newDate = this.modifyDateSymbolWithValue(this.value, symbol, datePartValue);
+                this.setInvalidDatePart(symbol, {
+                    value: datePartValue,
+                    date: cloneDate(newDate),
+                    startDate: this._partiallyInvalidDate.startDate || cloneDate(this.value)
+                });
+            }
+        }
+        return extend(parseResult, { value: null, switchToNext: false });
+    }
+    /**
+     * @hidden
+     */
+    symbolMap(symbol) {
+        return this.intl.splitDateFormat(this.format, this.localeId).reduce(dateSymbolMap, {})[symbol];
+    }
+    /**
+     * @hidden
+     */
+    resetLeadingZero() {
+        const hasLeadingZero = this.leadingZero !== null;
+        this.setLeadingZero(null);
+        return hasLeadingZero;
+    }
+    setLeadingZero(leadingZero) {
+        this.leadingZero = leadingZero;
+    }
+    /**
+     * @hidden
+     */
+    normalizeCentury(date) {
+        if (!isPresent(date)) {
+            return date;
+        }
+        const twoDigitYear = cropTwoDigitYear(date);
+        const centuryBase = this.getNormalizedCenturyBase(twoDigitYear);
+        const normalizedDate = setYears(date, centuryBase + twoDigitYear);
+        return normalizedDate;
+    }
+    incrementLeadingZero(symbol) {
+        const leadingZero = this.leadingZero || {};
+        leadingZero[symbol] = (leadingZero[symbol] || 0) + 1;
+        this.leadingZero = leadingZero;
+    }
+    /**
+     * @hidden
+     */
+    isAbbrMonth(parts, symbol) {
+        const pattern = this.partPattern(parts, symbol);
+        return pattern.type === 'month' && pattern.names;
+    }
+    /**
+     * @hidden
+     */
+    partPattern(parts, symbol) {
+        return parts.filter((part) => part.pattern.indexOf(symbol) !== -1)[0];
+    }
+    /**
+     * @hidden
+     */
+    peek(value, pattern) {
+        const peekValue = value.replace(/^0*/, '') + '0';
+        return padZero(pattern.length - peekValue.length) + peekValue;
+    }
+    /**
+     * @hidden
+     */
+    matchMonth(typedChar) {
+        this.typedMonthPart += typedChar.toLowerCase();
+        if (this.monthNames.length === 0) {
+            return '';
+        }
+        while (this.typedMonthPart.length > 0) {
+            for (let i = 0; i < this.monthNames.length; i++) {
+                if (this.monthNames[i].toLowerCase().indexOf(this.typedMonthPart) === 0) {
+                    return this.monthNames[i];
+                }
+            }
+            const monthAsNum = parseInt(this.typedMonthPart, 10);
+            /* ensure they exact match */
+            if (monthAsNum >= 1 && monthAsNum <= 12 && monthAsNum.toString() === this.typedMonthPart) {
+                return this.monthNames[monthAsNum - 1];
+            }
+            this.typedMonthPart = this.typedMonthPart.substring(1, this.typedMonthPart.length);
+        }
+        return '';
+    }
+    /**
+     * @hidden
+     */
+    matchDayPeriod(typedChar, symbol) {
+        const lowerChart = typedChar.toLowerCase();
+        if (symbol === 'a' && this.dayPeriods) {
+            if (this.dayPeriods.am.toLowerCase().startsWith(lowerChart)) {
+                return this.dayPeriods.am;
+            }
+            else if (this.dayPeriods.pm.toLowerCase().startsWith(lowerChart)) {
+                return this.dayPeriods.pm;
+            }
+        }
+        return '';
+    }
+    /**
+     * @hidden
+     */
+    allFormattedMonths(locale = "en") {
+        const dateFormatParts = this.intl.splitDateFormat(this.format, this.localeId);
+        for (let i = 0; i < dateFormatParts.length; i++) {
+            if (dateFormatParts[i].type === 'month' && dateFormatParts[i].names) {
+                // return this.intl.dateFormatNames(dateFormatParts[i].names);
+                return this.intl.dateFormatNames(locale, dateFormatParts[i].names);
+            }
+        }
+        return [];
+    }
+    /**
+     * @hidden
+     */
+    allDayPeriods(locale = "en") {
+        const dateFormatParts = this.intl.splitDateFormat(this.format);
+        for (let i = 0; i < dateFormatParts.length; i++) {
+            if (dateFormatParts[i].type === "dayperiod" && dateFormatParts[i].names) {
+                return this.intl.dateFormatNames(locale, dateFormatParts[i].names);
+            }
+        }
+        return null;
+    }
+    /**
+     * @hidden
+     */
+    patternLength(pattern) {
+        if (pattern[0] === 'y') {
+            return 4;
+        }
+        if (SHORT_PATTERN_LENGTH_REGEXP.test(pattern)) {
+            return 2;
+        }
+        return 0;
+    }
+    /**
+     * @hidden
+     */
+    dateFormatString(date, format) {
+        const dateFormatParts = this.intl.splitDateFormat(format, this.localeId);
+        const parts = [];
+        const partMap = [];
+        for (let i = 0; i < dateFormatParts.length; i++) {
+            let partLength = this.intl.formatDate(date, { pattern: dateFormatParts[i].pattern }, this.localeId).length;
+            while (partLength > 0) {
+                parts.push(this.symbols[dateFormatParts[i].pattern[0]] || Constants.formatSeparator);
+                partMap.push(dateFormatParts[i]);
+                partLength--;
+            }
+        }
+        const returnValue = new Mask();
+        returnValue.symbols = parts.join('');
+        returnValue.partMap = partMap;
+        return returnValue;
+    }
+    /**
+     * @hidden
+     */
+    merge(text, mask) {
+        // Important: right to left.
+        let resultText = '';
+        let resultFormat = '';
+        let format = mask.symbols;
+        for (let formatSymbolIndex = format.length - 1; formatSymbolIndex >= 0; formatSymbolIndex--) {
+            if (this.knownParts.indexOf(format[formatSymbolIndex]) === -1 || this.getExisting(format[formatSymbolIndex])) {
+                resultText = text[formatSymbolIndex] + resultText;
+                resultFormat = format[formatSymbolIndex] + resultFormat;
+            }
+            else {
+                const symbol = format[formatSymbolIndex];
+                while (formatSymbolIndex >= 0 && symbol === format[formatSymbolIndex]) {
+                    formatSymbolIndex--;
+                }
+                formatSymbolIndex++;
+                if (this.leadingZero && this.leadingZero[symbol]) {
+                    resultText = '0' + resultText;
+                }
+                else {
+                    if (!this.autoCorrectParts && this.getInvalidDatePartValue(symbol)) {
+                        const segmentText = text.substr(formatSymbolIndex, mask.partMap[formatSymbolIndex].pattern.length);
+                        resultText = segmentText + resultText;
+                    }
+                    else {
+                        resultText = this.dateFieldName(mask.partMap[formatSymbolIndex]) + resultText;
+                    }
+                }
+                while (resultFormat.length < resultText.length) {
+                    resultFormat = format[formatSymbolIndex] + resultFormat;
+                }
+            }
+        }
+        return { text: resultText, format: resultFormat };
+    }
+    /**
+     * @hidden
+     */
+    dateFieldName(part) {
+        const formatPlaceholder = this.formatPlaceholder || 'wide';
+        if (formatPlaceholder[part.type]) {
+            return formatPlaceholder[part.type];
+        }
+        if (formatPlaceholder === 'formatPattern') {
+            return part.pattern;
+        }
+        return this.intl.dateFieldName(Object.assign(part, { nameType: formatPlaceholder }));
+    }
+    /**
+     * @hidden
+     */
+    getNormalizedCenturyBase(twoDigitYear) {
+        return twoDigitYear > this.twoDigitYearMax ?
+            PREVIOUS_CENTURY_BASE :
+            CURRENT_CENTURY_BASE;
+    }
+    /**
+     * @hidden
+     */
+    shouldNormalizeCentury() {
+        return this.intl.splitDateFormat(this.format).some(part => part.pattern === 'yy');
+    }
+    resetInvalidDate() {
+        this._partiallyInvalidDate.startDate = null;
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(key => {
+            this.resetInvalidDatePart(key);
+        });
+    }
+    resetInvalidDateSymbol(symbol) {
+        this.resetInvalidDatePart(symbol);
+        let shouldResetInvalidDate = true;
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(key => {
+            if (this._partiallyInvalidDate.invalidDateParts[key] &&
+                isPresent(this._partiallyInvalidDate.invalidDateParts[key].value)) {
+                shouldResetInvalidDate = false;
+            }
+        });
+        if (shouldResetInvalidDate) {
+            this.resetInvalidDate();
+        }
+    }
+    resetInvalidDatePart(symbol) {
+        if (this._partiallyInvalidDate.invalidDateParts[symbol]) {
+            this._partiallyInvalidDate.invalidDateParts[symbol] = {
+                value: null,
+                date: null,
+                startDateOffset: 0
+            };
+        }
+    }
+    /**
+     * @hidden
+     */
+    getInvalidDatePart(symbol) {
+        const invalidDatePart = this._partiallyInvalidDate.invalidDateParts[symbol];
+        return invalidDatePart || {};
+    }
+    /**
+     * @hidden
+     */
+    getInvalidDatePartValue(symbol) {
+        const invalidDatePart = this._partiallyInvalidDate.invalidDateParts[symbol];
+        return (invalidDatePart || {}).value;
+    }
+    setInvalidDatePart(symbol, { value = null, date = null, startDateOffset = 0, startDate = null }) {
+        if (this._partiallyInvalidDate.invalidDateParts[symbol]) {
+            this._partiallyInvalidDate.invalidDateParts[symbol].value = value;
+            this._partiallyInvalidDate.invalidDateParts[symbol].date = date;
+            this._partiallyInvalidDate.invalidDateParts[symbol].startDateOffset = startDateOffset;
+            this._partiallyInvalidDate.startDate = startDate;
+        }
+    }
+    /**
+     * @hidden
+     */
+    modifyDateSymbolWithOffset(date, symbol, offset) {
+        let newValue = cloneDate(date);
+        let timeModified = false;
+        switch (symbol) {
+            case 'y':
+                newValue.setFullYear(newValue.getFullYear() + offset);
+                break;
+            case 'M':
+                newValue = addMonths(this.value, offset);
+                break;
+            case 'd':
+            case 'E':
+                newValue.setDate(newValue.getDate() + offset);
+                break;
+            case 'h':
+            case 'H':
+                newValue.setHours(newValue.getHours() + offset);
+                timeModified = true;
+                break;
+            case 'm':
+                newValue.setMinutes(newValue.getMinutes() + offset);
+                timeModified = true;
+                break;
+            case 's':
+                newValue.setSeconds(newValue.getSeconds() + offset);
+                timeModified = true;
+                break;
+            case "S":
+                newValue.setMilliseconds(newValue.getMilliseconds() + offset);
+                break;
+            case 'a':
+                newValue.setHours(newValue.getHours() + (12 * offset));
+                timeModified = true;
+                break;
+            default: break;
+        }
+        return {
+            date: newValue,
+            timeModified: timeModified
+        };
+    }
+    /**
+     * @hidden
+     */
+    modifyDateSymbolWithValue(date, symbol, value) {
+        let newValue = cloneDate(date);
+        switch (symbol) {
+            case 'y':
+                newValue.setFullYear(value);
+                break;
+            case 'M':
+                newValue = addMonths(date, value - date.getMonth());
+                break;
+            case 'd':
+            case 'E':
+                newValue.setDate(value);
+                break;
+            case 'h':
+            case 'H':
+                newValue.setHours(value);
+                break;
+            case 'm':
+                newValue.setMinutes(value);
+                break;
+            case 's':
+                newValue.setSeconds(value);
+                break;
+            case "S":
+                newValue.setMilliseconds(value);
+                break;
+            case 'a':
+                newValue.setHours(value);
+                break;
+            default: break;
+        }
+        return newValue;
+    }
+    markDatePartsAsExisting() {
+        this.modifyExisting(true);
+    }
+}