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

package/dist/es/common/dateobject.js

@@ -1,7 +1,7 @@
 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 { extend, isPresent, cropTwoDigitYear, setYears, parseToInt, clamp, areDatePartsEqualTo, isNumber, isValidDate } from './utils';
 import { Constants } from './constants';
 var PREVIOUS_CENTURY_BASE = 1900;
 var CURRENT_CENTURY_BASE = 2000;
@@ -158,16 +158,18 @@ var DateObject = /** @class */ (function () {
                     partiallyInvalidText += text[i];
                 }
                 else if (this.getInvalidDatePartValue(symbol)) {
+                    var partsForSegment = this.getPartsForSegment(mask, i);
                     if (symbol === "M") {
-                        if (mask.partMap[i].pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD) {
+                        var datePartText = (parseToInt(this.getInvalidDatePartValue(symbol)) + JS_MONTH_OFFSET).toString();
+                        if (partsForSegment.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);
+                                var formattedDatePart = padZero(partsForSegment.length - datePartText.length) + datePartText;
+                                partiallyInvalidText += formattedDatePart;
+                                // add -1 as the first character in the segment is at index i
+                                i += partsForSegment.length - 1;
                             }
                             else {
                                 partiallyInvalidText += formattedDates[symbol][i];
@@ -176,8 +178,11 @@ var DateObject = /** @class */ (function () {
                     }
                     else {
                         if (this.getInvalidDatePartValue(symbol)) {
-                            partiallyInvalidText += this.getInvalidDatePartValue(symbol);
-                            i += Math.max(0, this.getInvalidDatePartValue(symbol).toString().length - 1);
+                            var datePartText = this.getInvalidDatePartValue(symbol).toString();
+                            var formattedDatePart = padZero(partsForSegment.length - datePartText.length) + datePartText;
+                            partiallyInvalidText += formattedDatePart;
+                            // add -1 as the first character in the segment is at index i
+                            i += partsForSegment.length - 1;
                         }
                         else {
                             partiallyInvalidText += formattedDates[symbol][i];
@@ -288,16 +293,18 @@ var DateObject = /** @class */ (function () {
         }
     };
     DateObject.prototype.modifyPart = function (symbol, offset) {
+        if (!isPresent(symbol) || !isPresent(offset) || offset === 0) {
+            return;
+        }
         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 isMonth = symbol === "M";
+        var isDay = symbol === "d" || symbol === "E";
+        var symbolExists = this.getExisting(symbol);
+        if (!this.autoCorrectParts && (isDay || isMonth)) {
             var invalidDateParts = this._partiallyInvalidDate.invalidDateParts || {};
-            var invalidDatePart = invalidDateParts[symbol];
+            var invalidDatePartValue = this.getInvalidDatePartValue(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();
@@ -316,33 +323,61 @@ var DateObject = /** @class */ (function () {
                 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;
+                // case 'h':
+                // case 'H': hour += offset; break;
+                // case 'm': minutes += offset; break;
+                // case 's': seconds += offset; break;
+                // case 'S': milliseconds += offset; break;
                 default: break;
             }
             if (symbol === "M") {
-                if ((month < 0 || month > 11) && this.getExisting(symbol)) {
-                    // do not cycle months
-                    this.setExisting(symbol, false);
-                    return;
+                if ((month < 0 || month > 11)) {
+                    if (symbolExists) {
+                        this.setExisting(symbol, false);
+                        this.resetInvalidDateSymbol(symbol);
+                        return;
+                    }
+                }
+                if (!symbolExists) {
+                    if (month < 0) {
+                        month = clamp(11 + ((month % 11) + 1), 0, 11);
+                    }
+                    else {
+                        var monthValue = isPresent(invalidDatePartValue) ?
+                            month :
+                            ((offset - JS_MONTH_OFFSET) % 12);
+                        month = clamp(monthValue, 0, 11);
+                    }
+                    month = clamp(month, 0, 11);
+                }
+                month = clamp(month, 0, 11);
+            }
+            else if (symbol === "d") {
+                if (symbolExists) {
+                    if (day <= 0 || day > 31) {
+                        this.setExisting(symbol, false);
+                        this.resetInvalidDateSymbol(symbol);
+                        return;
+                    }
+                }
+                else if (!symbolExists) {
+                    if (isPresent(invalidDatePartValue)) {
+                        if (day <= 0 || day > 31) {
+                            this.setExisting(symbol, false);
+                            this.resetInvalidDateSymbol(symbol);
+                            return;
+                        }
+                    }
+                    if (offset < 0) {
+                        var dayValue = isPresent(invalidDatePartValue) ? day : 1 + (31 - Math.abs(offset % 31));
+                        day = clamp(dayValue, 1, 31);
+                    }
+                    else {
+                        var dayValue = isPresent(invalidDatePartValue) ? day : offset % 31;
+                        day = clamp(dayValue, 1, 31);
+                    }
+                    day = clamp(day, 1, 31);
                 }
-                // 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 ?
@@ -439,92 +474,6 @@ var DateObject = /** @class */ (function () {
                     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) {
@@ -583,7 +532,7 @@ var DateObject = /** @class */ (function () {
      */
     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 symbol = _a.symbol, currentChar = _a.currentChar, resetSegmentValue = _a.resetSegmentValue, cycleSegmentValue = _a.cycleSegmentValue, rawInputValue = _a.rawTextValue, isDeleting = _a.isDeleting, originalFormat = _a.originalFormat;
         var isInCaretMode = !cycleSegmentValue;
         var dateParts = this.dateFormatString(this.value, this.format);
         var datePartsLiterals = dateParts.partMap
@@ -591,9 +540,20 @@ var DateObject = /** @class */ (function () {
             .map(function (x, index) {
             return {
                 datePartIndex: index,
-                literal: x.pattern
+                type: x.type,
+                pattern: x.pattern,
+                literal: ""
             };
         });
+        for (var i = 0; i < datePartsLiterals.length; i++) {
+            var datePart = datePartsLiterals[i];
+            for (var j = 0; j < datePart.pattern.length; j++) {
+                if (datePartsLiterals[i + j]) {
+                    datePartsLiterals[i + j].literal = datePart.pattern[j];
+                }
+            }
+            i += datePart.pattern.length - 1;
+        }
         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; });
@@ -606,9 +566,9 @@ var DateObject = /** @class */ (function () {
             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;
+                    var rawValueStartsWithLiteral = rawInputValue.startsWith(literal);
+                    var rawValueEndsWithLiteral = rawInputValue.endsWith(literal);
+                    var rawValueHasConsecutiveLiterals = rawInputValue.indexOf(literal + literal) >= 0;
                     if (rawValueStartsWithLiteral || rawValueEndsWithLiteral || rawValueHasConsecutiveLiterals) {
                         this.resetLeadingZero();
                         this.setExisting(symbol, false);
@@ -631,38 +591,82 @@ var DateObject = /** @class */ (function () {
         var prefix = '';
         var current = '';
         var datePartText = '';
+        var basePrefix = '';
+        var baseSuffix = '';
         var suffix = '';
+        var datePartStartIndex = originalFormat.indexOf(symbol);
+        var datePartEndIndex = originalFormat.lastIndexOf(symbol);
+        var segmentLength = datePartEndIndex - datePartStartIndex + 1;
+        var hasFixedFormat = (this.format === baseFormat) ||
+            (this.format === originalFormat) ||
+            (this.format.length === originalFormat.length);
         if (isInCaretMode) {
-            var datePartIndex = 0;
-            var outOfDatePartBounds = false;
+            var processedSegmentCharsCount = 0;
             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 || '';
+                    if (isDeleting) {
+                        // when deleting, process (segmentLength - 1) chars
+                        if (processedSegmentCharsCount < segmentLength - 1) {
+                            datePartText += rawInputValue[i] || "";
                         }
+                        processedSegmentCharsCount++;
+                    }
+                    else {
+                        datePartText += rawInputValue[i] || "";
                     }
                     replaced = true;
                 }
                 else if (!replaced) {
                     prefix += baseDate[i];
+                    basePrefix += baseDate[i];
                 }
                 else {
                     suffix += baseDate[i];
+                    baseSuffix += baseDate[i];
+                }
+            }
+            if (hasFixedFormat) {
+                if (originalFormat.length < rawInputValue.length) {
+                    datePartText += currentChar;
+                }
+                if (datePartText.length > segmentLength) {
+                    return extend(parseResult, { value: null, switchToNext: false });
+                }
+            }
+            else {
+                processedSegmentCharsCount = 0;
+                current = "";
+                datePartText = "";
+                prefix = "";
+                suffix = "";
+                replaced = false;
+                for (var i = 0; i < originalFormat.length; i++) {
+                    if (originalFormat[i] === symbol) {
+                        var existing = this.getExisting(symbol);
+                        current += existing ? baseDate[i] || "" : '0';
+                        if (isDeleting) {
+                            // when deleting, process (segmentLength - 1) chars
+                            if (processedSegmentCharsCount < segmentLength - 1) {
+                                datePartText += rawInputValue[i] || "";
+                            }
+                            processedSegmentCharsCount++;
+                        }
+                        else {
+                            datePartText += rawInputValue[i] || "";
+                        }
+                        replaced = true;
+                    }
+                    else if (!replaced) {
+                        prefix += rawInputValue[i] || "";
+                    }
+                    else {
+                        suffix += rawInputValue[i] || "";
+                    }
+                }
+                if (originalFormat.length < rawInputValue.length) {
+                    datePartText += currentChar;
                 }
             }
         }
@@ -697,10 +701,6 @@ var DateObject = /** @class */ (function () {
         }
         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);
@@ -716,14 +716,30 @@ var DateObject = /** @class */ (function () {
             if (!this.autoCorrectParts) {
                 tryParse = false;
             }
-            var middle = resetSegmentValue ? currentChar : (current.substring(i) + currentChar);
-            if (!tryParse && isInCaretMode) {
+            var middle = resetSegmentValue ?
+                currentChar :
+                isInCaretMode ?
+                    datePartText :
+                    (current.substring(i) + currentChar);
+            if (isInCaretMode) {
                 // try to make an exact match as there will be only 1 attempt
+                tryParse = false;
                 middle = unpadZero(middle);
             }
             var middleNumber = parseInt(middle, 10);
             var candidateDateString = prefix + middle + suffix;
             parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            if (isInCaretMode && !hasFixedFormat && !isValidDate(parsedDate)) {
+                // if part of the date is not available, e.g. "d"
+                // but an expanded format like "F" is used
+                // the element value can be "EEEE, February 1, 2022 3:04:05 AM"
+                // which is not parsable by intl
+                // use the base prefix and suffix, e.g. convert the candidate date string
+                // to "Thursday, February 1, 2022 3:04:05 AM"
+                // as "EEEE, February..." is not parsable
+                parsedDate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+                datePartText = middle;
+            }
             var isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
             if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable) {
                 if (symbol === MONTH_SYMBOL && !month) {
@@ -739,23 +755,47 @@ var DateObject = /** @class */ (function () {
                 }
                 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()) {
+                    if (((isInCaretMode && isValidDate(parsedDate)) ||
+                        (!isInCaretMode && parsedDate)) && this.date && parsedDate.getDate() !== this.value.getDate()) {
                         parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
                     }
                 }
             }
-            if (parsedDate) {
+            if ((isInCaretMode && isValidDate(parsedDate)) || (!isInCaretMode && 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;
+                var leadingZeroOffset = (this.leadingZero || {})[symbol] || 0;
+                var patternSatisfied = (leadingZeroOffset + (unpadZero(middle) || currentChar).length) >= patternLength;
+                var switchToNext = peekDate === null ||
+                    (leadingZero[symbol] && patternValue.length <= middle.length) ||
+                    patternSatisfied;
                 if (this.shouldNormalizeCentury()) {
                     parsedDate = this.normalizeCentury(parsedDate);
                 }
                 this._value = parsedDate;
                 this.setExisting(symbol, true);
+                if (isInCaretMode && switchToNext) {
+                    if (symbol === "M") {
+                        if (segmentLength <= MONTH_PART_WITH_WORDS_THRESHOLD) {
+                            var datePartValue = parseToInt(datePartText);
+                            if (datePartValue >= 2) {
+                                switchToNext = true;
+                            }
+                            else {
+                                switchToNext = false;
+                            }
+                        }
+                    }
+                    else {
+                        switchToNext = switchToNext ?
+                            hasFixedFormat ?
+                                datePartText.length === segmentLength :
+                                datePartText.length > segmentLength :
+                            switchToNext;
+                    }
+                }
                 return extend(parseResult, { value: this.value, switchToNext: switchToNext });
             }
         }
@@ -778,6 +818,9 @@ var DateObject = /** @class */ (function () {
             this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? (_b = {}, _b[symbol] = true, _b) : null;
             this.setExisting(symbol, false);
         }
+        if (isInCaretMode && datePartText.length > segmentLength) {
+            return extend(parseResult, { value: null, switchToNext: false });
+        }
         if (!this.autoCorrectParts) {
             this.setExisting(symbol, false);
             // todo check if string is better
@@ -793,11 +836,14 @@ var DateObject = /** @class */ (function () {
             }
             if (isNumber(datePartValue)) {
                 var newDate = this.modifyDateSymbolWithValue(this.value, symbol, datePartValue);
+                // if (!isEqual(newDate, this.value)) {
+                this.setExisting(symbol, false);
                 this.setInvalidDatePart(symbol, {
                     value: datePartValue,
                     date: cloneDate(newDate),
                     startDate: this._partiallyInvalidDate.startDate || cloneDate(this.value)
                 });
+                // }
             }
         }
         return extend(parseResult, { value: null, switchToNext: false });
@@ -961,24 +1007,68 @@ var DateObject = /** @class */ (function () {
         var resultText = '';
         var resultFormat = '';
         var format = mask.symbols;
+        var processTextSymbolsEnded = false;
+        var ignoreFormatSymbolsCount = 0;
+        var formattedDates = this.getFormattedInvalidDates(format);
         for (var formatSymbolIndex = format.length - 1; formatSymbolIndex >= 0; formatSymbolIndex--) {
+            var partsForSegment = this.getPartsForSegment(mask, formatSymbolIndex);
             if (this.knownParts.indexOf(format[formatSymbolIndex]) === -1 || this.getExisting(format[formatSymbolIndex])) {
-                resultText = text[formatSymbolIndex] + resultText;
+                if (this.autoCorrectParts) {
+                    resultText = text[formatSymbolIndex] + resultText;
+                }
+                else {
+                    if (text.length !== format.length) {
+                        if (processTextSymbolsEnded) {
+                            resultText = text[formatSymbolIndex] + resultText;
+                        }
+                        else if (ignoreFormatSymbolsCount > 0) {
+                            resultText = text[formatSymbolIndex] + resultText;
+                            ignoreFormatSymbolsCount--;
+                            if (ignoreFormatSymbolsCount <= 0) {
+                                processTextSymbolsEnded = true;
+                            }
+                        }
+                        else {
+                            resultText = (text[formatSymbolIndex + text.length - format.length] || "") + resultText;
+                        }
+                    }
+                    else {
+                        resultText = text[formatSymbolIndex] + resultText;
+                    }
+                }
                 resultFormat = format[formatSymbolIndex] + resultFormat;
             }
             else {
                 var symbol = format[formatSymbolIndex];
-                while (formatSymbolIndex >= 0 && symbol === format[formatSymbolIndex]) {
-                    formatSymbolIndex--;
+                var formatSymbolIndexModifier = 0;
+                if (this.autoCorrectParts || (!this.autoCorrectParts && !this.getInvalidDatePartValue(symbol))) {
+                    while (formatSymbolIndex >= 0 && symbol === format[formatSymbolIndex]) {
+                        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;
+                        var datePartText = this.getInvalidDatePartValue(symbol).toString();
+                        if (symbol === "M") {
+                            datePartText = (parseToInt(this.getInvalidDatePartValue(symbol)) + JS_MONTH_OFFSET).toString();
+                            if (partsForSegment.length > MONTH_PART_WITH_WORDS_THRESHOLD) {
+                                resultText = formattedDates[symbol][formatSymbolIndex] + resultText;
+                            }
+                            else {
+                                datePartText = (parseToInt(this.getInvalidDatePartValue(symbol)) + JS_MONTH_OFFSET).toString();
+                                resultText = datePartText + resultText;
+                                ignoreFormatSymbolsCount = datePartText.length - partsForSegment.length;
+                            }
+                        }
+                        else {
+                            resultText = datePartText + resultText;
+                            formatSymbolIndexModifier = datePartText.length - 1;
+                            ignoreFormatSymbolsCount = datePartText.length - partsForSegment.length;
+                        }
                     }
                     else {
                         resultText = this.dateFieldName(mask.partMap[formatSymbolIndex]) + resultText;
@@ -987,6 +1077,9 @@ var DateObject = /** @class */ (function () {
                 while (resultFormat.length < resultText.length) {
                     resultFormat = format[formatSymbolIndex] + resultFormat;
                 }
+                if (formatSymbolIndexModifier !== 0) {
+                    formatSymbolIndex = (formatSymbolIndex - formatSymbolIndexModifier) + (text.length - format.length);
+                }
             }
         }
         return { text: resultText, format: resultFormat };
@@ -1154,6 +1247,32 @@ var DateObject = /** @class */ (function () {
     DateObject.prototype.markDatePartsAsExisting = function () {
         this.modifyExisting(true);
     };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getPartsForSegment = function (mask, partIndex) {
+        var segmentPart = mask.partMap[partIndex];
+        var partsForSegment = [];
+        for (var maskPartIndex = partIndex; maskPartIndex < mask.partMap.length; maskPartIndex++) {
+            var part = mask.partMap[maskPartIndex];
+            if (segmentPart.type === part.type && segmentPart.pattern === part.pattern) {
+                partsForSegment.push(part);
+            }
+            else {
+                break;
+            }
+        }
+        for (var maskPartIndex = partIndex - 1; maskPartIndex >= 0; maskPartIndex--) {
+            var part = mask.partMap[maskPartIndex];
+            if (segmentPart.type === part.type && segmentPart.pattern === part.pattern) {
+                partsForSegment.unshift(part);
+            }
+            else {
+                break;
+            }
+        }
+        return partsForSegment;
+    };
     return DateObject;
 }());
 export { DateObject };

package/dist/es/common/utils.js

@@ -125,4 +125,4 @@ export var areDatePartsEqualTo = function (date, year, month, day, hour, minutes
 /**
  * @hidden
  */
-export var isDate = function (value) { return isPresent(value) && value.getTime && isNumber(value.getTime()); };
+export var isValidDate = function (value) { return isPresent(value) && value.getTime && isNumber(value.getTime()); };