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

package/dist/es/common/dateobject.js

@@ -0,0 +1,1159 @@
+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';
+var PREVIOUS_CENTURY_BASE = 1900;
+var CURRENT_CENTURY_BASE = 2000;
+var SHORT_PATTERN_LENGTH_REGEXP = /d|M|H|h|m|s/;
+var MONTH_PART_WITH_WORDS_THRESHOLD = 2;
+var MONTH_SYMBOL = "M";
+// JS months start from 0 (January) instead of 1 (January)
+var JS_MONTH_OFFSET = 1;
+var DateObject = /** @class */ (function () {
+    function DateObject(_a) {
+        var intlService = _a.intlService, formatPlaceholder = _a.formatPlaceholder, format = _a.format, _b = _a.cycleTime, cycleTime = _b === void 0 ? false : _b, _c = _a.twoDigitYearMax, twoDigitYearMax = _c === void 0 ? Constants.twoDigitYearMax : _c, _d = _a.value, value = _d === void 0 ? null : _d, _e = _a.autoCorrectParts, autoCorrectParts = _e === void 0 ? true : _e;
+        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());
+            var sampleFormat = this.dateFormatString(this.value, this.format).symbols;
+            for (var i = 0; i < sampleFormat.length; i++) {
+                this.setExisting(sampleFormat[i], false);
+            }
+        }
+        else {
+            this._value = cloneDate(value);
+        }
+    }
+    Object.defineProperty(DateObject.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            if (value && !(value instanceof Date)) {
+                // throw new Error("The 'value' should be a valid JavaScript Date instance.");
+                return;
+            }
+            this._value = value;
+            this.resetInvalidDate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DateObject.prototype, "localeId", {
+        get: function () {
+            var localeId = Constants.defaultLocaleId;
+            var cldrKeys = Object.keys(this.intl.cldr);
+            for (var i = 0; i < cldrKeys.length; i++) {
+                var key = cldrKeys[i];
+                var value = this.intl.cldr[key];
+                if (value.name && value.calendar && value.numbers &&
+                    value.name !== Constants.defaultLocaleId) {
+                    localeId = value.name;
+                    break;
+                }
+            }
+            return localeId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DateObject.prototype.setValue = function (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
+     */
+    DateObject.prototype.hasValue = function () {
+        var _this = this;
+        var pred = function (a, p) { return a || p.type !== 'literal' && p.type !== 'dayperiod' && _this.getExisting(p.pattern[0]); };
+        return this.intl.splitDateFormat(this.format, this.localeId).reduce(pred, false);
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getValue = function () {
+        for (var i = 0; i < this.knownParts.length; i++) {
+            if (!this.getExisting(this.knownParts[i])) {
+                return null;
+            }
+        }
+        return cloneDate(this.value);
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getFormattedDate = function (format) {
+        return this.intl.formatDate(this.getValue(), format, this.localeId);
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getTextAndFormat = function (customFormat) {
+        if (customFormat === void 0) { customFormat = ""; }
+        var format = customFormat || this.format;
+        var text = this.intl.formatDate(this.value, format, this.localeId);
+        var mask = this.dateFormatString(this.value, format);
+        if (!this.autoCorrectParts && this._partiallyInvalidDate.startDate) {
+            var partiallyInvalidText = "";
+            var formattedDate = this.intl.formatDate(this.value, format, this.localeId);
+            var formattedDates = this.getFormattedInvalidDates(format);
+            for (var i = 0; i < formattedDate.length; i++) {
+                var 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)) {
+                                var month = parseToInt(this.getInvalidDatePartValue(symbol) + JS_MONTH_OFFSET).toString();
+                                var 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;
+        }
+        var result = this.merge(text, mask);
+        return result;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getFormattedInvalidDates = function (customFormat) {
+        var _this = this;
+        if (customFormat === void 0) { customFormat = ""; }
+        var format = customFormat || this.format;
+        var formattedDatesForSymbol = {
+            'E': '',
+            'H': '',
+            'M': '',
+            'a': '',
+            'd': '',
+            'h': '',
+            'm': '',
+            's': '',
+            'y': '',
+            'S': ''
+        };
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(function (key) {
+            var date = _this.getInvalidDatePart(key).date;
+            if (date) {
+                var formattedInvalidDate = _this.intl.formatDate(date, format, _this.localeId);
+                formattedDatesForSymbol[key] = formattedInvalidDate;
+            }
+        });
+        return formattedDatesForSymbol;
+    };
+    DateObject.prototype.modifyExisting = function (value) {
+        var sampleFormat = this.dateFormatString(this.value, this.format).symbols;
+        for (var i = 0; i < sampleFormat.length; i++) {
+            this.setExisting(sampleFormat[i], value);
+        }
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getExisting = function (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;
+        }
+    };
+    DateObject.prototype.setExisting = function (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();
+        }
+    };
+    DateObject.prototype.modifyPart = function (symbol, offset) {
+        var newValue = cloneDate(this.value);
+        var originalValue = cloneDate(this.value);
+        var timeModified = false;
+        var invalidDateFound;
+        var currentInvalidDatePartValue = 0;
+        if (!this.autoCorrectParts) {
+            var isMonth = symbol === "M";
+            var isDay = symbol === "d" || symbol === "E";
+            var invalidDateParts = this._partiallyInvalidDate.invalidDateParts || {};
+            var invalidDatePart = invalidDateParts[symbol];
+            var year = invalidDateParts.y.value || newValue.getFullYear();
+            var month = invalidDateParts.M.value || newValue.getMonth();
+            var day = invalidDateParts.d.value || invalidDateParts.E.value || newValue.getDate();
+            var hour = invalidDateParts.h.value || invalidDateParts.H.value || newValue.getHours();
+            var minutes = invalidDateParts.m.value || newValue.getMinutes();
+            var seconds = invalidDateParts.s.value || newValue.getSeconds();
+            var 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;
+                // }
+            }
+            var dateCandidate = createDate(year, month, day, hour, minutes, seconds, milliseconds);
+            var newValueCandidate = isMonth || isDay ?
+                this.modifyDateSymbolWithValue(newValue, symbol, isMonth ? month : day) :
+                null;
+            var 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 {
+                    }
+                }
+                var 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
+     */
+    DateObject.prototype.parsePart = function (_a) {
+        var _b;
+        var symbol = _a.symbol, currentChar = _a.currentChar, resetSegmentValue = _a.resetSegmentValue, cycleSegmentValue = _a.cycleSegmentValue, rawTextValue = _a.rawTextValue, isDeleting = _a.isDeleting;
+        var isInCaretMode = !cycleSegmentValue;
+        var dateParts = this.dateFormatString(this.value, this.format);
+        var datePartsLiterals = dateParts.partMap
+            .filter(function (x) { return x.type === "literal"; })
+            .map(function (x, index) {
+            return {
+                datePartIndex: index,
+                literal: x.pattern
+            };
+        });
+        var shouldResetPart = isInCaretMode && symbol === "M" && dateParts.partMap
+            .filter(function (x) { return x.type === "month"; })
+            .some(function (x) { return x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD; });
+        var parseResult = {
+            value: null,
+            switchPart: false,
+            resetPart: shouldResetPart
+        };
+        if (!currentChar) {
+            if (isInCaretMode) {
+                for (var i = 0; i < datePartsLiterals.length; i++) {
+                    var literal = datePartsLiterals[i].literal;
+                    var rawValueStartsWithLiteral = rawTextValue.startsWith(literal);
+                    var rawValueEndsWithLiteral = rawTextValue.endsWith(literal);
+                    var 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 };
+            }
+        }
+        var baseDate = this.intl.formatDate(this.value, this.format, this.localeId);
+        var baseFormat = dateParts.symbols;
+        var replaced = false;
+        var prefix = '';
+        var current = '';
+        var datePartText = '';
+        var suffix = '';
+        if (isInCaretMode) {
+            var datePartIndex = 0;
+            var outOfDatePartBounds = false;
+            for (var i = 0; i < baseDate.length; i++) {
+                var datePartLiteral = datePartsLiterals[datePartIndex];
+                if (datePartLiteral && datePartLiteral === baseDate[i]) {
+                    datePartIndex++;
+                }
+                if (baseFormat[i] === symbol) {
+                    var existing = this.getExisting(symbol);
+                    current += existing ? baseDate[i] : '0';
+                    var rawInputChar = rawTextValue[i];
+                    if (rawInputChar !== baseDate[i] && rawInputChar === datePartsLiterals[datePartIndex].literal) {
+                        outOfDatePartBounds = true;
+                    }
+                    else if (!outOfDatePartBounds) {
+                        if (rawInputChar === undefined) {
+                            var 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 (var i = 0; i < baseDate.length; i++) {
+                if (baseFormat[i] === symbol) {
+                    var existing = this.getExisting(symbol);
+                    current += existing ? baseDate[i] : '0';
+                    replaced = true;
+                }
+                else if (!replaced) {
+                    prefix += baseDate[i];
+                }
+                else {
+                    suffix += baseDate[i];
+                }
+            }
+        }
+        var parsedDate = null;
+        var month = this.matchMonth(currentChar);
+        var dayPeriod = this.matchDayPeriod(currentChar, symbol);
+        var isZeroCurrentChar = currentChar === '0';
+        var leadingZero = this.leadingZero || {};
+        if (isZeroCurrentChar && !isInCaretMode) {
+            var valueNumber = parseInt(resetSegmentValue ? currentChar : current + currentChar, 10);
+            if (valueNumber === 0 && !this.isAbbrMonth(dateParts.partMap, symbol)) {
+                this.incrementLeadingZero(symbol);
+            }
+        }
+        else {
+            this.resetLeadingZero();
+        }
+        var partPattern = this.partPattern(dateParts.partMap, symbol);
+        var patternValue = partPattern ? partPattern.pattern : null;
+        if (isInCaretMode && isDeleting) {
+            var 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 });
+            }
+        }
+        var currentMaxLength = current.length - 3;
+        var tryParse = true;
+        for (var i = Math.max(0, currentMaxLength); i <= current.length; i++) {
+            if (!tryParse) {
+                break;
+            }
+            if (!this.autoCorrectParts) {
+                tryParse = false;
+            }
+            var 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);
+            }
+            var middleNumber = parseInt(middle, 10);
+            var candidateDateString = prefix + middle + suffix;
+            parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            var 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)
+                    var 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
+                var peekDate = this.intl.parseDate("" + prefix + this.peek(middle, patternValue) + suffix, this.format, this.localeId);
+                var patternLength = this.patternLength(patternValue) || patternValue.length;
+                var patternSatisfied = (leadingZero + (unpadZero(middle) || currentChar).length) >= patternLength;
+                var 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) ? (_b = {}, _b[symbol] = true, _b) : 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;
+            var datePartValue = void 0;
+            var textToParse = isInCaretMode ? datePartText : current;
+            var parsedValue = parseToInt(textToParse);
+            if (isNumber(parsedValue)) {
+                datePartValue = symbol === "M" ?
+                    clamp(parsedValue - JS_MONTH_OFFSET, 0, 12 - JS_MONTH_OFFSET) :
+                    parsedValue;
+            }
+            if (isNumber(datePartValue)) {
+                var 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
+     */
+    DateObject.prototype.symbolMap = function (symbol) {
+        return this.intl.splitDateFormat(this.format, this.localeId).reduce(dateSymbolMap, {})[symbol];
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.resetLeadingZero = function () {
+        var hasLeadingZero = this.leadingZero !== null;
+        this.setLeadingZero(null);
+        return hasLeadingZero;
+    };
+    DateObject.prototype.setLeadingZero = function (leadingZero) {
+        this.leadingZero = leadingZero;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.normalizeCentury = function (date) {
+        if (!isPresent(date)) {
+            return date;
+        }
+        var twoDigitYear = cropTwoDigitYear(date);
+        var centuryBase = this.getNormalizedCenturyBase(twoDigitYear);
+        var normalizedDate = setYears(date, centuryBase + twoDigitYear);
+        return normalizedDate;
+    };
+    DateObject.prototype.incrementLeadingZero = function (symbol) {
+        var leadingZero = this.leadingZero || {};
+        leadingZero[symbol] = (leadingZero[symbol] || 0) + 1;
+        this.leadingZero = leadingZero;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.isAbbrMonth = function (parts, symbol) {
+        var pattern = this.partPattern(parts, symbol);
+        return pattern.type === 'month' && pattern.names;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.partPattern = function (parts, symbol) {
+        return parts.filter(function (part) { return part.pattern.indexOf(symbol) !== -1; })[0];
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.peek = function (value, pattern) {
+        var peekValue = value.replace(/^0*/, '') + '0';
+        return padZero(pattern.length - peekValue.length) + peekValue;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.matchMonth = function (typedChar) {
+        this.typedMonthPart += typedChar.toLowerCase();
+        if (this.monthNames.length === 0) {
+            return '';
+        }
+        while (this.typedMonthPart.length > 0) {
+            for (var i = 0; i < this.monthNames.length; i++) {
+                if (this.monthNames[i].toLowerCase().indexOf(this.typedMonthPart) === 0) {
+                    return this.monthNames[i];
+                }
+            }
+            var 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
+     */
+    DateObject.prototype.matchDayPeriod = function (typedChar, symbol) {
+        var 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
+     */
+    DateObject.prototype.allFormattedMonths = function (locale) {
+        if (locale === void 0) { locale = "en"; }
+        var dateFormatParts = this.intl.splitDateFormat(this.format, this.localeId);
+        for (var 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
+     */
+    DateObject.prototype.allDayPeriods = function (locale) {
+        if (locale === void 0) { locale = "en"; }
+        var dateFormatParts = this.intl.splitDateFormat(this.format);
+        for (var 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
+     */
+    DateObject.prototype.patternLength = function (pattern) {
+        if (pattern[0] === 'y') {
+            return 4;
+        }
+        if (SHORT_PATTERN_LENGTH_REGEXP.test(pattern)) {
+            return 2;
+        }
+        return 0;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.dateFormatString = function (date, format) {
+        var dateFormatParts = this.intl.splitDateFormat(format, this.localeId);
+        var parts = [];
+        var partMap = [];
+        for (var i = 0; i < dateFormatParts.length; i++) {
+            var 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--;
+            }
+        }
+        var returnValue = new Mask();
+        returnValue.symbols = parts.join('');
+        returnValue.partMap = partMap;
+        return returnValue;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.merge = function (text, mask) {
+        // Important: right to left.
+        var resultText = '';
+        var resultFormat = '';
+        var format = mask.symbols;
+        for (var 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 {
+                var 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)) {
+                        var 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
+     */
+    DateObject.prototype.dateFieldName = function (part) {
+        var 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
+     */
+    DateObject.prototype.getNormalizedCenturyBase = function (twoDigitYear) {
+        return twoDigitYear > this.twoDigitYearMax ?
+            PREVIOUS_CENTURY_BASE :
+            CURRENT_CENTURY_BASE;
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.shouldNormalizeCentury = function () {
+        return this.intl.splitDateFormat(this.format).some(function (part) { return part.pattern === 'yy'; });
+    };
+    DateObject.prototype.resetInvalidDate = function () {
+        var _this = this;
+        this._partiallyInvalidDate.startDate = null;
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(function (key) {
+            _this.resetInvalidDatePart(key);
+        });
+    };
+    DateObject.prototype.resetInvalidDateSymbol = function (symbol) {
+        var _this = this;
+        this.resetInvalidDatePart(symbol);
+        var shouldResetInvalidDate = true;
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(function (key) {
+            if (_this._partiallyInvalidDate.invalidDateParts[key] &&
+                isPresent(_this._partiallyInvalidDate.invalidDateParts[key].value)) {
+                shouldResetInvalidDate = false;
+            }
+        });
+        if (shouldResetInvalidDate) {
+            this.resetInvalidDate();
+        }
+    };
+    DateObject.prototype.resetInvalidDatePart = function (symbol) {
+        if (this._partiallyInvalidDate.invalidDateParts[symbol]) {
+            this._partiallyInvalidDate.invalidDateParts[symbol] = {
+                value: null,
+                date: null,
+                startDateOffset: 0
+            };
+        }
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getInvalidDatePart = function (symbol) {
+        var invalidDatePart = this._partiallyInvalidDate.invalidDateParts[symbol];
+        return invalidDatePart || {};
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getInvalidDatePartValue = function (symbol) {
+        var invalidDatePart = this._partiallyInvalidDate.invalidDateParts[symbol];
+        return (invalidDatePart || {}).value;
+    };
+    DateObject.prototype.setInvalidDatePart = function (symbol, _a) {
+        var _b = _a.value, value = _b === void 0 ? null : _b, _c = _a.date, date = _c === void 0 ? null : _c, _d = _a.startDateOffset, startDateOffset = _d === void 0 ? 0 : _d, _e = _a.startDate, startDate = _e === void 0 ? null : _e;
+        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
+     */
+    DateObject.prototype.modifyDateSymbolWithOffset = function (date, symbol, offset) {
+        var newValue = cloneDate(date);
+        var 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
+     */
+    DateObject.prototype.modifyDateSymbolWithValue = function (date, symbol, value) {
+        var 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;
+    };
+    DateObject.prototype.markDatePartsAsExisting = function () {
+        this.modifyExisting(true);
+    };
+    return DateObject;
+}());
+export { DateObject };