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

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

@@ -0,0 +1,56 @@
+/**
+ * @hidden
+ */
+export declare const generateGetters: (parts: any) => any;
+/**
+ * @hidden
+ */
+export declare const generateSnappers: (steps: any, min: any) => any;
+/**
+ * @hidden
+ */
+export declare const valueMerger: (getters: any) => (origin: any, candidate: any) => any;
+/**
+ * @hidden
+ */
+export declare const snapTime: (snappers: any) => (candidate: any) => any;
+/**
+ * @hidden
+ */
+export declare const setHours: (date: Date, value: number) => Date;
+/**
+ * @hidden
+ */
+export declare const setMinutes: (date: Date, value: number) => Date;
+/**
+ * @hidden
+ */
+export declare const setSeconds: (date: Date, value: number) => Date;
+/**
+ * @hidden
+ */
+export declare const getNow: () => Date;
+/**
+ * @hidden
+ */
+export declare const range: (start: number, end: number, step?: number) => number[];
+/**
+ * @hidden
+ */
+export declare const timeInRange: (candidate: Date, min: Date, max: Date) => Date;
+/**
+ * @hidden
+ */
+export declare const isInTimeRange: (candidate: Date | null, min?: Date, max?: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const isInRange: (candidate: Date | null, min: Date, max: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const isSmallerThanMin: (val: Date | null, min: Date | null) => boolean;
+/**
+ * @hidden
+ */
+export declare const isBiggerThanMax: (val: Date | null, max: Date | null) => boolean;

package/dist/esm/timepicker/utils.js

@@ -0,0 +1,149 @@
+import { cloneDate, addDays } from '@progress/kendo-date-math';
+import { TIME_PART } from './models/TimePart.js';
+import { MIDNIGHT_DATE, setTime } from '../utils.js';
+var setter = function (method) { return function (date, value) {
+    var clone = cloneDate(date);
+    clone[method](value);
+    return clone;
+}; };
+var defaultGetters = [
+    { type: TIME_PART.hour, getter: function (value) { return value.getHours(); } },
+    { type: TIME_PART.minute, getter: function (value) { return value.getMinutes(); } },
+    { type: TIME_PART.second, getter: function (value) { return value.getSeconds(); } },
+    { type: TIME_PART.millisecond, getter: function (value) { return value.getMilliseconds(); } }
+];
+var left = function (getter) { return function (origin, _) { return getter(origin); }; };
+var right = function (getter) { return function (_, candidate) { return getter(candidate); }; };
+var convertToObject = function (parts) { return parts.reduce(function (obj, p) { obj[p.type] = p.type; return obj; }, {}); };
+var getterByPart = function (parts) { return function (g) { return parts[g.type] ? right(g.getter) : left(g.getter); }; };
+var gettersFactory = function (getters) { return function (parts) { return (getters.map(getterByPart(convertToObject(parts)))); }; };
+var snapValue = function (getter, step, min, type) { return function (date) {
+    var value = getter(date);
+    var minValue = getter(min);
+    if (type === 'hour') {
+        return value - ((value - minValue) % step);
+    }
+    if (date.getTime() <= min.getTime()
+        && value !== 0
+        && value <= minValue) {
+        return (Math.ceil(value / step)) * step;
+    }
+    return value - (value % step);
+}; };
+var snappersFactory = function (getters) { return function (steps, min) { return (getters.map(function (g) {
+    var step = Math.floor(steps[g.type]);
+    return step ? snapValue(g.getter, step, min, g.type) : g.getter;
+})); }; };
+/**
+ * @hidden
+ */
+export var generateGetters = gettersFactory(defaultGetters);
+/**
+ * @hidden
+ */
+export var generateSnappers = snappersFactory(defaultGetters);
+/**
+ * @hidden
+ */
+export var valueMerger = function (getters) { return function (origin, candidate) {
+    origin.setHours.apply(origin, getters.map(function (g) { return g(origin, candidate); }));
+    return origin;
+}; };
+/**
+ * @hidden
+ */
+export var snapTime = function (snappers) { return function (candidate) {
+    var date = cloneDate(candidate);
+    date.setHours.apply(date, snappers.map(function (s) { return s(date); }));
+    return date;
+}; };
+/**
+ * @hidden
+ */
+export var setHours = setter('setHours');
+/**
+ * @hidden
+ */
+export var setMinutes = setter('setMinutes');
+/**
+ * @hidden
+ */
+export var setSeconds = setter('setSeconds');
+/**
+ * @hidden
+ */
+export var getNow = function () { return new Date(); };
+/**
+ * @hidden
+ */
+export var range = function (start, end, step) {
+    if (step === void 0) { step = 1; }
+    var result = [];
+    for (var i = start; i < end; i = i + step) {
+        result.push(i);
+    }
+    return result;
+};
+var normalizeTimes = function (candidate, min, max) { return ({
+    candidateValue: setTime(MIDNIGHT_DATE, candidate),
+    maxValue: addDays(setTime(MIDNIGHT_DATE, max), min.getHours() < max.getHours() ? 0 : 1),
+    minValue: setTime(MIDNIGHT_DATE, min)
+}); };
+/**
+ * @hidden
+ */
+export var timeInRange = function (candidate, min, max) {
+    if (!candidate || !min || !max) {
+        return candidate;
+    }
+    var _a = normalizeTimes(candidate, min, max), candidateValue = _a.candidateValue, minValue = _a.minValue, maxValue = _a.maxValue;
+    if (candidateValue < minValue) {
+        return setTime(candidate, min);
+    }
+    if (candidateValue > maxValue) {
+        return setTime(candidate, max);
+    }
+    return candidate;
+};
+/**
+ * @hidden
+ */
+export var isInTimeRange = function (candidate, min, max) {
+    if (!candidate || !min || !max) {
+        return true;
+    }
+    var _a = normalizeTimes(candidate, min, max), candidateValue = _a.candidateValue, minValue = _a.minValue, maxValue = _a.maxValue;
+    return minValue <= candidateValue && candidateValue <= maxValue;
+};
+/**
+ * @hidden
+ */
+export var isInRange = function (candidate, min, max) {
+    if (candidate === null) {
+        return true;
+    }
+    var _a = normalizeTimes(candidate, min, max), candidateValue = _a.candidateValue, minValue = _a.minValue, maxValue = _a.maxValue;
+    return minValue <= candidateValue && candidateValue <= maxValue;
+};
+/**
+ * @hidden
+ */
+export var isSmallerThanMin = function (val, min) {
+    if (val === null || min === null) {
+        return false;
+    }
+    var normalizedValue = setTime(MIDNIGHT_DATE, val);
+    var normalizedMin = setTime(MIDNIGHT_DATE, min);
+    return normalizedValue.getTime() < normalizedMin.getHours();
+};
+/**
+ * @hidden
+ */
+export var isBiggerThanMax = function (val, max) {
+    if (val === null || max === null) {
+        return false;
+    }
+    var normalizedValue = setTime(MIDNIGHT_DATE, val);
+    var normalizedMax = setTime(MIDNIGHT_DATE, max);
+    return normalizedMax.getTime() < normalizedValue.getHours();
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1,70 @@
+import { SelectionRange } from './calendar/models/SelectionRange';
+import { CalendarViewEnum } from './calendar/models/CalendarViewEnum';
+/**
+ * @hidden
+ */
+export declare const isEqualRange: (initial: SelectionRange, updated: SelectionRange) => boolean;
+/**
+ * @hidden
+ */
+export declare const viewInRange: (candidate: CalendarViewEnum, min: CalendarViewEnum, max: CalendarViewEnum) => CalendarViewEnum;
+/**
+ * @hidden
+ */
+export declare const MIDNIGHT_DATE: Date;
+/**
+ * @hidden
+ */
+export declare const MIN_DATE: Date;
+/**
+ * @hidden
+ */
+export declare const MAX_DATE: Date;
+/**
+ * @hidden
+ */
+export declare const MIN_TIME: Date;
+/**
+ * @hidden
+ */
+export declare const MAX_TIME: Date;
+/**
+ * @hidden
+ */
+export declare const isValidRange: (min: Date, max: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const setTime: (origin: Date, candidate: Date) => Date;
+/**
+ * @hidden
+ */
+export declare const getToday: () => Date;
+/**
+ * @hidden
+ */
+export declare const isInRange: (candidate: Date, min: Date, max: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const isInDateRange: (candidate: Date | null, min: Date, max: Date) => boolean;
+/**
+ * @hidden
+ */
+export declare const isInSelectionRange: (value: Date, selectionRange?: SelectionRange) => boolean;
+/**
+ * @hidden
+ */
+export declare const range: (start: number, end: number, step?: number) => number[];
+/**
+ * @hidden
+ */
+export declare const shiftWeekNames: (names: string[], offset: number) => string[];
+/**
+ * @hidden
+ */
+export declare const dateInRange: (candidate: Date, min: Date, max: Date) => Date;
+/**
+ * @hidden
+ */
+export declare const domContainerFactory: (type: string) => (children: string | HTMLElement[], classes?: string, styles?: any) => HTMLElement;

package/dist/esm/utils.js

@@ -0,0 +1,131 @@
+import { cloneDate, isEqual } from '@progress/kendo-date-math';
+import { getDate } from '@progress/kendo-date-math';
+import { EMPTY_SELECTIONRANGE } from './calendar/models/SelectionRange.js';
+/**
+ * @hidden
+ */
+export var isEqualRange = function (initial, updated) {
+    var _a = initial || EMPTY_SELECTIONRANGE, initialStart = _a.start, initialEnd = _a.end;
+    var _b = updated || EMPTY_SELECTIONRANGE, updatedStart = _b.start, updatedEnd = _b.end;
+    if (initialStart === null || initialEnd === null || updatedStart === null || updatedEnd === null) {
+        return false;
+    }
+    return isEqual(initialStart, updatedStart) && isEqual(initialEnd, updatedEnd);
+};
+/**
+ * @hidden
+ */
+export var viewInRange = function (candidate, min, max) {
+    if (min === undefined || max === undefined) {
+        return candidate;
+    }
+    return min <= candidate && candidate <= max
+        ? candidate
+        : candidate < min
+            ? min
+            : max;
+};
+/**
+ * @hidden
+ */
+export var MIDNIGHT_DATE = new Date(1980, 0, 1);
+/**
+ * @hidden
+ */
+export var MIN_DATE = new Date(1900, 0, 1);
+/**
+ * @hidden
+ */
+export var MAX_DATE = new Date(2099, 11, 31);
+/**
+ * @hidden
+ */
+export var MIN_TIME = new Date(1980, 0, 1);
+/**
+ * @hidden
+ */
+export var MAX_TIME = new Date(1980, 0, 1, 23, 59, 59);
+var isSet = function (value) { return value !== null && value !== undefined; };
+/**
+ * @hidden
+ */
+export var isValidRange = function (min, max) { return (!isSet(min) || !isSet(max) || min <= max); };
+/**
+ * @hidden
+ */
+export var setTime = function (origin, candidate) {
+    var date = cloneDate(origin);
+    date.setHours(candidate.getHours(), candidate.getMinutes(), candidate.getSeconds(), candidate.getMilliseconds());
+    return date;
+};
+/**
+ * @hidden
+ */
+export var getToday = function () { return getDate(new Date()); };
+/**
+ * @hidden
+ */
+export var isInRange = function (candidate, min, max) { return (!candidate || !((min && min > candidate) || (max && max < candidate))); };
+/**
+ * @hidden
+ */
+export var isInDateRange = function (candidate, min, max) { return (candidate === null
+    || !((min && getDate(min) > getDate(candidate))
+        || (max && getDate(max) < getDate(candidate)))); };
+/**
+ * @hidden
+ */
+export var isInSelectionRange = function (value, selectionRange) {
+    var _a = selectionRange || EMPTY_SELECTIONRANGE, start = _a.start, end = _a.end;
+    if (!start || !end) {
+        return false;
+    }
+    return start < value && value < end;
+};
+/**
+ * @hidden
+ */
+export var range = function (start, end, step) {
+    if (step === void 0) { step = 1; }
+    var result = [];
+    for (var i = start; i < end; i = i + step) {
+        result.push(i);
+    }
+    return result;
+};
+/**
+ * @hidden
+ */
+export var shiftWeekNames = function (names, offset) { return (names.slice(offset).concat(names.slice(0, offset))); };
+/**
+ * @hidden
+ */
+export var dateInRange = function (candidate, min, max) {
+    if (!candidate) {
+        return candidate;
+    }
+    if (min && candidate < min) {
+        return cloneDate(min);
+    }
+    if (max && candidate > max) {
+        return cloneDate(max);
+    }
+    return candidate;
+};
+/**
+ * @hidden
+ */
+export var domContainerFactory = function (type) { return function (children, classes, styles) {
+    if (classes === void 0) { classes = ''; }
+    if (styles === void 0) { styles = {}; }
+    var container = document.createElement(type);
+    container.className = classes;
+    Object.keys(styles).map(function (key) { return container.style[key] = styles[key]; });
+    if (typeof children === 'string') {
+        container.innerHTML = children || '';
+    }
+    else {
+        (children || []).forEach(function (child) { return child && container.appendChild(child); });
+    }
+    return container;
+}; };

package/dist/esm/virtualization/Virtualization.d.ts

@@ -0,0 +1,114 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { RowHeightService, ScrollerService, ScrollAction, PageAction } from './services';
+/**
+ * @hidden
+ */
+export interface ScrollActionArguments {
+    index: number;
+    target: HTMLDivElement | null;
+    scrollAction?: ScrollAction;
+    pageAction?: PageAction;
+    animationInProgress: boolean;
+}
+/**
+ * @hidden
+ */
+export declare enum ScrollDirection {
+    Backward = 0,
+    Forward = 1
+}
+/**
+ * @hidden
+ */
+export declare type Direction = 'horizontal' | 'vertical';
+/**
+ * @hidden
+ */
+export interface VirtualizationState {
+    cancelAnimation: any;
+    rowHeightService: RowHeightService;
+    scrollerService: ScrollerService;
+    scrollContainer: any;
+    scrollAction?: ScrollAction;
+    pageAction?: PageAction;
+    lastDirection: Direction;
+    lastTotal?: number;
+    lastTake: number;
+    animationInProgress: boolean;
+}
+/**
+ * @hidden
+ */
+export interface VirtualizationData {
+}
+/**
+ * @hidden
+ */
+export interface VirtualizationMethods {
+    [key: string]: any;
+    activeIndex: () => number;
+    itemIndex: (offset: number) => number;
+    itemOffset: (index: number) => number;
+    isIndexVisible: (index: number) => boolean;
+    isListScrolled: (index: number) => boolean;
+    scrollTo: (value: number) => void;
+    scrollToIndex: (index: number) => void;
+    animateToIndex: (index: number) => void;
+    scrollToBottom: () => void;
+    scrollStep: (start: number, end: number) => number;
+    scrollRange: (indexOffset: number, direction: ScrollDirection) => any;
+    containerMaxScroll: () => number;
+    getContainerScrollDirection: (indexOffset: number) => ScrollDirection;
+    initServices: (props?: any) => void;
+    getContainerProperty: (propertyName: string) => number;
+    handleScroll: (event: any) => void;
+    handleScrollAction: (action: ScrollAction) => void;
+    handlePageAction: (action: PageAction) => void;
+    containerOffsetSize: () => number;
+    containerScrollSize: () => number;
+    containerScrollPosition: () => number;
+}
+/**
+ * @hidden
+ */
+export interface VirtualizationComputed {
+    [key: string]: any;
+    element: HTMLDivElement | null;
+}
+/**
+ * @hidden
+ */
+export interface VirtualizationProps {
+    bottomOffset: number;
+    direction?: String;
+    forceScroll?: boolean;
+    itemHeight?: number;
+    itemWidth?: number;
+    maxScrollDifference?: number;
+    scrollOffsetSize?: number;
+    scrollDuration?: number;
+    skip: number;
+    tabIndex?: number;
+    take: number;
+    topOffset: number;
+    total: number;
+    role?: string;
+}
+/**
+ * @hidden
+ */
+export interface VirtualizationAll extends Vue2type, VirtualizationMethods, VirtualizationData, VirtualizationComputed, VirtualizationState {
+}
+/**
+ * @hidden
+ */
+declare let VirtualizationVue2: ComponentOptions<VirtualizationAll, DefaultData<VirtualizationData>, DefaultMethods<VirtualizationAll>, VirtualizationComputed, RecordPropsDefinition<VirtualizationProps>>;
+/**
+ * @hidden
+ */
+declare const Virtualization: DefineComponent<VirtualizationProps, any, VirtualizationData, VirtualizationComputed, VirtualizationMethods, {}, {}, {}, string, VirtualizationProps, VirtualizationProps, {}>;
+export { Virtualization, VirtualizationVue2 };