@progress/kendo-dateinputs-common 0.1.0 → 0.2.0-dev.202301061353

package/dist/es2015/dateinput/interaction-mode.js

@@ -0,0 +1,6 @@
+export var DateInputInteractionMode;
+(function (DateInputInteractionMode) {
+    DateInputInteractionMode["None"] = "none";
+    DateInputInteractionMode["Caret"] = "caret";
+    DateInputInteractionMode["Selection"] = "selection";
+})(DateInputInteractionMode || (DateInputInteractionMode = {}));

package/dist/es2015/dateinput/utils.js

@@ -0,0 +1,92 @@
+import { Constants } from '../common/constants';
+import { Key } from '../common/key';
+/**
+ * @hidden
+ */
+export const padZero = (length) => new Array(Math.max(length, 0)).fill('0').join('');
+/**
+ * @hidden
+ */
+export const unpadZero = (value) => value.replace(/^0*/, '');
+/**
+ * @hidden
+ */
+export const approximateStringMatching = ({ oldText, newText, formatPattern, selectionStart, isInCaretMode, keyEvent }) => {
+    /*
+      Remove the right part of the cursor.
+      oldFormat = oldFormat.substring(0, caret + oldText.length - newText.length);
+    */
+    const oldTextSeparator = oldText[selectionStart + oldText.length - newText.length];
+    const oldSegmentText = oldText.substring(0, selectionStart + oldText.length - newText.length);
+    const newSegmentText = newText.substring(0, selectionStart);
+    const diff = [];
+    /* Handle the typing of a single character over the same selection. */
+    if (oldSegmentText === newSegmentText && selectionStart > 0) {
+        diff.push([formatPattern[selectionStart - 1], newSegmentText[selectionStart - 1]]);
+        return diff;
+    }
+    if (oldSegmentText.indexOf(newSegmentText) === 0 && (isInCaretMode &&
+        (keyEvent.key === Key.DELETE || keyEvent.key === Key.BACKSPACE)) ||
+        (oldSegmentText.indexOf(newSegmentText) === 0 && !isInCaretMode &&
+            (newSegmentText.length === 0 ||
+                formatPattern[newSegmentText.length - 1] !== formatPattern[newSegmentText.length]))) {
+        /* Handle Delete/Backspace. */
+        let deletedSymbol = '';
+        /*
+            The whole text is replaced by the same character.
+            A nasty patch is required to keep the selection in the first segment.
+        */
+        if (!isInCaretMode && newSegmentText.length === 1) {
+            diff.push([formatPattern[0], newSegmentText[0]]);
+        }
+        for (let i = newSegmentText.length; i < oldSegmentText.length; i++) {
+            if (formatPattern[i] !== deletedSymbol && formatPattern[i] !== Constants.formatSeparator) {
+                deletedSymbol = formatPattern[i];
+                diff.push([deletedSymbol, '']);
+            }
+        }
+        return diff;
+    }
+    /*
+        Handle the insertion of the text (the new text is longer than the previous one).
+        Handle the typing over a literal as well.
+    */
+    if ((isInCaretMode &&
+        newSegmentText.indexOf(oldSegmentText) === 0 && formatPattern[selectionStart - 1]) ||
+        (!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;
+                }
+            }
+            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) {
+        return [[formatPattern[selectionStart - 1], Constants.formatSeparator]];
+    }
+    /* Handle typing over a correctly selected part. */
+    const result = [[formatPattern[selectionStart - 1], newSegmentText[selectionStart - 1]]];
+    return result;
+};
+/**
+ * @hidden
+ */
+export const dateSymbolMap = (map, part) => {
+    map[part.pattern[0]] = part.type;
+    return map;
+};
+/**
+ * @hidden
+ */
+export const isInRange = (candidate, min, max) => (candidate === null || !((min && min > candidate) || (max && max < candidate)));

package/dist/es2015/main.js

@@ -1 +1 @@
-export { MyClass } from './my-class';
+export { DateInput } from './dateinput/dateinput';

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

@@ -0,0 +1,6 @@
+export declare const Constants: {
+    formatSeparator: string;
+    twoDigitYearMax: number;
+    defaultDateFormat: string;
+    defaultLocaleId: string;
+};

package/dist/npm/common/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Constants = {
+    formatSeparator: "_",
+    twoDigitYearMax: 68,
+    defaultDateFormat: "d",
+    defaultLocaleId: "en"
+};

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

