@progress/kendo-dateinputs-common 0.2.0-dev.202301231327 → 0.2.0-dev.202301241303

package/dist/es2015/dateinput/dateinput.js

@@ -28,7 +28,6 @@ const FOCUS_END = "focusEnd";
 const CHANGE = "change";
 const defaultDateInputOptions = {
     format: "d",
-    allowNulls: false,
     hasPlaceholder: false,
     placeholder: null,
     cycleTime: true,
@@ -56,6 +55,7 @@ const defaultDateInputOptions = {
         [CHANGE]: null
     },
     selectNearestSegmentOnFocus: false,
+    selectPreviousSegmentOnBackspace: false,
     enableMouseWheel: false,
     allowCaretMode: false,
     autoSwitchParts: true,
@@ -202,6 +202,7 @@ export class DateInput extends Observable {
      */
     onElementClick(e) {
         this.mouseDownStarted = false;
+        this.switchedPartOnPreviousKeyAction = false;
         const selection = this.selection;
         if (this.isInCaretMode()) {
             // explicitly refresh the input element value
@@ -234,12 +235,10 @@ export class DateInput extends Observable {
      */
     onElementInput(e) {
         this.triggerInput({ event: e });
-        const keyDownEvent = this.keyDownEvent || {};
-        const isBackspaceKey = keyDownEvent.keyCode === KeyCode.BACKSPACE || keyDownEvent.key === Key.BACKSPACE;
-        const isDeleteKey = keyDownEvent.keyCode === KeyCode.DELETE || keyDownEvent.key === Key.DELETE;
         if (!this.element || !this.dateObject) {
             return;
         }
+        const switchedPartOnPreviousKeyAction = this.switchedPartOnPreviousKeyAction;
         if (this.isPasteInProgress) {
             if (this.options.allowCaretMode) {
                 // pasting should leave the input with caret
@@ -250,6 +249,9 @@ export class DateInput extends Observable {
             this.isPasteInProgress = false;
             return;
         }
+        const keyDownEvent = this.keyDownEvent || {};
+        const isBackspaceKey = keyDownEvent.keyCode === KeyCode.BACKSPACE || keyDownEvent.key === Key.BACKSPACE;
+        const isDeleteKey = keyDownEvent.keyCode === KeyCode.DELETE || keyDownEvent.key === Key.DELETE;
         const originalInteractionMode = this.interactionMode;
         if (this.options.allowCaretMode &&
             originalInteractionMode !== DateInputInteractionMode.Caret &&
@@ -268,50 +270,36 @@ export class DateInput extends Observable {
             this.restorePreviousInputEventState();
             return;
         }
-        const oldDateObjectValue = this.dateObject && this.dateObject.getValue();
+        const oldExistingDateValue = this.dateObject && this.dateObject.getValue();
+        const oldDateValue = this.dateObject ? this.dateObject.value : null;
         const { text: currentText, format: currentFormat } = this.dateObject.getTextAndFormat();
         this.currentFormat = currentFormat;
-        let text = "";
+        let oldText = "";
         if (hasCaret) {
             if (isBackspaceKey || isDeleteKey) {
-                text = this.previousElementValue;
+                oldText = this.previousElementValue;
             }
             else if (originalInteractionMode === DateInputInteractionMode.Caret) {
-                text = this.previousElementValue;
+                oldText = this.previousElementValue;
             }
             else {
-                text = currentText;
+                oldText = currentText;
             }
         }
         else {
-            text = currentText;
+            oldText = currentText;
         }
         const newText = this.elementValue;
         let diff = approximateStringMatching({
-            oldText: text,
+            oldText: oldText,
             newText: newText,
             formatPattern: this.currentFormat,
             selectionStart: this.selection.start,
             isInCaretMode: hasCaret,
             keyEvent: this.keyDownEvent
         });
-        const currentFormatChar = this.formatStateOnKeyDown.format[this.formatStateOnKeyDown.selectionStart] || "";
-        if (this.options.allowCaretMode && hasCaret && this.currentFormat.length !== this.elementValue.length) {
-            if (currentFormatChar &&
-                currentFormatChar.length > 0 &&
-                currentFormatChar !== Constants.formatSeparator) {
-                if (!diff || diff.length === 0) {
-                    diff = [];
-                    diff[0][0] = currentFormatChar;
-                    diff[0][1] = e.data || "";
-                }
-                else if (diff[0] && diff[0][0] !== Constants.formatSeparator) {
-                    if (diff[0][0] !== currentFormatChar) {
-                        diff[0][0] = currentFormatChar;
-                        diff[0][1] = e.data || "";
-                    }
-                }
-            }
+        if (diff && diff.length && diff[0] && diff[0][1] !== Constants.formatSeparator) {
+            this.switchedPartOnPreviousKeyAction = false;
         }
         if (hasCaret && (!diff || diff.length === 0)) {
             this.restorePreviousInputEventState();
@@ -350,104 +338,128 @@ export class DateInput extends Observable {
             switchPart = false;
         }
         this.resetSegmentValue = false;
+        const hasFixedFormat = this.options.format === this.currentFormat ||
+            // all not fixed formats are 1 symbol, e.g. "d"
+            (isPresent(this.options.format) && this.options.format.length > 1);
         const lastParseResult = parsePartsResults[parsePartsResults.length - 1];
-        const lastParseResultHasNoValue = lastParseResult && !lastParseResult.value;
+        const lastParseResultHasNoValue = lastParseResult && !isPresent(lastParseResult.value);
         const parsingFailedOnDelete = (hasCaret && (isBackspaceKey || isDeleteKey) && lastParseResultHasNoValue);
         const resetPart = lastParseResult ? lastParseResult.resetPart : false;
-        const hasInvalidDatePart = lastParseResult ? lastParseResult.hasInvalidDatePart : false;
-        const hasDateValueChanged = !isEqual(oldDateObjectValue, this.dateObject.value);
+        const newExistingDateValue = this.dateObject.getValue();
+        const hasExistingDateValueChanged = !isEqual(oldExistingDateValue, newExistingDateValue);
+        const newDateValue = this.dateObject.value;
         let symbolForSelection;
         const currentSelection = this.selection;
-        if (!hasCaret || parsingFailedOnDelete || resetPart) {
-            if (resetPart) {
-                symbolForSelection = this.currentFormat[currentSelection.start];
-            }
-            this.forceUpdate();
-        }
-        if (diff.length && diff[0][0] !== Constants.formatSeparator) {
-            if (!hasCaret || parsingFailedOnDelete || resetPart) {
-                if (symbolForSelection) {
-                    this.setSelection(this.selectionBySymbol(symbolForSelection));
+        if (hasCaret) {
+            const diffChar = diff && diff.length > 0 ? diff[0][0] : null;
+            let hasLeadingZero = this.dateObject.getLeadingZero()[diffChar];
+            if (diff.length && diff[0][0] !== Constants.formatSeparator) {
+                if (switchPart) {
+                    this.forceUpdateWithSelection();
+                    this.switchDateSegment(1);
                 }
-                else {
-                    if (!this.options.autoSwitchParts && diff[0][1] === Constants.formatSeparator) {
-                        // do not change the selection when a separator is pressed
-                        // this should happen only if autoSwitchKeys contains the separator explicitly
+                else if (resetPart) {
+                    symbolForSelection = this.currentFormat[currentSelection.start];
+                    if (symbolForSelection) {
+                        this.forceUpdate();
+                        this.setSelection(this.selectionBySymbol(symbolForSelection));
                     }
                     else {
+                        this.restorePreviousInputEventState();
+                    }
+                }
+                else if (parsingFailedOnDelete) {
+                    this.forceUpdate();
+                    if (diff.length && diff[0][0] !== Constants.formatSeparator) {
                         this.setSelection(this.selectionBySymbol(diff[0][0]));
                     }
                 }
-            }
-            else if (hasCaret) {
-                if ((hasDateValueChanged && isPresent(this.dateObject.getValue()) ||
-                    (!hasDateValueChanged && switchPart && isPresent(this.dateObject.getValue())))) {
-                    if (switchPart) {
-                        this.switchDateSegment(1);
+                else if (lastParseResultHasNoValue) {
+                    if (e.data === "0" && hasLeadingZero) {
+                        // do not reset element value on a leading zero
+                        // wait for consecutive input to determine the value
                     }
-                    else {
-                        if (this.options.format.length !== this.currentFormat.length &&
-                            currentFormatChar && currentFormatChar !== "y") {
-                            const elementValueLength = this.elementValue.length;
-                            this.forceUpdate();
-                            const selectionOffset = this.elementValue.length - elementValueLength;
-                            this.setSelection({
-                                start: currentSelection.start + selectionOffset,
-                                end: currentSelection.start + selectionOffset
-                            });
-                        }
+                    else if (isPresent(oldExistingDateValue) && !isPresent(newExistingDateValue)) {
+                        this.restorePreviousInputEventState();
                     }
-                }
-                else {
-                    if (lastParseResultHasNoValue) {
-                        let hasLeadingZero = this.dateObject.getLeadingZero()[currentFormatChar];
-                        if (switchPart) {
-                            this.switchDateSegment(1);
-                        }
-                        else if (e.data === "0" && hasLeadingZero) {
+                    else if (!isPresent(oldExistingDateValue) && isPresent(newExistingDateValue)) {
+                        this.forceUpdateWithSelection();
+                    }
+                    else if (isPresent(oldExistingDateValue) && isPresent(newExistingDateValue)) {
+                        if (hasExistingDateValueChanged) {
+                            this.forceUpdateWithSelection();
                         }
                         else {
                             this.restorePreviousInputEventState();
                         }
                     }
-                }
-            }
-        }
-        if (!switchPart && hasCaret && !isBackspaceKey && !isDeleteKey && !resetPart && lastParseResultHasNoValue) {
-            if (hasDateValueChanged) {
-                if (this.currentFormat.length === this.elementValue.length) {
-                    // if a full date is entered, do not reset it
-                }
-                else {
-                    // the input is not complete, not parsable or not updatable
-                    if (originalInteractionMode !== DateInputInteractionMode.Caret && hasDateValueChanged) {
+                    else if (!isPresent(oldExistingDateValue) && !isPresent(newExistingDateValue)) {
+                        this.forceUpdateWithSelection();
                     }
-                    else if (originalInteractionMode !== DateInputInteractionMode.Caret) {
-                        symbolForSelection = this.currentFormat[currentSelection.start];
-                        this.forceUpdate();
-                        this.setSelection(this.selectionBySymbol(symbolForSelection));
+                    else if (oldDateValue !== newDateValue) {
+                        // this can happen on auto correct when no valid value is parsed
                     }
-                    else if (!hasInvalidDatePart) {
+                    else {
                         this.restorePreviousInputEventState();
                     }
                 }
+                else if (!lastParseResultHasNoValue) {
+                    // the user types a valid but incomplete date (e.g. year "123" with format "yyyy")
+                    // let them continue typing, but refresh for not fixed formats
+                    if (!hasFixedFormat) {
+                        this.forceUpdateWithSelection();
+                    }
+                }
             }
             else {
-                let hasLeadingZero = this.dateObject.getLeadingZero()[currentFormatChar];
-                if (e.data === "0" && hasLeadingZero) {
+                if (!this.options.autoSwitchParts && diff[0][1] === Constants.formatSeparator) {
+                    // do not change the selection when a separator is pressed
+                    // this should happen only if autoSwitchKeys contains the separator explicitly
                 }
-                else if (!hasInvalidDatePart) {
-                    this.restorePreviousInputEventState();
+                else {
+                    this.setSelection(this.selectionBySymbol(diff[0][0]));
                 }
             }
         }
-        else if (this.options.autoSwitchParts && (switchPart || navigationOnly)) {
-            if (!hasCaret) {
-                this.switchDateSegment(1);
+        else if (!hasCaret) {
+            this.forceUpdate();
+            if (diff.length && diff[0][0] !== Constants.formatSeparator) {
+                this.setSelection(this.selectionBySymbol(diff[0][0]));
+            }
+            if (this.options.autoSwitchParts) {
+                if (navigationOnly) {
+                    this.resetSegmentValue = true;
+                    if (!switchedPartOnPreviousKeyAction) {
+                        this.switchDateSegment(1);
+                    }
+                    this.switchedPartOnPreviousKeyAction = true;
+                }
+                else if (switchPart) {
+                    this.switchDateSegment(1);
+                    this.switchedPartOnPreviousKeyAction = true;
+                }
+            }
+            else {
+                if (lastParseResult && lastParseResult.switchToNext) {
+                    // the value is complete and should be switched, but the "autoSwitchParts" option prevents this
+                    // ensure that the segment value can be reset on next input
+                    this.resetSegmentValue = true;
+                }
+                else if (navigationOnly) {
+                    this.resetSegmentValue = true;
+                    if (!switchedPartOnPreviousKeyAction) {
+                        this.switchDateSegment(1);
+                    }
+                    this.switchedPartOnPreviousKeyAction = true;
+                }
+            }
+            if (isBackspaceKey && this.options.selectPreviousSegmentOnBackspace) {
+                // kendo angular have this UX
+                this.switchDateSegment(-1);
             }
         }
         this.tryTriggerValueChange({
-            oldValue: oldDateObjectValue,
+            oldValue: oldExistingDateValue,
             event: e
         });
         this.triggerInputEnd({ event: e });
@@ -467,6 +479,7 @@ export class DateInput extends Observable {
         }
         this.isActive = true;
         this.interactionMode = DateInputInteractionMode.None;
+        this.switchedPartOnPreviousKeyAction = false;
         this.refreshElementValue();
         if (!this.mouseDownStarted) {
             this.caret(0, this.elementValue.length);
@@ -484,6 +497,7 @@ export class DateInput extends Observable {
             return;
         }
         this.interactionMode = DateInputInteractionMode.None;
+        this.switchedPartOnPreviousKeyAction = false;
         this.refreshElementValue();
         this.triggerBlurEnd({ event: e });
     }
@@ -503,20 +517,9 @@ export class DateInput extends Observable {
         const { start, end } = this.selection;
         this.keyDownEvent = e;
         this.previousElementValue = this.element.value;
-        this.formatStateOnKeyDown = {
-            format: this.currentFormat,
-            selectionStart: start,
-            selectionEnd: end
-        };
         this.previousElementSelection = { start, end };
-        const autoSwitchKeys = (this.options.autoSwitchKeys || [])
-            .map(x => x.toString().toLowerCase().trim());
-        if (autoSwitchKeys.indexOf(e.keyCode.toString()) >= 0 ||
-            autoSwitchKeys.indexOf(e.keyCode) >= 0 ||
-            autoSwitchKeys.indexOf(e.key.toLowerCase().trim()) >= 0) {
-            const isTabKey = autoSwitchKeys.indexOf(Key.TAB.toLowerCase().trim()) >= 0 ||
-                autoSwitchKeys.indexOf(KeyCode.TAB) >= 0 ||
-                autoSwitchKeys.indexOf(KeyCode.TAB.toString()) >= 0;
+        if (this.keyEventMatchesAutoSwitchKeys(e)) {
+            const isTabKey = e.KeyCode === KeyCode.TAB;
             if (isTabKey) {
                 const { start: selectionStart, end: selectionEnd } = this.selection;
                 if (e.shiftKey && isTabKey) {
@@ -548,45 +551,33 @@ export class DateInput extends Observable {
             case KeyCode.ARROW_LEFT:
                 this.switchDateSegment(-1);
                 shouldPreventDefault = true;
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             case KeyCode.ARROW_UP:
                 this.modifyDateSegmentValue(step, symbol, event);
                 shouldPreventDefault = true;
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             case KeyCode.ARROW_RIGHT:
                 this.switchDateSegment(1);
                 shouldPreventDefault = true;
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             case KeyCode.ARROW_DOWN:
                 this.modifyDateSegmentValue(-step, symbol, event);
                 shouldPreventDefault = true;
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             case KeyCode.ENTER:
                 // todo: handle "change" event
                 break;
-            case KeyCode.DELETE:
-            case KeyCode.BACKSPACE:
-                if (this.options.allowNulls) {
-                    const oldValue = this.dateObject.value;
-                    this.dateObject.setValue(null);
-                    this.forceUpdate();
-                    this.tryTriggerValueChange({
-                        oldValue: oldValue,
-                        event: e
-                    });
-                }
-                shouldPreventDefault = true;
-                if (e.keyCode === KeyCode.BACKSPACE &&
-                    ((this.options.autoSwitchKeys || []).indexOf(KeyCode.BACKSPACE) >= 0 ||
-                        (this.options.autoSwitchKeys || []).indexOf(Key.BACKSPACE) >= 0)) {
-                    this.switchDateSegment(-1);
-                }
-                return;
             case Key.HOME:
                 this.selectNearestSegment(0);
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             case Key.END:
                 this.selectNearestSegment(this.elementValue.length);
+                this.switchedPartOnPreviousKeyAction = false;
                 break;
             default:
                 // allow the "input" event to handle the change
@@ -675,9 +666,11 @@ export class DateInput extends Observable {
         return returnValue;
     }
     setSelection(selection) {
-        // this._lastSelectedSymbol = this.currentFormat[selection.start];
         if (this.element && document.activeElement === this.element) {
             this.element.setSelectionRange(selection.start, selection.end);
+            if (selection.start !== selection.end) {
+                this.interactionMode = DateInputInteractionMode.Selection;
+            }
         }
     }
     /**
@@ -728,8 +721,7 @@ export class DateInput extends Observable {
         const selection = this.selection;
         if (this.isInCaretMode()) {
             let start = selection.start;
-            const currentSymbol = this.currentFormat[start - (this.elementValue.length - this.currentFormat.length)] ||
-                this.currentFormat[start];
+            const currentSymbol = this.currentFormat[start - 1];
             let symbol = "";
             let symbolCandidate = "";
             if (offset < 0) {
@@ -903,6 +895,19 @@ export class DateInput extends Observable {
         this.setTextAndFormat();
         this.refreshElementValue();
     }
+    /**
+     * @hidden
+     */
+    forceUpdateWithSelection() {
+        const { start, end } = this.selection;
+        const elementValueLength = this.elementValue.length;
+        this.forceUpdate();
+        const selectionOffset = this.elementValue.length - elementValueLength;
+        this.setSelection({
+            start: start + selectionOffset,
+            end: end + selectionOffset
+        });
+    }
     /**
      * @hidden
      */
@@ -1084,4 +1089,18 @@ export class DateInput extends Observable {
         }, options));
         return dateObject;
     }
+    /* tslint:enable:align */
+    /**
+     * @hidden
+     */
+    keyEventMatchesAutoSwitchKeys(keyObject) {
+        const autoSwitchKeys = (this.options.autoSwitchKeys || [])
+            .map(x => x.toString().toLowerCase().trim());
+        if (autoSwitchKeys.indexOf(keyObject.keyCode.toString()) >= 0 ||
+            autoSwitchKeys.indexOf(keyObject.keyCode) >= 0 ||
+            autoSwitchKeys.indexOf(keyObject.key.toLowerCase().trim()) >= 0) {
+            return true;
+        }
+        return false;
+    }
 }

package/dist/es2015/dateinput/utils.js

@@ -67,8 +67,8 @@ export const approximateStringMatching = ({ oldText, newText, formatPattern, sel
         return [[symbol, newSegmentText[selectionStart - 1]]];
     }
     /* Handle the entering of a space or a separator for navigating to the next item. */
-    if ((!isInCaretMode && newSegmentText[newSegmentText.length - 1] === ' ') ||
-        (!isInCaretMode && newSegmentText[newSegmentText.length - 1] === oldTextSeparator)) {
+    if ((newSegmentText[newSegmentText.length - 1] === ' ') ||
+        (newSegmentText[newSegmentText.length - 1] === oldTextSeparator)) {
         return [[formatPattern[selectionStart - 1], Constants.formatSeparator]];
     }
     /* Handle typing over a correctly selected part. */

package/dist/npm/common/dateobject.js

@@ -533,7 +533,6 @@ var DateObject = /** @class */ (function () {
      * @hidden
      */
     DateObject.prototype.parsePart = function (_a) {
-        var _b;
         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);
@@ -578,7 +577,7 @@ var DateObject = /** @class */ (function () {
             .some(function (x) { return x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD; });
         var parseResult = {
             value: null,
-            switchPart: false,
+            switchToNext: false,
             resetPart: shouldResetPart,
             hasInvalidDatePart: false
         };
@@ -601,8 +600,7 @@ var DateObject = /** @class */ (function () {
                 this.resetLeadingZero();
                 this.setExisting(symbol, false);
                 this.resetInvalidDateSymbol(symbol);
-                // return extend(parseResult, { value: null, switchToNext: false });
-                return { value: null, switchToNext: false };
+                return utils_2.extend(parseResult, { value: null, switchToNext: false });
             }
         }
         var baseDate = this.intl.formatDate(this.value, this.format, this.localeId);
@@ -625,21 +623,13 @@ var DateObject = /** @class */ (function () {
         var datePartStartIndex = (hasFixedFormat ? convertedBaseFormat : originalFormat).indexOf(symbol);
         var datePartEndIndex = (hasFixedFormat ? convertedBaseFormat : originalFormat).lastIndexOf(symbol);
         var segmentLength = datePartEndIndex - datePartStartIndex + 1;
-        var processedSegmentCharsCount = 0;
         var formatToTextLengthDiff = originalFormat.length - rawInputValue.length;
         if (isInCaretMode || (!isInCaretMode && !this.autoCorrectParts)) {
             for (var i = 0; i < baseDate.length; i++) {
                 if (baseFormat[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 if (formatToTextLengthDiff > 0) {
+                    if (formatToTextLengthDiff > 0) {
                         if (datePartText.length + formatToTextLengthDiff < segmentLength) {
                             datePartText += rawInputValue[i] || "";
                         }
@@ -663,18 +653,13 @@ var DateObject = /** @class */ (function () {
                     datePartText += currentChar;
                 }
                 else if (!isDeleting && originalFormat.length > rawInputValue.length) {
-                    var lengthDiff = originalFormat.length - rawInputValue.length;
-                    var trimmedDatePartText = datePartText.substr(0, datePartText.length - lengthDiff);
-                    if (trimmedDatePartText && trimmedDatePartText.length > 0) {
-                        datePartText = trimmedDatePartText;
-                    }
+                    // let the parsing to determine if the incomplete value is valid
                 }
                 if (datePartText.length > segmentLength) {
                     return utils_2.extend(parseResult, { value: null, switchToNext: false });
                 }
             }
             if (!hasFixedFormat || (hasFixedFormat && !this.autoCorrectParts)) {
-                processedSegmentCharsCount = 0;
                 current = "";
                 datePartText = "";
                 prefix = "";
@@ -684,14 +669,7 @@ var DateObject = /** @class */ (function () {
                     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 if (formatToTextLengthDiff > 0) {
+                        if (formatToTextLengthDiff > 0) {
                             if (datePartText.length + formatToTextLengthDiff < segmentLength) {
                                 datePartText += rawInputValue[i] || "";
                             }
@@ -715,7 +693,6 @@ var DateObject = /** @class */ (function () {
         }
         if (!isInCaretMode) {
             if (this.autoCorrectParts) {
-                processedSegmentCharsCount = 0;
                 current = "";
                 datePartText = "";
                 prefix = "";
@@ -760,6 +737,7 @@ var DateObject = /** @class */ (function () {
         }
         var partPattern = this.partPattern(dateParts.partMap, symbol);
         var patternValue = partPattern ? partPattern.pattern : null;
+        var patternLength = this.patternLength(patternValue) || patternValue.length;
         if (isInCaretMode) {
             if (isDeleting && !datePartText) {
                 this.setExisting(symbol, false);
@@ -781,11 +759,13 @@ var DateObject = /** @class */ (function () {
             if (isInCaretMode || !this.autoCorrectParts) {
                 tryParse = false;
                 middle = utils_1.unpadZero(middle);
-                middle = utils_1.padZero(segmentLength - middle.length) + middle;
+                // middle = padZero(segmentLength - middle.length) + middle;
+                middle = utils_1.padZero(patternLength - middle.length) + middle;
             }
             var middleNumber = parseInt(middle, 10);
             var candidateDateString = prefix + middle + suffix;
             parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            var autoCorrectedPrefixAndSuffix = false;
             if (isInCaretMode && !utils_2.isValidDate(parsedDate)) {
                 // if part of the date is not available, e.g. "d"
                 // but an expanded format like "F" is used
@@ -796,6 +776,7 @@ var DateObject = /** @class */ (function () {
                 // as "EEEE, February..." is not parsable
                 if (this.autoCorrectParts) {
                     parsedDate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+                    autoCorrectedPrefixAndSuffix = true;
                 }
             }
             var isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
@@ -822,10 +803,22 @@ var DateObject = /** @class */ (function () {
             if ((isInCaretMode && utils_2.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 peekValue = this.peek(middle, patternValue);
-                var peekDateString = "" + prefix + peekValue + suffix;
-                var peekDate = this.intl.parseDate(peekDateString, this.format, this.localeId);
-                var switchToNext = peekDate === null || (leadingZero[symbol] && patternValue.length <= middle.length) || false;
+                var peekedValue = this.peek(middle, patternValue);
+                var peekedDateString = autoCorrectedPrefixAndSuffix ?
+                    "" + basePrefix + peekedValue + baseSuffix :
+                    "" + prefix + peekedValue + suffix;
+                var peekedDate = this.intl.parseDate(peekedDateString, this.format, this.localeId);
+                var leadingZeroOffset = (this.leadingZero || {})[symbol] || 0;
+                var patternSatisfied = (leadingZeroOffset + utils_1.unpadZero(middle).length) >= patternLength;
+                var switchToNext = peekedDate === null ||
+                    (leadingZero[symbol] ?
+                        patternValue.length <= middle.length :
+                        patternSatisfied);
+                // console.log("peeek: " + peekedDate);
+                // console.log("lead : " + (leadingZero[symbol] && patternValue.length <= middle.length ));
+                // console.log("pat s: " + patternSatisfied);
+                // console.log("middl: " + middle);
+                // console.log("pater: " + patternValue);
                 if (this.shouldNormalizeCentury()) {
                     parsedDate = this.normalizeCentury(parsedDate);
                 }
@@ -851,24 +844,6 @@ var DateObject = /** @class */ (function () {
                         this.markDatePartsAsExisting();
                     }
                 }
-                if (isInCaretMode && switchToNext) {
-                    if (symbol === "M") {
-                        var datePartValue = utils_2.parseToInt(datePartText);
-                        if (datePartValue >= 2 || datePartText.length >= 2) {
-                            switchToNext = true;
-                        }
-                        else {
-                            switchToNext = false;
-                        }
-                    }
-                    else {
-                        switchToNext = switchToNext ?
-                            hasFixedFormat ?
-                                datePartText.length === segmentLength :
-                                datePartText.length > segmentLength :
-                            switchToNext;
-                    }
-                }
                 return utils_2.extend(parseResult, { value: this.value, switchToNext: switchToNext });
             }
         }
@@ -888,7 +863,6 @@ var DateObject = /** @class */ (function () {
             }
         }
         if (isZeroCurrentChar) {
-            this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? (_b = {}, _b[symbol] = true, _b) : null;
             this.setExisting(symbol, false);
         }
         if (!this.autoCorrectParts) {