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

package/dist/es2015/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';
 const PREVIOUS_CENTURY_BASE = 1900;
 const CURRENT_CENTURY_BASE = 2000;
@@ -147,16 +147,18 @@ export class DateObject {
                     partiallyInvalidText += text[i];
                 }
                 else if (this.getInvalidDatePartValue(symbol)) {
+                    const partsForSegment = this.getPartsForSegment(mask, i);
                     if (symbol === "M") {
-                        if (mask.partMap[i].pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD) {
+                        const 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)) {
-                                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);
+                                const 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];
@@ -165,8 +167,11 @@ export class DateObject {
                     }
                     else {
                         if (this.getInvalidDatePartValue(symbol)) {
-                            partiallyInvalidText += this.getInvalidDatePartValue(symbol);
-                            i += Math.max(0, this.getInvalidDatePartValue(symbol).toString().length - 1);
+                            const datePartText = this.getInvalidDatePartValue(symbol).toString();
+                            const 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];
@@ -275,16 +280,18 @@ export class DateObject {
         }
     }
     modifyPart(symbol, offset) {
+        if (!isPresent(symbol) || !isPresent(offset) || offset === 0) {
+            return;
+        }
         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 isMonth = symbol === "M";
+        const isDay = symbol === "d" || symbol === "E";
+        const symbolExists = this.getExisting(symbol);
+        if (!this.autoCorrectParts && (isDay || isMonth)) {
             const invalidDateParts = this._partiallyInvalidDate.invalidDateParts || {};
-            const invalidDatePart = invalidDateParts[symbol];
+            const invalidDatePartValue = this.getInvalidDatePartValue(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();
@@ -303,33 +310,61 @@ export class DateObject {
                 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 {
+                        const 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) {
+                        const dayValue = isPresent(invalidDatePartValue) ? day : 1 + (31 - Math.abs(offset % 31));
+                        day = clamp(dayValue, 1, 31);
+                    }
+                    else {
+                        const 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;
-                // }
             }
             const dateCandidate = createDate(year, month, day, hour, minutes, seconds, milliseconds);
             const newValueCandidate = isMonth || isDay ?
@@ -426,92 +461,6 @@ export class DateObject {
                     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) {
@@ -568,7 +517,7 @@ export class DateObject {
     /**
      * @hidden
      */
-    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue, isDeleting }) {
+    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue: rawInputValue, isDeleting, originalFormat }) {
         const isInCaretMode = !cycleSegmentValue;
         const dateParts = this.dateFormatString(this.value, this.format);
         const datePartsLiterals = dateParts.partMap
@@ -576,9 +525,20 @@ export class DateObject {
             .map((x, index) => {
             return {
                 datePartIndex: index,
-                literal: x.pattern
+                type: x.type,
+                pattern: x.pattern,
+                literal: ""
             };
         });
+        for (let i = 0; i < datePartsLiterals.length; i++) {
+            const datePart = datePartsLiterals[i];
+            for (let j = 0; j < datePart.pattern.length; j++) {
+                if (datePartsLiterals[i + j]) {
+                    datePartsLiterals[i + j].literal = datePart.pattern[j];
+                }
+            }
+            i += datePart.pattern.length - 1;
+        }
         let shouldResetPart = isInCaretMode && symbol === "M" && dateParts.partMap
             .filter(x => x.type === "month")
             .some(x => x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD);
@@ -591,9 +551,9 @@ export class DateObject {
             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;
+                    const rawValueStartsWithLiteral = rawInputValue.startsWith(literal);
+                    const rawValueEndsWithLiteral = rawInputValue.endsWith(literal);
+                    const rawValueHasConsecutiveLiterals = rawInputValue.indexOf(literal + literal) >= 0;
                     if (rawValueStartsWithLiteral || rawValueEndsWithLiteral || rawValueHasConsecutiveLiterals) {
                         this.resetLeadingZero();
                         this.setExisting(symbol, false);
@@ -616,38 +576,82 @@ export class DateObject {
         let prefix = '';
         let current = '';
         let datePartText = '';
+        let basePrefix = '';
+        let baseSuffix = '';
         let suffix = '';
+        const datePartStartIndex = originalFormat.indexOf(symbol);
+        const datePartEndIndex = originalFormat.lastIndexOf(symbol);
+        const segmentLength = datePartEndIndex - datePartStartIndex + 1;
+        const hasFixedFormat = (this.format === baseFormat) ||
+            (this.format === originalFormat) ||
+            (this.format.length === originalFormat.length);
         if (isInCaretMode) {
-            let datePartIndex = 0;
-            let outOfDatePartBounds = false;
+            let processedSegmentCharsCount = 0;
             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 || '';
+                    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 (let i = 0; i < originalFormat.length; i++) {
+                    if (originalFormat[i] === symbol) {
+                        const 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;
                 }
             }
         }
@@ -682,10 +686,6 @@ export class DateObject {
         }
         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);
@@ -701,14 +701,30 @@ export class DateObject {
             if (!this.autoCorrectParts) {
                 tryParse = false;
             }
-            let middle = resetSegmentValue ? currentChar : (current.substring(i) + currentChar);
-            if (!tryParse && isInCaretMode) {
+            let 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);
             }
             let middleNumber = parseInt(middle, 10);
             const 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;
+            }
             const isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
             if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable) {
                 if (symbol === MONTH_SYMBOL && !month) {
@@ -724,23 +740,47 @@ export class DateObject {
                 }
                 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
                 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;
+                const leadingZeroOffset = (this.leadingZero || {})[symbol] || 0;
+                const patternSatisfied = (leadingZeroOffset + (unpadZero(middle) || currentChar).length) >= patternLength;
+                let 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) {
+                            const 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 });
             }
         }
@@ -763,6 +803,9 @@ export class DateObject {
             this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? { [symbol]: true } : 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
@@ -778,11 +821,14 @@ export class DateObject {
             }
             if (isNumber(datePartValue)) {
                 const 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 });
@@ -944,24 +990,68 @@ export class DateObject {
         let resultText = '';
         let resultFormat = '';
         let format = mask.symbols;
+        let processTextSymbolsEnded = false;
+        let ignoreFormatSymbolsCount = 0;
+        const formattedDates = this.getFormattedInvalidDates(format);
         for (let formatSymbolIndex = format.length - 1; formatSymbolIndex >= 0; formatSymbolIndex--) {
+            const 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 {
                 const symbol = format[formatSymbolIndex];
-                while (formatSymbolIndex >= 0 && symbol === format[formatSymbolIndex]) {
-                    formatSymbolIndex--;
+                let 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)) {
-                        const segmentText = text.substr(formatSymbolIndex, mask.partMap[formatSymbolIndex].pattern.length);
-                        resultText = segmentText + resultText;
+                        let 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;
@@ -970,6 +1060,9 @@ export class DateObject {
                 while (resultFormat.length < resultText.length) {
                     resultFormat = format[formatSymbolIndex] + resultFormat;
                 }
+                if (formatSymbolIndexModifier !== 0) {
+                    formatSymbolIndex = (formatSymbolIndex - formatSymbolIndexModifier) + (text.length - format.length);
+                }
             }
         }
         return { text: resultText, format: resultFormat };
@@ -1134,4 +1227,30 @@ export class DateObject {
     markDatePartsAsExisting() {
         this.modifyExisting(true);
     }
+    /**
+     * @hidden
+     */
+    getPartsForSegment(mask, partIndex) {
+        const segmentPart = mask.partMap[partIndex];
+        const partsForSegment = [];
+        for (let maskPartIndex = partIndex; maskPartIndex < mask.partMap.length; maskPartIndex++) {
+            const part = mask.partMap[maskPartIndex];
+            if (segmentPart.type === part.type && segmentPart.pattern === part.pattern) {
+                partsForSegment.push(part);
+            }
+            else {
+                break;
+            }
+        }
+        for (let maskPartIndex = partIndex - 1; maskPartIndex >= 0; maskPartIndex--) {
+            const part = mask.partMap[maskPartIndex];
+            if (segmentPart.type === part.type && segmentPart.pattern === part.pattern) {
+                partsForSegment.unshift(part);
+            }
+            else {
+                break;
+            }
+        }
+        return partsForSegment;
+    }
 }

package/dist/es2015/common/utils.js

@@ -114,4 +114,4 @@ export const areDatePartsEqualTo = (date, year, month, day, hour, minutes, secon
 /**
  * @hidden
  */
-export const isDate = (value) => isPresent(value) && value.getTime && isNumber(value.getTime());
+export const isValidDate = (value) => isPresent(value) && value.getTime && isNumber(value.getTime());