@progress/kendo-dateinputs-common 0.2.0-dev.202301061341 → 0.2.0-dev.202301101148

package/dist/es2015/common/dateobject.js

@@ -1,7 +1,7 @@
 import { addMonths, cloneDate, createDate, isEqual, getDate, lastDayOfMonth } from '@progress/kendo-date-math';
 import { Mask } from './mask';
 import { dateSymbolMap, padZero, unpadZero } from '../dateinput/utils';
-import { extend, isPresent, cropTwoDigitYear, setYears, parseToInt, clamp, areDatePartsEqualTo, isNumber } from './utils';
+import { extend, isPresent, cropTwoDigitYear, setYears, parseToInt, clamp, areDatePartsEqualTo, isNumber, isValidDate } from './utils';
 import { Constants } from './constants';
 const PREVIOUS_CENTURY_BASE = 1900;
 const CURRENT_CENTURY_BASE = 2000;
@@ -568,7 +568,7 @@ export class DateObject {
     /**
      * @hidden
      */
-    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue, isDeleting }) {
+    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue: rawInputValue, isDeleting, originalFormat }) {
         const isInCaretMode = !cycleSegmentValue;
         const dateParts = this.dateFormatString(this.value, this.format);
         const datePartsLiterals = dateParts.partMap
@@ -576,9 +576,20 @@ export class DateObject {
             .map((x, index) => {
             return {
                 datePartIndex: index,
-                literal: x.pattern
+                type: x.type,
+                pattern: x.pattern,
+                literal: ""
             };
         });
+        for (let i = 0; i < datePartsLiterals.length; i++) {
+            const datePart = datePartsLiterals[i];
+            for (let j = 0; j < datePart.pattern.length; j++) {
+                if (datePartsLiterals[i + j]) {
+                    datePartsLiterals[i + j].literal = datePart.pattern[j];
+                }
+            }
+            i += datePart.pattern.length - 1;
+        }
         let shouldResetPart = isInCaretMode && symbol === "M" && dateParts.partMap
             .filter(x => x.type === "month")
             .some(x => x.pattern.length > MONTH_PART_WITH_WORDS_THRESHOLD);
@@ -591,9 +602,9 @@ export class DateObject {
             if (isInCaretMode) {
                 for (let i = 0; i < datePartsLiterals.length; i++) {
                     const literal = datePartsLiterals[i].literal;
-                    const rawValueStartsWithLiteral = rawTextValue.startsWith(literal);
-                    const rawValueEndsWithLiteral = rawTextValue.endsWith(literal);
-                    const rawValueHasConsecutiveLiterals = rawTextValue.indexOf(literal + literal) >= 0;
+                    const rawValueStartsWithLiteral = rawInputValue.startsWith(literal);
+                    const rawValueEndsWithLiteral = rawInputValue.endsWith(literal);
+                    const rawValueHasConsecutiveLiterals = rawInputValue.indexOf(literal + literal) >= 0;
                     if (rawValueStartsWithLiteral || rawValueEndsWithLiteral || rawValueHasConsecutiveLiterals) {
                         this.resetLeadingZero();
                         this.setExisting(symbol, false);
@@ -616,38 +627,82 @@ export class DateObject {
         let prefix = '';
         let current = '';
         let datePartText = '';
+        let basePrefix = '';
+        let baseSuffix = '';
         let suffix = '';
+        const datePartStartIndex = originalFormat.indexOf(symbol);
+        const datePartEndIndex = originalFormat.lastIndexOf(symbol);
+        const segmentLength = datePartEndIndex - datePartStartIndex + 1;
+        const hasFixedFormat = (this.format === baseFormat) ||
+            (this.format === originalFormat) ||
+            (this.format.length === originalFormat.length);
         if (isInCaretMode) {
-            let datePartIndex = 0;
-            let outOfDatePartBounds = false;
+            let processedSegmentCharsCount = 0;
             for (let i = 0; i < baseDate.length; i++) {
-                const datePartLiteral = datePartsLiterals[datePartIndex];
-                if (datePartLiteral && datePartLiteral === baseDate[i]) {
-                    datePartIndex++;
-                }
                 if (baseFormat[i] === symbol) {
                     const existing = this.getExisting(symbol);
                     current += existing ? baseDate[i] : '0';
-                    const rawInputChar = rawTextValue[i];
-                    if (rawInputChar !== baseDate[i] && rawInputChar === datePartsLiterals[datePartIndex].literal) {
-                        outOfDatePartBounds = true;
-                    }
-                    else if (!outOfDatePartBounds) {
-                        if (rawInputChar === undefined) {
-                            const formatOffset = Math.abs(this.format.length - baseFormat.length);
-                            datePartText += rawTextValue[i - formatOffset] || '';
-                        }
-                        else {
-                            datePartText += rawInputChar || '';
+                    if (isDeleting) {
+                        // when deleting, process (segmentLength - 1) chars
+                        if (processedSegmentCharsCount < segmentLength - 1) {
+                            datePartText += rawInputValue[i] || "";
                         }
+                        processedSegmentCharsCount++;
+                    }
+                    else {
+                        datePartText += rawInputValue[i] || "";
                     }
                     replaced = true;
                 }
                 else if (!replaced) {
                     prefix += baseDate[i];
+                    basePrefix += baseDate[i];
                 }
                 else {
                     suffix += baseDate[i];
+                    baseSuffix += baseDate[i];
+                }
+            }
+            if (hasFixedFormat) {
+                if (originalFormat.length < rawInputValue.length) {
+                    datePartText += currentChar;
+                }
+                if (datePartText.length > segmentLength) {
+                    return extend(parseResult, { value: null, switchToNext: false });
+                }
+            }
+            else {
+                processedSegmentCharsCount = 0;
+                current = "";
+                datePartText = "";
+                prefix = "";
+                suffix = "";
+                replaced = false;
+                for (let i = 0; i < originalFormat.length; i++) {
+                    if (originalFormat[i] === symbol) {
+                        const existing = this.getExisting(symbol);
+                        current += existing ? baseDate[i] || "" : '0';
+                        if (isDeleting) {
+                            // when deleting, process (segmentLength - 1) chars
+                            if (processedSegmentCharsCount < segmentLength - 1) {
+                                datePartText += rawInputValue[i] || "";
+                            }
+                            processedSegmentCharsCount++;
+                        }
+                        else {
+                            datePartText += rawInputValue[i] || "";
+                        }
+                        replaced = true;
+                    }
+                    else if (!replaced) {
+                        prefix += rawInputValue[i] || "";
+                    }
+                    else {
+                        suffix += rawInputValue[i] || "";
+                    }
+                }
+                if (originalFormat.length < rawInputValue.length) {
+                    datePartText += currentChar;
                 }
             }
         }
@@ -682,10 +737,6 @@ export class DateObject {
         }
         const partPattern = this.partPattern(dateParts.partMap, symbol);
         const patternValue = partPattern ? partPattern.pattern : null;
-        if (isInCaretMode && isDeleting) {
-            const padPrefix = padZero(Math.abs(current.length - datePartText.length));
-            current = padPrefix + datePartText;
-        }
         if (isInCaretMode) {
             if (isDeleting && !datePartText) {
                 this.setExisting(symbol, false);
@@ -701,14 +752,29 @@ export class DateObject {
             if (!this.autoCorrectParts) {
                 tryParse = false;
             }
-            let middle = resetSegmentValue ? currentChar : (current.substring(i) + currentChar);
-            if (!tryParse && isInCaretMode) {
+            let middle = resetSegmentValue ?
+                currentChar :
+                isInCaretMode ?
+                    datePartText :
+                    (current.substring(i) + currentChar);
+            if (isInCaretMode) {
                 // try to make an exact match as there will be only 1 attempt
+                tryParse = false;
                 middle = unpadZero(middle);
             }
             let middleNumber = parseInt(middle, 10);
             const candidateDateString = prefix + middle + suffix;
             parsedDate = this.intl.parseDate(candidateDateString, this.format, this.localeId);
+            if (isInCaretMode && !hasFixedFormat && !isValidDate(parsedDate)) {
+                // if part of the date is not available, e.g. "d"
+                // but an expanded format like "F" is used
+                // the element value can be "EEEE, February 1, 2022 3:04:05 AM"
+                // which is not parsable by intl
+                // use the base prefix and suffix, e.g. convert the candidate date string
+                // to "Thursday, February 1, 2022 3:04:05 AM"
+                // as "EEEE, February..." is not parsable
+                parsedDate = this.intl.parseDate(basePrefix + middle + baseSuffix, this.format, this.localeId);
+            }
             const isCurrentCharParsable = !isNaN(parseInt(currentChar, 10)) || (isInCaretMode && isDeleting && currentChar === "");
             if (!parsedDate && !isNaN(middleNumber) && isCurrentCharParsable) {
                 if (symbol === MONTH_SYMBOL && !month) {
@@ -724,18 +790,22 @@ export class DateObject {
                 }
                 if (symbol === 'y') {
                     parsedDate = createDate(parseInt(middle, 10), this.month ? this.value.getMonth() : 0, this.date ? this.value.getDate() : 1, this.hours ? this.value.getHours() : 0, this.minutes ? this.value.getMinutes() : 0, this.seconds ? this.value.getSeconds() : 0, this.milliseconds ? this.value.getMilliseconds() : 0);
-                    if (this.date && parsedDate.getDate() !== this.value.getDate()) {
+                    if (((isInCaretMode && isValidDate(parsedDate)) ||
+                        (!isInCaretMode && parsedDate)) && this.date && parsedDate.getDate() !== this.value.getDate()) {
                         parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
                     }
                 }
             }
-            if (parsedDate) {
+            if ((isInCaretMode && isValidDate(parsedDate)) || (!isInCaretMode && parsedDate)) {
                 // move to next segment if the part will overflow with next char
                 // when start from empty date (01, then 010), padded zeros should be trimmed
                 const peekDate = this.intl.parseDate(`${prefix}${this.peek(middle, patternValue)}${suffix}`, this.format, this.localeId);
                 const patternLength = this.patternLength(patternValue) || patternValue.length;
-                const patternSatisfied = (leadingZero + (unpadZero(middle) || currentChar).length) >= patternLength;
-                const switchToNext = peekDate === null || patternSatisfied;
+                const leadingZeroOffset = (this.leadingZero || {})[symbol] || 0;
+                const patternSatisfied = (leadingZeroOffset + (unpadZero(middle) || currentChar).length) >= patternLength;
+                const switchToNext = peekDate === null ||
+                    (leadingZero[symbol] && patternValue.length <= middle.length) ||
+                    patternSatisfied;
                 if (this.shouldNormalizeCentury()) {
                     parsedDate = this.normalizeCentury(parsedDate);
                 }
@@ -763,6 +833,9 @@ export class DateObject {
             this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? { [symbol]: true } : null;
             this.setExisting(symbol, false);
         }
+        if (isInCaretMode && datePartText.length > segmentLength) {
+            return extend(parseResult, { value: null, switchToNext: false });
+        }
         if (!this.autoCorrectParts) {
             this.setExisting(symbol, false);
             // todo check if string is better
@@ -778,11 +851,14 @@ export class DateObject {
             }
             if (isNumber(datePartValue)) {
                 const newDate = this.modifyDateSymbolWithValue(this.value, symbol, datePartValue);
+                // if (!isEqual(newDate, this.value)) {
+                this.setExisting(symbol, false);
                 this.setInvalidDatePart(symbol, {
                     value: datePartValue,
                     date: cloneDate(newDate),
                     startDate: this._partiallyInvalidDate.startDate || cloneDate(this.value)
                 });
+                // }
             }
         }
         return extend(parseResult, { value: null, switchToNext: false });
@@ -960,7 +1036,10 @@ export class DateObject {
                 }
                 else {
                     if (!this.autoCorrectParts && this.getInvalidDatePartValue(symbol)) {
-                        const segmentText = text.substr(formatSymbolIndex, mask.partMap[formatSymbolIndex].pattern.length);
+                        // use mask.symbols instead of mask.partMap
+                        const part = mask.partMap[formatSymbolIndex];
+                        const pattern = mask.partMap.filter(x => x.type === part.type && x.pattern === part.pattern);
+                        const segmentText = text.substr(formatSymbolIndex, pattern.length);
                         resultText = segmentText + resultText;
                     }
                     else {

package/dist/es2015/common/utils.js

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

package/dist/es2015/dateinput/dateinput.js

@@ -2,7 +2,7 @@ import { DateObject } from '../common/dateobject';
 import { approximateStringMatching } from './utils';
 import { KeyCode } from '../common/keycode';
 import { Key } from '../common/key';
-import { extend, isPresent, isDocumentAvailable, millisecondDigitsInFormat, millisecondStepFor, isDate } from '../common/utils';
+import { extend, isPresent, isDocumentAvailable, millisecondDigitsInFormat, millisecondStepFor, isValidDate } from '../common/utils';
 import { Observable } from '../common/observable';
 import { DateInputInteractionMode } from './interaction-mode';
 import { isEqual, cloneDate } from '@progress/kendo-date-math';
@@ -71,19 +71,19 @@ export class DateInput extends Observable {
         this.currentText = '';
         this.currentFormat = '';
         this.interactionMode = DateInputInteractionMode.None;
-        this.localeId = Constants.defaultLocaleId;
+        this.previousElementSelection = { start: 0, end: 0 };
         this.init(element, options);
     }
     get value() {
         return this.dateObject && this.dateObject.getValue();
     }
     init(element, options) {
-        let dateValue = isDate(this.options.value) ? cloneDate(this.options.value) : new Date(options.formattedValue);
-        if (!isDate(dateValue)) {
+        let dateValue = isValidDate(this.options.value) ? cloneDate(this.options.value) : new Date(options.formattedValue);
+        if (!isValidDate(dateValue)) {
             dateValue = null;
         }
         this.element = element;
-        // this.element._kendoWidget = this;
+        this.element._kendoWidget = this;
         this.options = extend({}, defaultDateInputOptions, options);
         this.intl = this.options.intlService;
         this.formatPlaceholder = this.options.formatPlaceholder ? this.options.formatPlaceholder : 'formatPattern';
@@ -263,33 +263,48 @@ export class DateInput extends Observable {
         const hasCaret = this.isInCaretMode();
         if (hasCaret && this.keyDownEvent.key === Key.SPACE) {
             // do not allow custom "holes" in the date segments
-            this.setPreviousInputEventState(this.keyDownEvent);
+            this.restorePreviousInputEventState();
             return;
         }
         const oldDateObjectValue = this.dateObject && this.dateObject.getValue();
         const { text: currentText, format: currentFormat } = this.dateObject.getTextAndFormat();
         this.currentFormat = currentFormat;
-        const text = hasCaret && (isBackspaceKey || isDeleteKey) ? this.previousElementValue : currentText;
+        let text = "";
+        if (hasCaret) {
+            if (isBackspaceKey || isDeleteKey) {
+                text = this.previousElementValue;
+            }
+            else if (originalInteractionMode === DateInputInteractionMode.Caret) {
+                text = this.previousElementValue;
+            }
+            else {
+                text = currentText;
+            }
+        }
+        else {
+            text = currentText;
+        }
+        const newText = this.elementValue;
         const diff = approximateStringMatching({
             oldText: text,
-            newText: this.element.value,
+            newText: newText,
             formatPattern: this.currentFormat,
             selectionStart: this.selection.start,
             isInCaretMode: hasCaret,
             keyEvent: this.keyDownEvent
         });
         if (hasCaret && (!diff || diff.length === 0)) {
-            this.setPreviousInputEventState(this.keyDownEvent);
+            this.restorePreviousInputEventState();
             return;
         }
         else if (hasCaret && diff.length === 1) {
             if (!diff[0] || !diff[0][0]) {
-                this.setPreviousInputEventState(this.keyDownEvent);
+                this.restorePreviousInputEventState();
                 return;
             }
             else if (hasCaret && diff[0] &&
                 (diff[0][0] === Constants.formatSeparator || diff[0][1] === Constants.formatSeparator)) {
-                this.setPreviousInputEventState(this.keyDownEvent);
+                this.restorePreviousInputEventState();
                 return;
             }
         }
@@ -304,7 +319,8 @@ export class DateInput extends Observable {
                     resetSegmentValue: this.resetSegmentValue,
                     cycleSegmentValue: !this.isInCaretMode(),
                     rawTextValue: this.element.value,
-                    isDeleting: isBackspaceKey || isDeleteKey
+                    isDeleting: isBackspaceKey || isDeleteKey,
+                    originalFormat: this.currentFormat
                 });
                 parsePartsResults.push(parsePartResult);
                 switchPart = parsePartResult.switchToNext;
@@ -342,6 +358,29 @@ export class DateInput extends Observable {
                     }
                 }
             }
+            else if (hasCaret) {
+                if (this.options.format.length !== this.currentFormat.length) {
+                    if (hasDateValueChanged && isPresent(this.dateObject.value)) {
+                        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 (hasDateValueChanged) {
+                        if (lastParseResultHasNoValue) {
+                            this.restorePreviousInputEventState();
+                        }
+                    }
+                    else {
+                        this.restorePreviousInputEventState();
+                    }
+                }
+            }
         }
         if (!switchPart && hasCaret && !isBackspaceKey && !isDeleteKey && !resetPart && lastParseResultHasNoValue) {
             if (hasDateValueChanged) {
@@ -358,10 +397,13 @@ export class DateInput extends Observable {
                         this.setSelection(this.selectionBySymbol(symbolForSelection));
                     }
                     else {
-                        this.setPreviousInputEventState(this.keyDownEvent);
+                        this.restorePreviousInputEventState();
                     }
                 }
             }
+            else {
+                this.restorePreviousInputEventState();
+            }
         }
         else if (this.options.autoSwitchParts && (switchPart || navigationOnly)) {
             if (!hasCaret) {
@@ -373,6 +415,12 @@ export class DateInput extends Observable {
             event: e
         });
         this.triggerInputEnd({ event: e });
+        if (hasCaret) {
+            // a format like "F" can dynamically change the resolved format pattern based on the value, e.g.
+            // "Tuesday, February 1, 2022 3:04:05 AM" becomes
+            // "Wednesday, February 2, 2022 3:04:05 AM" giving a diff of 2 ("Tuesday".length - "Wednesday".length)
+            this.setTextAndFormat();
+        }
     }
     /**
      * @hidden
@@ -418,6 +466,8 @@ export class DateInput extends Observable {
         }
         this.keyDownEvent = e;
         this.previousElementValue = this.element.value;
+        const { start, end } = this.selection;
+        this.previousElementSelection = { start, end };
         const autoSwitchKeys = (this.options.autoSwitchKeys || [])
             .map(x => x.toString().toLowerCase().trim());
         if (autoSwitchKeys.indexOf(e.keyCode.toString()) >= 0 ||
@@ -800,7 +850,6 @@ export class DateInput extends Observable {
      * @hidden
      */
     setElementValue(value) {
-        this.previousElementValue = this.element.value;
         this.element.value = value;
     }
     /**
@@ -836,23 +885,25 @@ export class DateInput extends Observable {
         }
         /* eslint-enable no-fallthrough */
     }
-    setPreviousInputEventState(keyDownEvent) {
-        const { start: selectionStart, end: selectionEnd } = this.selection;
-        let selectionOffset = -1;
-        if (keyDownEvent.keyCode === KeyCode.BACKSPACE) {
-            selectionOffset = 1;
-        }
-        else if (keyDownEvent.keyCode === KeyCode.DELETE) {
-            selectionOffset = 0;
-        }
-        else if (keyDownEvent.keyCode === KeyCode.SPACE) {
-            selectionOffset = -1;
-        }
-        else {
-            selectionOffset = -1;
-        }
+    /**
+     * @hidden
+     */
+    restorePreviousInputEventState() {
+        this.restorePreviousElementValue();
+        this.restorePreviousElementSelection();
+    }
+    /**
+     * @hidden
+     */
+    restorePreviousElementValue() {
         this.setElementValue(this.previousElementValue || '');
-        this.setSelection({ start: selectionStart + selectionOffset, end: selectionEnd + selectionOffset });
+    }
+    /**
+     * @hidden
+     */
+    restorePreviousElementSelection() {
+        const { start, end } = this.previousElementSelection;
+        this.setSelection({ start: start || 0, end: end || 0 });
     }
     writeValue(value) {
         this.verifyValue(value);
@@ -860,7 +911,7 @@ export class DateInput extends Observable {
         this.refreshElementValue();
     }
     verifyValue(value) {
-        if (value && !isDate(value)) {
+        if (value && !isValidDate(value)) {
             throw new Error("The 'value' should be a valid JavaScript Date instance.");
         }
     }
@@ -878,6 +929,7 @@ export class DateInput extends Observable {
             element.placeholder = this.options.placeholder;
         }
         const newElementValue = !showPlaceholder ? currentText : "";
+        this.previousElementValue = this.elementValue;
         this.setElementValue(newElementValue);
         if (this.isActive && !this.options.allowCaretMode && this.options.selectNearestSegmentOnFocus) {
             this.selectNearestSegment(start);
@@ -959,10 +1011,10 @@ export class DateInput extends Observable {
             intlService: this.intl,
             formatPlaceholder: this.formatPlaceholder,
             format: this.inputFormat,
-            localeId: this.localeId,
             cycleTime: this.options.cycleTime,
             twoDigitYearMax: this.options.twoDigitYearMax,
-            autoCorrectParts: this.options.autoCorrectParts
+            autoCorrectParts: this.options.autoCorrectParts,
+            value: this.options.value
         }, options));
         return dateObject;
     }

package/dist/es2015/dateinput/utils.js

@@ -52,27 +52,23 @@ export const approximateStringMatching = ({ oldText, newText, formatPattern, sel
         Handle the typing over a literal as well.
     */
     if ((isInCaretMode &&
-        newSegmentText.indexOf(oldSegmentText) === 0 && formatPattern[selectionStart - 1]) ||
+        (newSegmentText.indexOf(oldSegmentText) === 0 ||
+            formatPattern[selectionStart - 1] === Constants.formatSeparator)) ||
         (!isInCaretMode &&
             (newSegmentText.indexOf(oldSegmentText) === 0 ||
                 formatPattern[selectionStart - 1] === Constants.formatSeparator))) {
-        if (isInCaretMode) {
-            let symbol = formatPattern[selectionStart - 1];
-            return [[symbol, newSegmentText[selectionStart - 1]]];
-        }
-        else {
-            let symbol = formatPattern[0];
-            for (let i = Math.max(0, oldSegmentText.length - 1); i < formatPattern.length; i++) {
-                if (formatPattern[i] !== Constants.formatSeparator) {
-                    symbol = formatPattern[i];
-                    break;
-                }
+        let symbol = formatPattern[0];
+        for (let i = Math.max(0, oldSegmentText.length - 1); i < formatPattern.length; i++) {
+            if (formatPattern[i] !== Constants.formatSeparator) {
+                symbol = formatPattern[i];
+                break;
             }
-            return [[symbol, newSegmentText[selectionStart - 1]]];
         }
+        return [[symbol, newSegmentText[selectionStart - 1]]];
     }
     /* Handle the entering of a space or a separator for navigating to the next item. */
-    if (newSegmentText[newSegmentText.length - 1] === ' ' || newSegmentText[newSegmentText.length - 1] === oldTextSeparator) {
+    if ((!isInCaretMode && newSegmentText[newSegmentText.length - 1] === ' ') ||
+        (!isInCaretMode && newSegmentText[newSegmentText.length - 1] === oldTextSeparator)) {
         return [[formatPattern[selectionStart - 1], Constants.formatSeparator]];
     }
     /* Handle typing over a correctly selected part. */

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

@@ -63,13 +63,14 @@ export declare class DateObject {
     /**
      * @hidden
      */
-    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue, isDeleting }: {
+    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue: rawInputValue, isDeleting, originalFormat }: {
         symbol: any;
         currentChar: any;
         resetSegmentValue: any;
         cycleSegmentValue: any;
         rawTextValue: any;
         isDeleting: any;
+        originalFormat: any;
     }): any;
     /**
      * @hidden