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

package/dist/es/dateinput/dateinput.js

@@ -30,7 +30,6 @@ var FOCUS_END = "focusEnd";
 var CHANGE = "change";
 var defaultDateInputOptions = {
     format: "d",
-    allowNulls: false,
     hasPlaceholder: false,
     placeholder: null,
     cycleTime: true,
@@ -58,6 +57,7 @@ var defaultDateInputOptions = {
         _a[CHANGE] = null,
         _a),
     selectNearestSegmentOnFocus: false,
+    selectPreviousSegmentOnBackspace: false,
     enableMouseWheel: false,
     allowCaretMode: false,
     autoSwitchParts: true,
@@ -211,6 +211,7 @@ var DateInput = /** @class */ (function (_super) {
      */
     DateInput.prototype.onElementClick = function (e) {
         this.mouseDownStarted = false;
+        this.switchedPartOnPreviousKeyAction = false;
         var selection = this.selection;
         if (this.isInCaretMode()) {
             // explicitly refresh the input element value
@@ -243,12 +244,10 @@ var DateInput = /** @class */ (function (_super) {
      */
     DateInput.prototype.onElementInput = function (e) {
         this.triggerInput({ event: e });
-        var keyDownEvent = this.keyDownEvent || {};
-        var isBackspaceKey = keyDownEvent.keyCode === KeyCode.BACKSPACE || keyDownEvent.key === Key.BACKSPACE;
-        var isDeleteKey = keyDownEvent.keyCode === KeyCode.DELETE || keyDownEvent.key === Key.DELETE;
         if (!this.element || !this.dateObject) {
             return;
         }
+        var switchedPartOnPreviousKeyAction = this.switchedPartOnPreviousKeyAction;
         if (this.isPasteInProgress) {
             if (this.options.allowCaretMode) {
                 // pasting should leave the input with caret
@@ -259,6 +258,9 @@ var DateInput = /** @class */ (function (_super) {
             this.isPasteInProgress = false;
             return;
         }
+        var keyDownEvent = this.keyDownEvent || {};
+        var isBackspaceKey = keyDownEvent.keyCode === KeyCode.BACKSPACE || keyDownEvent.key === Key.BACKSPACE;
+        var isDeleteKey = keyDownEvent.keyCode === KeyCode.DELETE || keyDownEvent.key === Key.DELETE;
         var originalInteractionMode = this.interactionMode;
         if (this.options.allowCaretMode &&
             originalInteractionMode !== DateInputInteractionMode.Caret &&
@@ -277,50 +279,36 @@ var DateInput = /** @class */ (function (_super) {
             this.restorePreviousInputEventState();
             return;
         }
-        var oldDateObjectValue = this.dateObject && this.dateObject.getValue();
+        var oldExistingDateValue = this.dateObject && this.dateObject.getValue();
+        var oldDateValue = this.dateObject ? this.dateObject.value : null;
         var _a = this.dateObject.getTextAndFormat(), currentText = _a.text, currentFormat = _a.format;
         this.currentFormat = currentFormat;
-        var text = "";
+        var 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;
         }
         var newText = this.elementValue;
         var diff = approximateStringMatching({
-            oldText: text,
+            oldText: oldText,
             newText: newText,
             formatPattern: this.currentFormat,
             selectionStart: this.selection.start,
             isInCaretMode: hasCaret,
             keyEvent: this.keyDownEvent
         });
-        var 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();
@@ -359,104 +347,128 @@ var DateInput = /** @class */ (function (_super) {
             switchPart = false;
         }
         this.resetSegmentValue = false;
+        var 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);
         var lastParseResult = parsePartsResults[parsePartsResults.length - 1];
-        var lastParseResultHasNoValue = lastParseResult && !lastParseResult.value;
+        var lastParseResultHasNoValue = lastParseResult && !isPresent(lastParseResult.value);
         var parsingFailedOnDelete = (hasCaret && (isBackspaceKey || isDeleteKey) && lastParseResultHasNoValue);
         var resetPart = lastParseResult ? lastParseResult.resetPart : false;
-        var hasInvalidDatePart = lastParseResult ? lastParseResult.hasInvalidDatePart : false;
-        var hasDateValueChanged = !isEqual(oldDateObjectValue, this.dateObject.value);
+        var newExistingDateValue = this.dateObject.getValue();
+        var hasExistingDateValueChanged = !isEqual(oldExistingDateValue, newExistingDateValue);
+        var newDateValue = this.dateObject.value;
         var symbolForSelection;
         var 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) {
+            var diffChar = diff && diff.length > 0 ? diff[0][0] : null;
+            var 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") {
-                            var elementValueLength = this.elementValue.length;
-                            this.forceUpdate();
-                            var 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) {
-                        var 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 {
-                var 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 });
@@ -476,6 +488,7 @@ var DateInput = /** @class */ (function (_super) {
         }
         this.isActive = true;
         this.interactionMode = DateInputInteractionMode.None;
+        this.switchedPartOnPreviousKeyAction = false;
         this.refreshElementValue();
         if (!this.mouseDownStarted) {
             this.caret(0, this.elementValue.length);
@@ -493,6 +506,7 @@ var DateInput = /** @class */ (function (_super) {
             return;
         }
         this.interactionMode = DateInputInteractionMode.None;
+        this.switchedPartOnPreviousKeyAction = false;
         this.refreshElementValue();
         this.triggerBlurEnd({ event: e });
     };
@@ -512,20 +526,9 @@ var DateInput = /** @class */ (function (_super) {
         var _a = this.selection, start = _a.start, end = _a.end;
         this.keyDownEvent = e;
         this.previousElementValue = this.element.value;
-        this.formatStateOnKeyDown = {
-            format: this.currentFormat,
-            selectionStart: start,
-            selectionEnd: end
-        };
         this.previousElementSelection = { start: start, end: end };
-        var autoSwitchKeys = (this.options.autoSwitchKeys || [])
-            .map(function (x) { return x.toString().toLowerCase().trim(); });
-        if (autoSwitchKeys.indexOf(e.keyCode.toString()) >= 0 ||
-            autoSwitchKeys.indexOf(e.keyCode) >= 0 ||
-            autoSwitchKeys.indexOf(e.key.toLowerCase().trim()) >= 0) {
-            var isTabKey = autoSwitchKeys.indexOf(Key.TAB.toLowerCase().trim()) >= 0 ||
-                autoSwitchKeys.indexOf(KeyCode.TAB) >= 0 ||
-                autoSwitchKeys.indexOf(KeyCode.TAB.toString()) >= 0;
+        if (this.keyEventMatchesAutoSwitchKeys(e)) {
+            var isTabKey = e.KeyCode === KeyCode.TAB;
             if (isTabKey) {
                 var _b = this.selection, selectionStart = _b.start, selectionEnd = _b.end;
                 if (e.shiftKey && isTabKey) {
@@ -557,45 +560,33 @@ var DateInput = /** @class */ (function (_super) {
             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) {
-                    var 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
@@ -700,9 +691,11 @@ var DateInput = /** @class */ (function (_super) {
         configurable: true
     });
     DateInput.prototype.setSelection = function (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;
+            }
         }
     };
     /**
@@ -753,8 +746,7 @@ var DateInput = /** @class */ (function (_super) {
         var selection = this.selection;
         if (this.isInCaretMode()) {
             var start = selection.start;
-            var currentSymbol = this.currentFormat[start - (this.elementValue.length - this.currentFormat.length)] ||
-                this.currentFormat[start];
+            var currentSymbol = this.currentFormat[start - 1];
             var symbol = "";
             var symbolCandidate = "";
             if (offset < 0) {
@@ -941,6 +933,19 @@ var DateInput = /** @class */ (function (_super) {
         this.setTextAndFormat();
         this.refreshElementValue();
     };
+    /**
+     * @hidden
+     */
+    DateInput.prototype.forceUpdateWithSelection = function () {
+        var _a = this.selection, start = _a.start, end = _a.end;
+        var elementValueLength = this.elementValue.length;
+        this.forceUpdate();
+        var selectionOffset = this.elementValue.length - elementValueLength;
+        this.setSelection({
+            start: start + selectionOffset,
+            end: end + selectionOffset
+        });
+    };
     /**
      * @hidden
      */
@@ -1124,6 +1129,20 @@ var DateInput = /** @class */ (function (_super) {
         }, options));
         return dateObject;
     };
+    /* tslint:enable:align */
+    /**
+     * @hidden
+     */
+    DateInput.prototype.keyEventMatchesAutoSwitchKeys = function (keyObject) {
+        var autoSwitchKeys = (this.options.autoSwitchKeys || [])
+            .map(function (x) { return 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;
+    };
     return DateInput;
 }(Observable));
 export { DateInput };

package/dist/es/dateinput/utils.js

@@ -68,8 +68,8 @@ export var approximateStringMatching = function (_a) {
         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/es2015/common/dateobject.js

@@ -561,7 +561,7 @@ export class DateObject {
             .some(x => x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD);
         let parseResult = {
             value: null,
-            switchPart: false,
+            switchToNext: false,
             resetPart: shouldResetPart,
             hasInvalidDatePart: false
         };
@@ -584,8 +584,7 @@ export class DateObject {
                 this.resetLeadingZero();
                 this.setExisting(symbol, false);
                 this.resetInvalidDateSymbol(symbol);
-                // return extend(parseResult, { value: null, switchToNext: false });
-                return { value: null, switchToNext: false };
+                return extend(parseResult, { value: null, switchToNext: false });
             }
         }
         const baseDate = this.intl.formatDate(this.value, this.format, this.localeId);
@@ -608,21 +607,13 @@ export class DateObject {
         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);
                     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] || "";
                         }
@@ -646,18 +637,13 @@ export class DateObject {
                     datePartText += currentChar;
                 }
                 else if (!isDeleting && originalFormat.length > rawInputValue.length) {
-                    const lengthDiff = originalFormat.length - rawInputValue.length;
-                    const 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 extend(parseResult, { value: null, switchToNext: false });
                 }
             }
             if (!hasFixedFormat || (hasFixedFormat && !this.autoCorrectParts)) {
-                processedSegmentCharsCount = 0;
                 current = "";
                 datePartText = "";
                 prefix = "";
@@ -667,14 +653,7 @@ export class DateObject {
                     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 if (formatToTextLengthDiff > 0) {
+                        if (formatToTextLengthDiff > 0) {
                             if (datePartText.length + formatToTextLengthDiff < segmentLength) {
                                 datePartText += rawInputValue[i] || "";
                             }
@@ -698,7 +677,6 @@ export class DateObject {
         }
         if (!isInCaretMode) {
             if (this.autoCorrectParts) {
-                processedSegmentCharsCount = 0;
                 current = "";
                 datePartText = "";
                 prefix = "";
@@ -743,6 +721,7 @@ export class DateObject {
         }
         const partPattern = this.partPattern(dateParts.partMap, symbol);
         const patternValue = partPattern ? partPattern.pattern : null;
+        const patternLength = this.patternLength(patternValue) || patternValue.length;
         if (isInCaretMode) {
             if (isDeleting && !datePartText) {
                 this.setExisting(symbol, false);
@@ -764,11 +743,13 @@ export class DateObject {
             if (isInCaretMode || !this.autoCorrectParts) {
                 tryParse = false;
                 middle = unpadZero(middle);
-                middle = padZero(segmentLength - middle.length) + middle;
+                // middle = padZero(segmentLength - middle.length) + middle;
+                middle = padZero(patternLength - middle.length) + middle;
             }
             let middleNumber = parseInt(middle, 10);
             const candidateDateString = prefix + middle + suffix;
             parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            let autoCorrectedPrefixAndSuffix = false;
             if (isInCaretMode && !isValidDate(parsedDate)) {
                 // if part of the date is not available, e.g. "d"
                 // but an expanded format like "F" is used
@@ -779,6 +760,7 @@ export class DateObject {
                 // as "EEEE, February..." is not parsable
                 if (this.autoCorrectParts) {
                     parsedDate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+                    autoCorrectedPrefixAndSuffix = true;
                 }
             }
             const isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
@@ -805,10 +787,22 @@ export class DateObject {
             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 peekValue = this.peek(middle, patternValue);
-                const peekDateString = `${prefix}${peekValue}${suffix}`;
-                const peekDate = this.intl.parseDate(peekDateString, this.format, this.localeId);
-                let switchToNext = peekDate === null || (leadingZero[symbol] && patternValue.length <= middle.length) || false;
+                const peekedValue = this.peek(middle, patternValue);
+                const peekedDateString = autoCorrectedPrefixAndSuffix ?
+                    `${basePrefix}${peekedValue}${baseSuffix}` :
+                    `${prefix}${peekedValue}${suffix}`;
+                const peekedDate = this.intl.parseDate(peekedDateString, this.format, this.localeId);
+                const leadingZeroOffset = (this.leadingZero || {})[symbol] || 0;
+                const patternSatisfied = (leadingZeroOffset + unpadZero(middle).length) >= patternLength;
+                let 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);
                 }
@@ -834,24 +828,6 @@ export class DateObject {
                         this.markDatePartsAsExisting();
                     }
                 }
-                if (isInCaretMode && switchToNext) {
-                    if (symbol === "M") {
-                        const datePartValue = 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 extend(parseResult, { value: this.value, switchToNext: switchToNext });
             }
         }
@@ -871,7 +847,6 @@ export class DateObject {
             }
         }
         if (isZeroCurrentChar) {
-            this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? { [symbol]: true } : null;
             this.setExisting(symbol, false);
         }
         if (!this.autoCorrectParts) {