@progress/kendo-dateinputs-common 0.3.3 → 0.3.4-dev.202406251149

package/dist/es2015/common/dateobject.js

@@ -3,6 +3,8 @@ import { Mask } from './mask';
 import { dateSymbolMap, padZero, unpadZero } from '../dateinput/utils';
 import { extend, isPresent, cropTwoDigitYear, setYears, parseToInt, clamp, areDatePartsEqualTo, isNumber, isValidDate } from './utils';
 import { Constants } from './constants';
+const MONTH_INDEX_FEBRUARY = 1;
+const DEFAULT_LEAP_YEAR = 2000;
 const PREVIOUS_CENTURY_BASE = 1900;
 const CURRENT_CENTURY_BASE = 2000;
 const SHORT_PATTERN_LENGTH_REGEXP = /d|M|H|h|m|s/;
@@ -35,7 +37,7 @@ export class DateObject {
             'y': 'y',
             'S': 'S'
         };
-        this._value = getDate(new Date());
+        this._value = this.getDefaultDate();
         this.cycleTime = false;
         this._partiallyInvalidDate = {
             startDate: null,
@@ -62,7 +64,7 @@ export class DateObject {
             autoCorrectParts
         });
         if (!value) {
-            this._value = getDate(new Date());
+            this._value = this.getDefaultDate();
             const sampleFormat = this.dateFormatString(this.value, this.format).symbols;
             for (let i = 0; i < sampleFormat.length; i++) {
                 this.setExisting(sampleFormat[i], false);
@@ -112,7 +114,7 @@ export class DateObject {
     }
     setValue(value) {
         if (!value) {
-            this._value = getDate(new Date());
+            this._value = this.getDefaultDate();
             this.modifyExisting(false);
         }
         else if (!isEqual(value, this._value)) {
@@ -139,6 +141,23 @@ export class DateObject {
         }
         return cloneDate(this.value);
     }
+    /**
+     * @hidden
+     */
+    createDefaultDate() {
+        // use the leap year 2000 that has 29th February
+        // and a month that has 31 days
+        // so that the default date can accommodate maximum date values
+        // it is better to use a fixed date instead of new Date()
+        // as otherwise the
+        return createDate(DEFAULT_LEAP_YEAR, 0, 31);
+    }
+    /**
+     * @hidden
+     */
+    getDefaultDate() {
+        return getDate(this.createDefaultDate());
+    }
     /**
      * @hidden
      */
@@ -261,7 +280,7 @@ export class DateObject {
                 // allow 2/29 dates
                 this.year = value;
                 if (value === false) {
-                    this._value.setFullYear(2000);
+                    this._value.setFullYear(DEFAULT_LEAP_YEAR);
                 }
                 break;
             case 'M':
@@ -808,17 +827,19 @@ 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 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);
+                const peekResult = this.isPeekDateOverflowingDatePart({
+                    useBasePrefixAndSuffix: autoCorrectedPrefixAndSuffix,
+                    middle,
+                    patternValue,
+                    basePrefix,
+                    baseSuffix,
+                    prefix,
+                    suffix,
+                    symbol,
+                    patternLength,
+                    leadingZero
+                });
+                let switchToNext = peekResult.switchToNext;
                 if (this.shouldNormalizeCentury()) {
                     parsedDate = this.normalizeCentury(parsedDate);
                 }
@@ -842,6 +863,21 @@ export class DateObject {
                     }
                     if (!this.hasInvalidDatePart()) {
                         this.markDatePartsAsExisting();
+                        if (!peekResult.peekedDate && peekResult.switchToNext && !this.autoCorrectParts) {
+                            if (symbol === "M") {
+                                // skip processing the month
+                            }
+                            else if (symbol === "d") {
+                                if (peekResult.parsedPeekedValue === 30 &&
+                                    this.value.getMonth() === MONTH_INDEX_FEBRUARY) {
+                                    // the peekValue cannot be constructed
+                                    // as there cannot be more than 29 days in February
+                                    // still the segment should not be switched as autoCorrectParts="false"
+                                    // should allow typing "30"
+                                    switchToNext = false;
+                                }
+                            }
+                        }
                     }
                 }
                 return extend(parseResult, { value: this.value, switchToNext: switchToNext });
@@ -869,12 +905,25 @@ export class DateObject {
         }
         if (!this.autoCorrectParts) {
             let datePartValue;
-            const textToParse = isInCaretMode ? datePartText : middle;
-            const parsedValue = parseToInt(textToParse);
+            let textToParse = isInCaretMode ? datePartText : middle;
+            let 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 });
+                    if (isInCaretMode) {
+                        return extend(parseResult, {
+                            value: null,
+                            switchToNext: false
+                        });
+                    }
+                    else {
+                        // the value overflows the possible value range
+                        // thus reset the segment value regardless of the "resetSegmentValue" flag
+                        // otherwise the input is ignored and you cannot change the value,
+                        // e.g. "03->(press 2)->02" will not work and the user will be blocked on "03"
+                        textToParse = currentChar;
+                        parsedValue = parseToInt(textToParse);
+                    }
                 }
                 datePartValue = symbol === "M" ?
                     parsedValue - JS_MONTH_OFFSET :
