@progress/kendo-vue-dateinputs 3.5.0-dev.202208010922 → 3.5.1-dev.202208100944

package/dist/esm/dateinput/models/kendo-date.js

@@ -0,0 +1,338 @@
+import { addMonths, cloneDate, createDate, isEqual, getDate, lastDayOfMonth } from '@progress/kendo-date-math';
+import { Mask } from './mask.js';
+import { dateSymbolMap } from './../utils.js';
+/**
+ * @hidden
+ */
+var KendoDate = /** @class */ (function () {
+    function KendoDate(intlProvider, formatPlaceholder, format) {
+        this.year = true;
+        this.month = true;
+        this.date = true;
+        this.hours = true;
+        this.minutes = true;
+        this.seconds = true;
+        this.milliseconds = true;
+        this.leadingZero = null;
+        this.typedMonthPart = '';
+        this.knownParts = 'adHhmMsEy';
+        this.symbols = {
+            'E': 'E',
+            'H': 'H',
+            'M': 'M',
+            'a': 'a',
+            'd': 'd',
+            'h': 'h',
+            'm': 'm',
+            's': 's',
+            'y': 'y'
+        };
+        this._value = getDate(new Date());
+        this.intlProvider = intlProvider;
+        this.formatPlaceholder = formatPlaceholder;
+        this.format = format;
+        this.monthNames = this.allFormatedMonths();
+    }
+    Object.defineProperty(KendoDate.prototype, "intl", {
+        get: function () {
+            return this.intlProvider();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(KendoDate.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    KendoDate.prototype.setValue = function (value) {
+        if (!value) {
+            this._value = getDate(new Date());
+            this.modifyExisting(false);
+        }
+        else if (!isEqual(value, this._value)) {
+            this._value = cloneDate(value);
+            this.modifyExisting(true);
+        }
+    };
+    KendoDate.prototype.hasValue = function () {
+        var _this = this;
+        var pred = function (a, p) { return a || p.type !== 'literal' && p.type !== 'dayperiod' && _this.getExisting(p.pattern[0]); };
+        return this.intl.splitDateFormat(this.format).reduce(pred, false);
+    };
+    KendoDate.prototype.getDateObject = function () {
+        for (var i = 0; i < this.knownParts.length; i++) {
+            if (!this.getExisting(this.knownParts[i])) {
+                return null;
+            }
+        }
+        return cloneDate(this.value);
+    };
+    KendoDate.prototype.getTextAndFormat = function () {
+        return this.merge(this.intl.formatDate(this.value, this.format), this.dateFormatString(this.value, this.format));
+    };
+    KendoDate.prototype.modifyExisting = function (value) {
+        var sampleFormat = this.dateFormatString(this.value, this.format).symbols;
+        for (var i = 0; i < sampleFormat.length; i++) {
+            this.setExisting(sampleFormat[i], value);
+        }
+    };
+    KendoDate.prototype.getExisting = function (symbol) {
+        switch (symbol) {
+            case 'y': return this.year;
+            case 'M':
+            case 'L': return this.month;
+            case 'd': return this.date;
+            case 'E': return this.date && this.month && this.year;
+            case 'h':
+            case 'H': return this.hours;
+            case 'm': return this.minutes;
+            case 's': return this.seconds;
+            default: return true;
+        }
+    };
+    KendoDate.prototype.setExisting = function (symbol, value) {
+        switch (symbol) {
+            case 'y':
+                // allow 2/29 dates
+                this.year = value;
+                if (value === false) {
+                    this._value.setFullYear(2000);
+                }
+                break;
+            case 'M':
+                // make sure you can type 31 in the day part
+                this.month = value;
+                if (value === false) {
+                    this._value.setMonth(0);
+                }
+                break;
+            case 'd':
+                this.date = value;
+                break;
+            case 'h':
+            case 'H':
+                this.hours = value;
+                break;
+            case 'm':
+                this.minutes = value;
+                break;
+            case 's':
+                this.seconds = value;
+                break;
+            default: return;
+        }
+    };
+    KendoDate.prototype.modifyPart = function (symbol, offset) {
+        var newValue = cloneDate(this.value);
+        switch (symbol) {
+            case 'y':
+                newValue.setFullYear(newValue.getFullYear() + offset);
+                break;
+            case 'M':
+                newValue = addMonths(this.value, offset);
+                break;
+            case 'd':
+            case 'E':
+                newValue.setDate(newValue.getDate() + offset);
+                break;
+            case 'h':
+            case 'H':
+                newValue.setHours(newValue.getHours() + offset);
+                break;
+            case 'm':
+                newValue.setMinutes(newValue.getMinutes() + offset);
+                break;
+            case 's':
+                newValue.setSeconds(newValue.getSeconds() + offset);
+                break;
+            case 'a':
+                newValue.setHours(newValue.getHours() + (12 * offset));
+                break;
+            default: break;
+        }
+        this.setExisting(symbol, true);
+        this._value = newValue;
+    };
+    KendoDate.prototype.parsePart = function (symbol, currentChar) {
+        var _a;
+        this.resetLeadingZero();
+        if (!currentChar) {
+            this.setExisting(symbol, false);
+            return { value: null };
+        }
+        var baseDate = this.intl.formatDate(this.value, this.format);
+        var dateParts = this.dateFormatString(this.value, this.format);
+        var baseFormat = dateParts.symbols;
+        var replaced = false;
+        var prefix = '';
+        var current = '';
+        var suffix = '';
+        for (var i = 0; i < baseDate.length; i++) {
+            if (baseFormat[i] === symbol) {
+                current += this.getExisting(symbol) ? baseDate[i] : '0';
+                replaced = true;
+            }
+            else if (!replaced) {
+                prefix += baseDate[i];
+            }
+            else {
+                suffix += baseDate[i];
+            }
+        }
+        var parsedDate = null;
+        var month = this.matchMonth(currentChar);
+        while (current.length > 0 && current.charAt(0) === '0') {
+            current = current.slice(1);
+        }
+        if (current.length >= 4) {
+            current = '';
+        }
+        for (var i = 0; i < 2; i++) {
+            var middle = current + currentChar;
+            var middleNumber = parseInt(middle, 10);
+            parsedDate = this.intl.parseDate(prefix + middle + suffix, this.format);
+            if (!parsedDate && !isNaN(middleNumber) && !isNaN(parseInt(currentChar, 10))) {
+                if (symbol === 'M' && !month) {
+                    var monthNumber = middleNumber - 1;
+                    if (monthNumber > -1 && monthNumber < 12) {
+                        parsedDate = cloneDate(this.value);
+                        parsedDate.setMonth(monthNumber);
+                        if (parsedDate.getMonth() !== monthNumber) {
+                            parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
+                        }
+                    }
+                }
+                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()) {
+                        parsedDate = lastDayOfMonth(addMonths(parsedDate, -1));
+                    }
+                }
+            }
+            if (parsedDate) {
+                this._value = parsedDate;
+                this.setExisting(symbol, true);
+                return { value: this.value };
+            }
+            current = '';
+        }
+        if (month) {
+            parsedDate = this.intl.parseDate(prefix + month + suffix, this.format);
+            if (parsedDate) {
+                this._value = parsedDate;
+                this.setExisting(symbol, true);
+                return { value: this.value };
+            }
+        }
+        if (currentChar === '0') {
+            this.leadingZero = !this.isAbbrMonth(dateParts.partMap, symbol) ? (_a = {}, _a[symbol] = true, _a) : null;
+            this.setExisting(symbol, false);
+        }
+        return { value: null };
+    };
+    KendoDate.prototype.symbolMap = function (symbol) {
+        return (this.intl.splitDateFormat(this.format)).reduce(dateSymbolMap, {})[symbol];
+    };
+    KendoDate.prototype.resetLeadingZero = function () {
+        var hasLeadingZero = this.leadingZero !== null;
+        this.leadingZero = null;
+        return hasLeadingZero;
+    };
+    KendoDate.prototype.isAbbrMonth = function (parts, symbol) {
+        var pattern = this.partPattern(parts, symbol);
+        return pattern.type === 'month' && pattern.names;
+    };
+    KendoDate.prototype.partPattern = function (parts, symbol) {
+        return parts.filter(function (part) { return part.pattern.indexOf(symbol) !== -1; })[0];
+    };
+    KendoDate.prototype.matchMonth = function (typedChar) {
+        this.typedMonthPart += typedChar.toLowerCase();
+        if (this.monthNames.length === 0) {
+            return '';
+        }
+        while (this.typedMonthPart.length > 0) {
+            for (var i = 0; i < this.monthNames.length; i++) {
+                if (this.monthNames[i].toLowerCase().indexOf(this.typedMonthPart) === 0) {
+                    return this.monthNames[i];
+                }
+            }
+            var monthAsNum = parseInt(this.typedMonthPart, 10);
+            /* ensure they exact match */
+            if (monthAsNum >= 1 && monthAsNum <= 12 && monthAsNum.toString() === this.typedMonthPart) {
+                return this.monthNames[monthAsNum - 1];
+            }
+            this.typedMonthPart = this.typedMonthPart.substring(1, this.typedMonthPart.length);
+        }
+        return '';
+    };
+    KendoDate.prototype.allFormatedMonths = function () {
+        var dateFormatParts = this.intl.splitDateFormat(this.format);
+        for (var i = 0; i < dateFormatParts.length; i++) {
+            if (dateFormatParts[i].type === 'month' && dateFormatParts[i].names) {
+                return this.intl.dateFormatNames(dateFormatParts[i].names);
+            }
+        }
+        return [];
+    };
+    KendoDate.prototype.dateFormatString = function (date, format) {
+        var dateFormatParts = this.intl.splitDateFormat(format);
+        var parts = [];
+        var partMap = [];
+        for (var i = 0; i < dateFormatParts.length; i++) {
+            var partLength = this.intl.formatDate(date, { pattern: dateFormatParts[i].pattern }).length;
+            while (partLength > 0) {
+                parts.push(this.symbols[dateFormatParts[i].pattern[0]] || '_');
+                partMap.push(dateFormatParts[i]);
+                partLength--;
+            }
+        }
+        var returnValue = new Mask();
+        returnValue.symbols = parts.join('');
+        returnValue.partMap = partMap;
+        return returnValue;
+    };
+    KendoDate.prototype.merge = function (text, mask) {
+        // Important: right to left.
+        var resultText = '';
+        var resultFormat = '';
+        var format = mask.symbols;
+        for (var r = format.length - 1; r >= 0; r--) {
+            if (this.knownParts.indexOf(format[r]) === -1 || this.getExisting(format[r])) {
+                resultText = text[r] + resultText;
+                resultFormat = format[r] + resultFormat;
+            }
+            else {
+                var currentSymbol = format[r];
+                while (r >= 0 && currentSymbol === format[r]) {
+                    r--;
+                }
+                r++;
+                if (this.leadingZero && this.leadingZero[currentSymbol]) {
+                    resultText = '0' + resultText;
+                }
+                else {
+                    resultText = this.dateFieldName(mask.partMap[r]) + resultText;
+                }
+                while (resultFormat.length < resultText.length) {
+                    resultFormat = format[r] + resultFormat;
+                }
+            }
+        }
+        return { text: resultText, format: resultFormat };
+    };
+    KendoDate.prototype.dateFieldName = function (part) {
+        var formatPlaceholder = this.formatPlaceholder || 'wide';
+        if (formatPlaceholder[part.type]) {
+            return formatPlaceholder[part.type];
+        }
+        if (formatPlaceholder === 'formatPattern') {
+            return part.pattern;
+        }
+        return this.intl.dateFieldName(Object.assign(part, { nameType: formatPlaceholder }));
+    };
+    return KendoDate;
+}());
+export { KendoDate };

package/dist/esm/dateinput/models/mask.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @hidden
+ */
+export declare class Mask {
+    symbols: string;
+    partMap: any[];
+}

package/dist/esm/dateinput/models/mask.js

@@ -0,0 +1,10 @@
+/**
+ * @hidden
+ */
+var Mask = /** @class */ (function () {
+    function Mask() {
+        this.symbols = '';
+    }
+    return Mask;
+}());
+export { Mask };

package/dist/esm/dateinput/models/selection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @hidden
+ */
+export declare type Selection = {
+    start: number;
+    end: number;
+};

package/dist/esm/dateinput/models/selection.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/dateinput/utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @hidden
+ */
+export declare const defaultFormat = "d";
+/**
+ * @hidden
+ */
+export declare const defaultFormatPlaceholder = "wide";
+/**
+ * @hidden
+ */
+export declare const padZero: (length: any) => string;
+/**
+ * @hidden
+ */
+export declare const approximateStringMatching: (oldTextOrigin: string, oldFormat: string, newTextOrigin: string, selectionStart: number) => any[];
+/**
+ * @hidden
+ */
+export declare const dateSymbolMap: (map: any, part: any) => Function;
+/**
+ * @hidden
+ */
+export declare const isInRange: (candidate: Date | null, min: Date, max: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const invalidClasses: string[];
+/** @hidden */
+export declare const wrapperClasses: string[];

package/dist/esm/dateinput/utils.js

@@ -0,0 +1,83 @@
+/**
+ * @hidden
+ */
+export var defaultFormat = 'd';
+/**
+ * @hidden
+ */
+export var defaultFormatPlaceholder = 'wide';
+/**
+ * @hidden
+ */
+export var padZero = function (length) { return new Array(Math.max(length, 0)).fill('0').join(''); };
+/**
+ * @hidden
+ */
+export var approximateStringMatching = function (oldTextOrigin, oldFormat, newTextOrigin, selectionStart) {
+    /*
+      Remove the right part of the cursor.
+      oldFormat = oldFormat.substring(0, caret + oldText.length - newText.length);
+    */
+    var oldTextSeparator = oldTextOrigin[selectionStart + oldTextOrigin.length - newTextOrigin.length];
+    var oldText = oldTextOrigin.substring(0, selectionStart + oldTextOrigin.length - newTextOrigin.length);
+    var newText = newTextOrigin.substring(0, selectionStart);
+    var diff = [];
+    /* Handle the typing of a single character over the same selection. */
+    if (oldText === newText && selectionStart > 0) {
+        diff.push([oldFormat[selectionStart - 1], newText[selectionStart - 1]]);
+        return diff;
+    }
+    if (oldText.indexOf(newText) === 0 &&
+        (newText.length === 0 || oldFormat[newText.length - 1] !== oldFormat[newText.length])) {
+        /* Handle Delete/Backspace. */
+        var deletedSymbol = '';
+        /*
+            The whole text is replaced by the same character.
+            A nasty patch is required to keep the selection in the first segment.
+        */
+        if (newText.length === 1) {
+            diff.push([oldFormat[0], newText[0]]);
+        }
+        for (var i = newText.length; i < oldText.length; i++) {
+            if (oldFormat[i] !== deletedSymbol && oldFormat[i] !== '_') {
+                deletedSymbol = oldFormat[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 (newText.indexOf(oldText) === 0 || oldFormat[selectionStart - 1] === '_') {
+        var symbol = oldFormat[0];
+        for (var i = Math.max(0, oldText.length - 1); i < oldFormat.length; i++) {
+            if (oldFormat[i] !== '_') {
+                symbol = oldFormat[i];
+                break;
+            }
+        }
+        return [[symbol, newText[selectionStart - 1]]];
+    }
+    /* Handle the entering of a space or a separator for navigating to the next item. */
+    if (newText[newText.length - 1] === ' ' || newText[newText.length - 1] === oldTextSeparator) {
+        return [[oldFormat[selectionStart - 1], '_']];
+    }
+    /* Handle typing over a correctly selected part. */
+    return [[oldFormat[selectionStart - 1], newText[selectionStart - 1]]];
+};
+/**
+ * @hidden
+ */
+export var dateSymbolMap = function (map, part) { map[part.pattern[0]] = part.type; return map; };
+/**
+ * @hidden
+ */
+export var isInRange = function (candidate, min, max) { return (candidate === null || !((min && min > candidate) || (max && max < candidate))); };
+/**
+ * @hidden
+ */
+export var invalidClasses = ['k-invalid'];
+/** @hidden */
+export var wrapperClasses = ['k-dateinput'];

package/dist/esm/datepicker/DatePicker.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => DatePickerData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { DatePickerMethods } from './interfaces/DatePickerMethods';
+import { DatePickerData } from './interfaces/DatePickerData';
+import { DatePickerComputed } from './interfaces/DatePickerComputed';
+import { DatePickerState } from './interfaces/DatePickerState';
+import { DatePickerProps } from './interfaces/DatePickerProps';
+/**
+ * @hidden
+ */
+export interface DatePickerAll extends Vue2type, DatePickerMethods, DatePickerData, DatePickerComputed, DatePickerState {
+}
+/**
+ * @hidden
+ */
+declare let DatePickerVue2: ComponentOptions<DatePickerAll, DefaultData<DatePickerData>, DefaultMethods<DatePickerAll>, DatePickerComputed, RecordPropsDefinition<DatePickerProps>>;
+/**
+ * @hidden
+ */
+declare const DatePicker: DefineComponent<DatePickerProps, any, DatePickerData, DatePickerComputed, DatePickerMethods, {}, {}, {}, string, DatePickerProps, DatePickerProps, {}>;
+export { DatePicker, DatePickerVue2 };