@@ -0,0 +1,172 @@
+import { Mask } from './mask';
+export declare class DateObject {
+    year: boolean;
+    month: boolean;
+    date: boolean;
+    hours: boolean;
+    minutes: boolean;
+    seconds: boolean;
+    milliseconds: boolean;
+    formatPlaceholder: any;
+    format: string | any;
+    intl: any;
+    private leadingZero;
+    private monthNames;
+    private typedMonthPart;
+    private knownParts;
+    private symbols;
+    private _value;
+    value: Date;
+    private readonly localeId;
+    private cycleTime;
+    private dayPeriods;
+    private twoDigitYearMax;
+    private autoCorrectParts;
+    private _partiallyInvalidDate;
+    constructor({ intlService, formatPlaceholder, format, cycleTime, twoDigitYearMax, value, autoCorrectParts }: {
+        intlService: any;
+        formatPlaceholder: any;
+        format: any;
+        cycleTime?: boolean;
+        twoDigitYearMax?: number;
+        value?: any;
+        autoCorrectParts?: boolean;
+    });
+    setValue(value: any): void;
+    /**
+     * @hidden
+     */
+    hasValue(): boolean;
+    /**
+     * @hidden
+     */
+    getValue(): Date;
+    /**
+     * @hidden
+     */
+    getFormattedDate(format: any): string;
+    /**
+     * @hidden
+     */
+    getTextAndFormat(customFormat?: string): any;
+    /**
+     * @hidden
+     */
+    getFormattedInvalidDates(customFormat?: string): any;
+    modifyExisting(value: any): void;
+    /**
+     * @hidden
+     */
+    getExisting(symbol: any): boolean;
+    setExisting(symbol: any, value: any): void;
+    modifyPart(symbol: any, offset: any): void;
+    /**
+     * @hidden
+     */
+    parsePart({ symbol, currentChar, resetSegmentValue, cycleSegmentValue, rawTextValue, isDeleting }: {
+        symbol: any;
+        currentChar: any;
+        resetSegmentValue: any;
+        cycleSegmentValue: any;
+        rawTextValue: any;
+        isDeleting: any;
+    }): any;
+    /**
+     * @hidden
+     */
+    symbolMap(symbol: any): any;
+    /**
+     * @hidden
+     */
+    resetLeadingZero(): boolean;
+    setLeadingZero(leadingZero: any): void;
+    /**
+     * @hidden
+     */
+    normalizeCentury(date: Date): Date;
+    incrementLeadingZero(symbol: any): void;
+    /**
+     * @hidden
+     */
+    isAbbrMonth(parts: any, symbol: any): any;
+    /**
+     * @hidden
+     */
+    partPattern(parts: any, symbol: any): any;
+    /**
+     * @hidden
+     */
+    peek(value: any, pattern: any): string;
+    /**
+     * @hidden
+     */
+    matchMonth(typedChar: any): string;
+    /**
+     * @hidden
+     */
+    matchDayPeriod(typedChar: any, symbol: any): string;
+    /**
+     * @hidden
+     */
+    allFormattedMonths(locale?: string): string[];
+    /**
+     * @hidden
+     */
+    allDayPeriods(locale?: string): string[];
+    /**
+     * @hidden
+     */
+    patternLength(pattern: string): number;
+    /**
+     * @hidden
+     */
+    dateFormatString(date: any, format: any): Mask;
+    /**
+     * @hidden
+     */
+    merge(text: any, mask: any): {
+        text: string;
+        format: string;
+    };
+    /**
+     * @hidden
+     */
+    dateFieldName(part: any): string;
+    /**
+     * @hidden
+     */
+    getNormalizedCenturyBase(twoDigitYear: number): number;
+    /**
+     * @hidden
+     */
+    shouldNormalizeCentury(): boolean;
+    resetInvalidDate(): void;
+    resetInvalidDateSymbol(symbol: any): void;
+    resetInvalidDatePart(symbol: any): void;
+    /**
+     * @hidden
+     */
+    getInvalidDatePart(symbol: any): any;
+    /**
+     * @hidden
+     */
+    getInvalidDatePartValue(symbol: any): any;
+    setInvalidDatePart(symbol: any, { value, date, startDateOffset, startDate }: {
+        value?: any;
+        date?: any;
+        startDateOffset?: number;
+        startDate?: any;
+    }): void;
+    /**
+     * @hidden
+     */
+    modifyDateSymbolWithOffset(date: any, symbol: any, offset: any): {
+        date: Date;
+        timeModified: boolean;
+    };
+    /**
+     * @hidden
+     */
+    modifyDateSymbolWithValue(date: any, symbol: any, value: any): Date;
+    markDatePartsAsExisting(): void;
+}