@@ -1005,9 +1054,24 @@ export class DateObject {
                     }
                 }
                 else {
-                    switchToNext = hasFixedFormat ?
-                        textToParse.length === segmentLength :
-                        textToParse.length > segmentLength;
+                    if (hasFixedFormat) {
+                        const peekDateSwitchToNext = this.isPeekDateOverflowingDatePart({
+                            useBasePrefixAndSuffix: !this.autoCorrectParts,
+                            middle,
+                            patternValue,
+                            basePrefix,
+                            baseSuffix,
+                            prefix,
+                            suffix,
+                            symbol,
+                            patternLength,
+                            leadingZero
+                        }).switchToNext;
+                        switchToNext = peekDateSwitchToNext;
+                    }
+                    else {
+                        switchToNext = textToParse.length > segmentLength;
+                    }
                 }
                 return extend(parseResult, {
                     value: null,
@@ -1459,4 +1523,34 @@ export class DateObject {
         }
         return partsForSegment;
     }
+    /**
+     * @hidden
+     */
+    isPeekDateOverflowingDatePart({ useBasePrefixAndSuffix, middle, patternValue, basePrefix, baseSuffix, prefix, suffix, symbol, patternLength, leadingZero }) {
+        // 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 peekedValue = this.peek(middle, patternValue);
+        const peekedDateString = useBasePrefixAndSuffix ?
+            `${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 parsedPeekedValue = parseToInt(peekedValue);
+        if (symbol === "M") {
+        }
+        else if (symbol === "d") {
+        }
+        const switchToNext = peekedDate === null ||
+            (leadingZero[symbol] ?
+                patternValue.length <= middle.length :
+                patternSatisfied);
+        return {
+            peekedDate,
+            peekedDateString,
+            peekedValue,
+            parsedPeekedValue,
+            switchToNext
+        };
+    }
 }

package/dist/npm/common/dateobject.d.ts

@@ -46,6 +46,14 @@ export declare class DateObject {
      * @hidden
      */
     getValue(): Date;
+    /**
+     * @hidden
+     */
+    createDefaultDate(): Date;
+    /**
+     * @hidden
+     */
+    getDefaultDate(): Date;
     /**
      * @hidden
      */
@@ -187,4 +195,25 @@ export declare class DateObject {
      * @hidden
      */
     getPartsForSegment(mask: any, partIndex: any): any[];
+    /**
+     * @hidden
+     */
+    isPeekDateOverflowingDatePart({ useBasePrefixAndSuffix, middle, patternValue, basePrefix, baseSuffix, prefix, suffix, symbol, patternLength, leadingZero }: {
+        useBasePrefixAndSuffix: any;
+        middle: any;
+        patternValue: any;
+        basePrefix: any;
+        baseSuffix: any;
+        prefix: any;
+        suffix: any;
+        symbol: any;
+        patternLength: any;
+        leadingZero: any;
+    }): {
+        peekedDate: any;
+        peekedDateString: string;
+        peekedValue: string;
+        parsedPeekedValue: number;
+        switchToNext: boolean;
+    };
 }

package/dist/npm/common/dateobject.js

@@ -5,6 +5,8 @@ var mask_1 = require("./mask");
 var utils_1 = require("../dateinput/utils");
 var utils_2 = require("./utils");
 var constants_1 = require("./constants");
+var MONTH_INDEX_FEBRUARY = 1;
+var DEFAULT_LEAP_YEAR = 2000;
 var PREVIOUS_CENTURY_BASE = 1900;
 var CURRENT_CENTURY_BASE = 2000;
 var SHORT_PATTERN_LENGTH_REGEXP = /d|M|H|h|m|s/;
@@ -38,7 +40,7 @@ var DateObject = /** @class */ (function () {
             'y': 'y',
             'S': 'S'
         };
-        this._value = kendo_date_math_1.getDate(new Date());
+        this._value = this.getDefaultDate();
         this.cycleTime = false;
         this._partiallyInvalidDate = {
             startDate: null,
@@ -65,7 +67,7 @@ var DateObject = /** @class */ (function () {
             autoCorrectParts: autoCorrectParts
         });
         if (!value) {
-            this._value = kendo_date_math_1.getDate(new Date());
+            this._value = this.getDefaultDate();
             var sampleFormat = this.dateFormatString(this.value, this.format).symbols;
             for (var i = 0; i < sampleFormat.length; i++) {
                 this.setExisting(sampleFormat[i], false);
@@ -123,7 +125,7 @@ var DateObject = /** @class */ (function () {
     };
     DateObject.prototype.setValue = function (value) {
         if (!value) {
-            this._value = kendo_date_math_1.getDate(new Date());
+            this._value = this.getDefaultDate();
             this.modifyExisting(false);
         }
         else if (!kendo_date_math_1.isEqual(value, this._value)) {
@@ -151,6 +153,23 @@ var DateObject = /** @class */ (function () {
         }
         return kendo_date_math_1.cloneDate(this.value);
     };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.createDefaultDate = function () {
+        // use the leap year 2000 that has 29th February
+        // and a month that has 31 days
+        // so that the default date can accommodate maximum date values
+        // it is better to use a fixed date instead of new Date()
+        // as otherwise the
+        return kendo_date_math_1.createDate(DEFAULT_LEAP_YEAR, 0, 31);
+    };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.getDefaultDate = function () {
+        return kendo_date_math_1.getDate(this.createDefaultDate());
+    };
     /**
      * @hidden
      */
@@ -276,7 +295,7 @@ var DateObject = /** @class */ (function () {
                 // allow 2/29 dates
                 this.year = value;
                 if (value === false) {
-                    this._value.setFullYear(2000);
+                    this._value.setFullYear(DEFAULT_LEAP_YEAR);
                 }
                 break;
             case 'M':
@@ -824,17 +843,19 @@ 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 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);
+                var peekResult = this.isPeekDateOverflowingDatePart({
+                    useBasePrefixAndSuffix: autoCorrectedPrefixAndSuffix,
+                    middle: middle,
+                    patternValue: patternValue,
+                    basePrefix: basePrefix,
+                    baseSuffix: baseSuffix,
+                    prefix: prefix,
+                    suffix: suffix,
+                    symbol: symbol,
+                    patternLength: patternLength,
+                    leadingZero: leadingZero
+                });
+                var switchToNext = peekResult.switchToNext;
                 if (this.shouldNormalizeCentury()) {
                     parsedDate = this.normalizeCentury(parsedDate);
                 }
@@ -858,6 +879,21 @@ var DateObject = /** @class */ (function () {
                     }
                     if (!this.hasInvalidDatePart()) {
                         this.markDatePartsAsExisting();
+                        if (!peekResult.peekedDate && peekResult.switchToNext && !this.autoCorrectParts) {
+                            if (symbol === "M") {
+                                // skip processing the month
+                            }
+                            else if (symbol === "d") {
+                                if (peekResult.parsedPeekedValue === 30 &&
+                                    this.value.getMonth() === MONTH_INDEX_FEBRUARY) {
+                                    // the peekValue cannot be constructed
+                                    // as there cannot be more than 29 days in February
+                                    // still the segment should not be switched as autoCorrectParts="false"
+                                    // should allow typing "30"
+                                    switchToNext = false;
+                                }
+                            }
+                        }
                     }
                 }
                 return utils_2.extend(parseResult, { value: this.value, switchToNext: switchToNext });
@@ -890,7 +926,20 @@ var DateObject = /** @class */ (function () {
             if (utils_2.isNumber(parsedValue)) {
                 if ((symbol === "d" && (parsedValue <= 0 || parsedValue > 31)) ||
                     (symbol === "M" && (parsedValue < 0 || parsedValue > 11))) {
-                    return utils_2.extend(parseResult, { value: null, switchToNext: false });
+                    if (isInCaretMode) {
+                        return utils_2.extend(parseResult, {
+                            value: null,
+                            switchToNext: false
+                        });
+                    }
+                    else {
+                        // the value overflows the possible value range
+                        // thus reset the segment value regardless of the "resetSegmentValue" flag
+                        // otherwise the input is ignored and you cannot change the value,
+                        // e.g. "03->(press 2)->02" will not work and the user will be blocked on "03"
+                        textToParse = currentChar;
+                        parsedValue = utils_2.parseToInt(textToParse);
+                    }
                 }
                 datePartValue = symbol === "M" ?
                     parsedValue - JS_MONTH_OFFSET :
@@ -1021,9 +1070,24 @@ var DateObject = /** @class */ (function () {
                     }
                 }
                 else {
-                    switchToNext = hasFixedFormat ?
-                        textToParse.length === segmentLength :
-                        textToParse.length > segmentLength;
+                    if (hasFixedFormat) {
+                        var peekDateSwitchToNext = this.isPeekDateOverflowingDatePart({
+                            useBasePrefixAndSuffix: !this.autoCorrectParts,
+                            middle: middle,
+                            patternValue: patternValue,
+                            basePrefix: basePrefix,
+                            baseSuffix: baseSuffix,
+                            prefix: prefix,
+                            suffix: suffix,
+                            symbol: symbol,
+                            patternLength: patternLength,
+                            leadingZero: leadingZero
+                        }).switchToNext;
+                        switchToNext = peekDateSwitchToNext;
+                    }
+                    else {
+                        switchToNext = textToParse.length > segmentLength;
+                    }
                 }
                 return utils_2.extend(parseResult, {
                     value: null,
@@ -1481,6 +1545,37 @@ var DateObject = /** @class */ (function () {
         }
         return partsForSegment;
     };
+    /**
+     * @hidden
+     */
+    DateObject.prototype.isPeekDateOverflowingDatePart = function (_a) {
+        var useBasePrefixAndSuffix = _a.useBasePrefixAndSuffix, middle = _a.middle, patternValue = _a.patternValue, basePrefix = _a.basePrefix, baseSuffix = _a.baseSuffix, prefix = _a.prefix, suffix = _a.suffix, symbol = _a.symbol, patternLength = _a.patternLength, leadingZero = _a.leadingZero;
+        // 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 peekedValue = this.peek(middle, patternValue);
+        var peekedDateString = useBasePrefixAndSuffix ?
+            "" + 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 parsedPeekedValue = utils_2.parseToInt(peekedValue);
+        if (symbol === "M") {
+        }
+        else if (symbol === "d") {
+        }
+        var switchToNext = peekedDate === null ||
+            (leadingZero[symbol] ?
+                patternValue.length <= middle.length :
+                patternSatisfied);
+        return {
+            peekedDate: peekedDate,
+            peekedDateString: peekedDateString,
+            peekedValue: peekedValue,
+            parsedPeekedValue: parsedPeekedValue,
+            switchToNext: switchToNext
+        };
+    };
     return DateObject;
 }());
 exports.DateObject = DateObject;