@progress/kendo-dateinputs-common 0.2.0-dev.202301131210 → 0.2.0-dev.202301171717

package/dist/es2015/common/dateobject.js

@@ -530,6 +530,14 @@ export class DateObject {
                 literal: ""
             };
         });
+        const flatDateParts = dateParts.partMap
+            .map((x) => {
+            return {
+                type: x.type,
+                pattern: x.pattern,
+                text: ""
+            };
+        });
         for (let i = 0; i < datePartsLiterals.length; i++) {
             const datePart = datePartsLiterals[i];
             for (let j = 0; j < datePart.pattern.length; j++) {
@@ -539,13 +547,23 @@ export class DateObject {
             }
             i += datePart.pattern.length - 1;
         }
+        for (let i = 0; i < flatDateParts.length; i++) {
+            const datePart = flatDateParts[i];
+            for (let j = 0; j < datePart.pattern.length; j++) {
+                if (flatDateParts[i + j]) {
+                    flatDateParts[i + j].text = 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);
         let parseResult = {
             value: null,
             switchPart: false,
-            resetPart: shouldResetPart
+            resetPart: shouldResetPart,
+            hasInvalidDatePart: false
         };
         if (!currentChar) {
             if (isInCaretMode) {
@@ -579,14 +597,20 @@ export class DateObject {
         let basePrefix = '';
         let baseSuffix = '';
         let suffix = '';
-        const datePartStartIndex = originalFormat.indexOf(symbol);
-        const datePartEndIndex = originalFormat.lastIndexOf(symbol);
-        const segmentLength = datePartEndIndex - datePartStartIndex + 1;
+        let convertedBaseFormat = "";
+        for (let i = 0; i < flatDateParts.length; i++) {
+            convertedBaseFormat += flatDateParts[i].text;
+        }
         const hasFixedFormat = (this.format === baseFormat) ||
+            (this.format === convertedBaseFormat) ||
             (this.format === originalFormat) ||
             (this.format.length === originalFormat.length);
-        if (isInCaretMode) {
-            let processedSegmentCharsCount = 0;
+        const datePartStartIndex = (hasFixedFormat ? convertedBaseFormat : originalFormat).indexOf(symbol);
+        const datePartEndIndex = (hasFixedFormat ? convertedBaseFormat : originalFormat).lastIndexOf(symbol);
+        const segmentLength = datePartEndIndex - datePartStartIndex + 1;
+        let processedSegmentCharsCount = 0;
+        let formatToTextLengthDiff = originalFormat.length - rawInputValue.length;
+        if (isInCaretMode || (!isInCaretMode && !this.autoCorrectParts)) {
             for (let i = 0; i < baseDate.length; i++) {
                 if (baseFormat[i] === symbol) {
                     const existing = this.getExisting(symbol);
@@ -598,6 +622,11 @@ export class DateObject {
                         }
                         processedSegmentCharsCount++;
                     }
+                    else if (formatToTextLengthDiff > 0) {
+                        if (datePartText.length + formatToTextLengthDiff < segmentLength) {
+                            datePartText += rawInputValue[i] || "";
+                        }
+                    }
                     else {
                         datePartText += rawInputValue[i] || "";
                     }
@@ -613,12 +642,12 @@ export class DateObject {
                 }
             }
             if (hasFixedFormat) {
-                if (originalFormat.length < rawInputValue.length) {
+                if (convertedBaseFormat.length < rawInputValue.length) {
                     datePartText += currentChar;
                 }
                 else if (!isDeleting && originalFormat.length > rawInputValue.length) {
                     const lengthDiff = originalFormat.length - rawInputValue.length;
-                    const trimmedDatePartText = datePartText.substring(0, datePartText.length - lengthDiff);
+                    const trimmedDatePartText = datePartText.substr(0, datePartText.length - lengthDiff);
                     if (trimmedDatePartText && trimmedDatePartText.length > 0) {
                         datePartText = trimmedDatePartText;
                     }
@@ -627,7 +656,7 @@ export class DateObject {
                     return extend(parseResult, { value: null, switchToNext: false });
                 }
             }
-            else {
+            if (!hasFixedFormat || (hasFixedFormat && !this.autoCorrectParts)) {
                 processedSegmentCharsCount = 0;
                 current = "";
                 datePartText = "";
@@ -645,6 +674,11 @@ export class DateObject {
                             }
                             processedSegmentCharsCount++;
                         }
+                        else if (formatToTextLengthDiff > 0) {
+                            if (datePartText.length + formatToTextLengthDiff < segmentLength) {
+                                datePartText += rawInputValue[i] || "";
+                            }
+                        }
                         else {
                             datePartText += rawInputValue[i] || "";
                         }
@@ -654,43 +688,52 @@ export class DateObject {
                         prefix += rawInputValue[i] || "";
                     }
                     else {
-                        suffix += rawInputValue[i] || "";
+                        suffix += rawInputValue[i - formatToTextLengthDiff] || "";
                     }
                 }
                 if (originalFormat.length < rawInputValue.length) {
                     datePartText += currentChar;
                 }
-                else if (!isDeleting && originalFormat.length > rawInputValue.length) {
-                    const lengthDiff = originalFormat.length - rawInputValue.length;
-                    const trimmedDatePartText = datePartText.substring(0, datePartText.length - lengthDiff);
-                    if (trimmedDatePartText && trimmedDatePartText.length > 0) {
-                        datePartText = trimmedDatePartText;
-                    }
-                }
             }
         }
-        else {
-            for (let i = 0; i < baseDate.length; i++) {
-                if (baseFormat[i] === symbol) {
-                    const existing = this.getExisting(symbol);
-                    current += existing ? baseDate[i] : '0';
-                    replaced = true;
-                }
-                else if (!replaced) {
-                    prefix += baseDate[i];
-                }
-                else {
-                    suffix += baseDate[i];
+        if (!isInCaretMode) {
+            if (this.autoCorrectParts) {
+                processedSegmentCharsCount = 0;
+                current = "";
+                datePartText = "";
+                prefix = "";
+                suffix = "";
+                replaced = false;
+                for (let i = 0; i < baseDate.length; i++) {
+                    if (baseFormat[i] === symbol) {
+                        const existing = this.getExisting(symbol);
+                        current += existing ? baseDate[i] : '0';
+                        replaced = true;
+                    }
+                    else if (!replaced) {
+                        prefix += baseDate[i];
+                    }
+                    else {
+                        suffix += baseDate[i];
+                    }
                 }
             }
+            else {
+                current = resetSegmentValue ? datePartText : current;
+            }
         }
         let parsedDate = null;
-        const month = this.matchMonth(currentChar);
+        let month = this.matchMonth(currentChar);
         const dayPeriod = this.matchDayPeriod(currentChar, symbol);
         const isZeroCurrentChar = currentChar === '0';
         const leadingZero = this.leadingZero || {};
-        if (isZeroCurrentChar && !isInCaretMode) {
-            let valueNumber = parseInt(resetSegmentValue ? currentChar : current + currentChar, 10);
+        if (isZeroCurrentChar) {
+            if (datePartText === "0") {
+                datePartText = current;
+            }
+            let valueNumber = parseToInt(resetSegmentValue ?
+                currentChar :
+                (isInCaretMode ? datePartText : current) + currentChar);
             if (valueNumber === 0 && !this.isAbbrMonth(dateParts.partMap, symbol)) {
                 this.incrementLeadingZero(symbol);
             }
@@ -708,32 +751,25 @@ export class DateObject {
         }
         const currentMaxLength = current.length - 3;
         let tryParse = true;
+        let middle = isInCaretMode ? datePartText : current;
         for (let i = Math.max(0, currentMaxLength); i <= current.length; i++) {
             if (!tryParse) {
                 break;
             }
-            let middle = resetSegmentValue ?
+            middle = resetSegmentValue ?
                 currentChar :
                 isInCaretMode ?
                     datePartText :
                     (current.substring(i) + currentChar);
-            if (!this.autoCorrectParts) {
-                tryParse = false;
-                if (!isInCaretMode) {
-                    // try to make an exact match as there will be only 1 attempt
-                    middle = unpadZero(middle);
-                    middle = padZero(segmentLength - middle.length) + middle;
-                }
-            }
-            if (isInCaretMode) {
-                // try to make an exact match as there will be only 1 attempt
+            if (isInCaretMode || !this.autoCorrectParts) {
                 tryParse = false;
                 middle = unpadZero(middle);
+                middle = padZero(segmentLength - middle.length) + 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 (isInCaretMode && !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"
@@ -741,11 +777,12 @@ export class DateObject {
                 // 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;
+                if (this.autoCorrectParts) {
+                    parsedDate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+                }
             }
             const isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
-            if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable) {
+            if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable && this.autoCorrectParts) {
                 if (symbol === MONTH_SYMBOL && !month) {
                     // JS months start from 0 (January) instead of 1 (January)
                     const monthNumber = middleNumber - JS_MONTH_OFFSET;
@@ -780,16 +817,34 @@ export class DateObject {
                 }
                 this._value = parsedDate;
                 this.setExisting(symbol, true);
+                this.resetInvalidDateSymbol(symbol);
+                if (!this.autoCorrectParts) {
+                    if (symbol === "M") {
+                        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 if (symbol === "d") {
+                        if (this.getExisting("d") && this.getExisting("y")) {
+                            // changing from 31/Jan to 31/Feb to 28/Feb
+                            this.setExisting("M", true);
+                            this.resetInvalidDateSymbol("M");
+                        }
+                    }
+                    if (!this.hasInvalidDatePart()) {
+                        this.markDatePartsAsExisting();
+                    }
+                }
                 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;
-                            }
+                        const datePartValue = parseToInt(datePartText);
+                        if (datePartValue >= 2 || datePartText.length >= 2) {
+                            switchToNext = true;
+                        }
+                        else {
+                            switchToNext = false;
                         }
                     }
                     else {
@@ -822,29 +877,157 @@ 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);
             let datePartValue;
-            const textToParse = isInCaretMode ? datePartText : current;
+            const textToParse = isInCaretMode ? datePartText : middle;
             const parsedValue = parseToInt(textToParse);
             if (isNumber(parsedValue)) {
+                if ((symbol === "d" && (parsedValue <= 0 || parsedValue > 31)) ||
+                    (symbol === "M" && (parsedValue < 0 || parsedValue > 11))) {
+                    return extend(parseResult, { value: null, switchToNext: false });
+                }
                 datePartValue = symbol === "M" ?
-                    clamp(parsedValue - JS_MONTH_OFFSET, 0, 12 - JS_MONTH_OFFSET) :
+                    parsedValue - JS_MONTH_OFFSET :
                     parsedValue;
-            }
-            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)
+                const isMonth = symbol === "M";
+                const isDay = symbol === "d";
+                let newValue = cloneDate(this._value);
+                const invalidDateParts = this._partiallyInvalidDate.invalidDateParts || {};
+                let year = invalidDateParts.y.value || newValue.getFullYear();
+                /* tslint:disable:no-shadowed-variable */
+                let month = isMonth ? datePartValue : invalidDateParts.M.value || newValue.getMonth();
+                /* tslint:enable:no-shadowed-variable */
+                let day = isDay ? datePartValue : invalidDateParts.d.value || invalidDateParts.E.value || newValue.getDate();
+                let hour = invalidDateParts.h.value || invalidDateParts.H.value || newValue.getHours();
+                let minutes = invalidDateParts.m.value || newValue.getMinutes();
+                let seconds = invalidDateParts.s.value || newValue.getSeconds();
+                let milliseconds = invalidDateParts.S.value || newValue.getMilliseconds();
+                const dateCandidate = createDate(year, month, day, hour, minutes, seconds, milliseconds);
+                const dateCandidateExists = areDatePartsEqualTo(dateCandidate, year, month, day, hour, minutes, seconds, milliseconds);
+                const newValueCandidate = isMonth || isDay ?
+                    this.modifyDateSymbolWithValue(newValue, symbol, isMonth ? month : day) :
+                    null;
+                let invalidDateFound = false;
+                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);
+                    }
+                }
+                if (!invalidDateFound) {
+                    this.setExisting(symbol, true);
+                    if (isInCaretMode && !isValidDate(parsedDate)) {
+                        const valueCandidate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+                        if (isValidDate(valueCandidate)) {
+                            this._value = valueCandidate;
+                        }
+                    }
+                    else {
+                        this._value = newValue;
+                    }
+                    if (this.getValue()) {
+                        this.resetInvalidDate();
+                    }
+                }
+                let switchToNext = false;
+                if (symbol === "M") {
+                    if (parsedValue >= 2 || textToParse.length >= 2) {
+                        switchToNext = true;
+                    }
+                    else {
+                        switchToNext = false;
+                    }
+                }
+                else {
+                    switchToNext = hasFixedFormat ?
+                        textToParse.length === segmentLength :
+                        textToParse.length > segmentLength;
+                }
+                return extend(parseResult, {
+                    value: null,
+                    switchToNext: switchToNext,
+                    hasInvalidDatePart: invalidDateFound
                 });
-                // }
             }
         }
         return extend(parseResult, { value: null, switchToNext: false });
@@ -866,6 +1049,12 @@ export class DateObject {
     setLeadingZero(leadingZero) {
         this.leadingZero = leadingZero;
     }
+    /**
+     * @hidden
+     */
+    getLeadingZero() {
+        return this.leadingZero || {};
+    }
     /**
      * @hidden
      */
@@ -948,7 +1137,6 @@ export class DateObject {
         const dateFormatParts = this.intl.splitDateFormat(this.format, this.localeId);
         for (let i = 0; i < dateFormatParts.length; i++) {
             if (dateFormatParts[i].type === 'month' && dateFormatParts[i].names) {
-                // return this.intl.dateFormatNames(dateFormatParts[i].names);
                 return this.intl.dateFormatNames(locale, dateFormatParts[i].names);
             }
         }
@@ -1059,13 +1247,16 @@ export class DateObject {
                             }
                             else {
                                 datePartText = (parseToInt(this.getInvalidDatePartValue(symbol)) + JS_MONTH_OFFSET).toString();
-                                resultText = datePartText + resultText;
+                                const formattedDatePart = padZero(partsForSegment.length - datePartText.length) + datePartText;
+                                resultText = formattedDatePart + resultText;
+                                formatSymbolIndexModifier = partsForSegment.length - 1;
                                 ignoreFormatSymbolsCount = datePartText.length - partsForSegment.length;
                             }
                         }
                         else {
-                            resultText = datePartText + resultText;
-                            formatSymbolIndexModifier = datePartText.length - 1;
+                            const formattedDatePart = padZero(partsForSegment.length - datePartText.length) + datePartText;
+                            resultText = formattedDatePart + resultText;
+                            formatSymbolIndexModifier = partsForSegment.length - 1;
                             ignoreFormatSymbolsCount = datePartText.length - partsForSegment.length;
                         }
                     }
@@ -1160,6 +1351,19 @@ export class DateObject {
             this._partiallyInvalidDate.startDate = startDate;
         }
     }
+    /**
+     * @hidden
+     */
+    hasInvalidDatePart() {
+        let hasInvalidDatePart = false;
+        Object.keys(this._partiallyInvalidDate.invalidDateParts).forEach(key => {
+            if (this._partiallyInvalidDate.invalidDateParts[key] &&
+                isPresent(this._partiallyInvalidDate.invalidDateParts[key].value)) {
+                hasInvalidDatePart = true;
+            }
+        });
+        return hasInvalidDatePart;
+    }
     /**
      * @hidden
      */