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

package/dist/esm/recurrence/types/WeekDayRule.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @hidden
+ *
+ */
+export interface WeekDayRule {
+    day: number;
+    offset: number;
+}

package/dist/esm/recurrence/types/WeekDayRule.js

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

package/dist/esm/recurrence/utils/index.d.ts

@@ -0,0 +1 @@
+

package/dist/esm/reducers/editReducer.d.ts

@@ -0,0 +1,33 @@
+import { DataItem } from '../models';
+/** @hidden */
+export interface SchedulerEditState {
+    dataItem?: DataItem;
+    editDialog: boolean;
+    occurrenceDialog: boolean;
+    drop?: boolean;
+    removeDialog: boolean;
+    removeOccurrenceDialog: boolean;
+}
+/** @hidden */
+export declare const EDIT_INITIAL_STATE: SchedulerEditState;
+/** @hidden */
+export interface SchedulerEditAction {
+    type: EDIT_ACTIONS;
+    payload?: DataItem;
+    original?: DataItem;
+    finishCallback?: (event: any) => void;
+}
+/** @hidden */
+export declare enum EDIT_ACTIONS {
+    CREATE = 0,
+    EDIT = 1,
+    EDIT_OCCURRENCE = 2,
+    EDIT_CONFIRM = 3,
+    EDIT_DROP_OCCURRENCE = 4,
+    REMOVE = 5,
+    REMOVE_OCCURRENCE = 6,
+    REMOVE_CONFIRM = 7,
+    RESET = 8
+}
+/** @hidden */
+export declare const editReducer: (state: SchedulerEditState, action: SchedulerEditAction) => SchedulerEditState;

package/dist/esm/reducers/editReducer.js

@@ -0,0 +1,65 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+/** @hidden */
+export var EDIT_INITIAL_STATE = {
+    dataItem: undefined,
+    drop: false,
+    editDialog: false,
+    occurrenceDialog: false,
+    removeDialog: false,
+    removeOccurrenceDialog: false
+};
+/** @hidden */
+export var EDIT_ACTIONS;
+(function (EDIT_ACTIONS) {
+    EDIT_ACTIONS[EDIT_ACTIONS["CREATE"] = 0] = "CREATE";
+    EDIT_ACTIONS[EDIT_ACTIONS["EDIT"] = 1] = "EDIT";
+    EDIT_ACTIONS[EDIT_ACTIONS["EDIT_OCCURRENCE"] = 2] = "EDIT_OCCURRENCE";
+    EDIT_ACTIONS[EDIT_ACTIONS["EDIT_CONFIRM"] = 3] = "EDIT_CONFIRM";
+    EDIT_ACTIONS[EDIT_ACTIONS["EDIT_DROP_OCCURRENCE"] = 4] = "EDIT_DROP_OCCURRENCE";
+    EDIT_ACTIONS[EDIT_ACTIONS["REMOVE"] = 5] = "REMOVE";
+    EDIT_ACTIONS[EDIT_ACTIONS["REMOVE_OCCURRENCE"] = 6] = "REMOVE_OCCURRENCE";
+    EDIT_ACTIONS[EDIT_ACTIONS["REMOVE_CONFIRM"] = 7] = "REMOVE_CONFIRM";
+    EDIT_ACTIONS[EDIT_ACTIONS["RESET"] = 8] = "RESET";
+})(EDIT_ACTIONS || (EDIT_ACTIONS = {}));
+/** @hidden */
+export var editReducer = function (state, action) {
+    var newState;
+    switch (action.type) {
+        case EDIT_ACTIONS.CREATE:
+            newState = __assign(__assign({}, state), { dataItem: action.payload, editDialog: true });
+            break;
+        case EDIT_ACTIONS.EDIT:
+            newState = __assign(__assign({}, state), { dataItem: action.payload, editDialog: true, occurrenceDialog: false });
+            break;
+        case EDIT_ACTIONS.EDIT_OCCURRENCE:
+            newState = __assign(__assign({}, state), { dataItem: action.payload, occurrenceDialog: true });
+            break;
+        case EDIT_ACTIONS.EDIT_DROP_OCCURRENCE:
+            newState = __assign(__assign({}, state), { dataItem: action.original, drop: action.payload, occurrenceDialog: true });
+            break;
+        case EDIT_ACTIONS.REMOVE:
+            newState = __assign(__assign({}, state), { dataItem: action.payload, removeDialog: true });
+            break;
+        case EDIT_ACTIONS.REMOVE_OCCURRENCE:
+            newState = __assign(__assign({}, state), { dataItem: action.payload, removeOccurrenceDialog: true });
+            break;
+        case EDIT_ACTIONS.EDIT_CONFIRM:
+        case EDIT_ACTIONS.REMOVE_CONFIRM:
+        case EDIT_ACTIONS.RESET:
+            newState = __assign({}, EDIT_INITIAL_STATE);
+            break;
+        default:
+            newState = __assign({}, EDIT_INITIAL_STATE);
+    }
+    return newState;
+};

package/dist/esm/reducers/index.d.ts

@@ -0,0 +1 @@
+export * from './editReducer';

package/dist/esm/reducers/index.js

@@ -0,0 +1 @@
+export * from './editReducer.js';

package/dist/esm/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './itemsService';
+export * from './slotsService';
+export * from './occurrenceService';
+export * from './rangeService';

package/dist/esm/services/index.js

@@ -0,0 +1,4 @@
+export * from './itemsService.js';
+export * from './slotsService.js';
+export * from './occurrenceService.js';
+export * from './rangeService.js';

package/dist/esm/services/itemsService.d.ts

@@ -0,0 +1,14 @@
+import { Occurrence, Group, Range, Item, Slot } from '../models';
+/** @hidden */
+export declare const toItems: (occurrences: Occurrence[], { timezone }: {
+    timezone: any;
+}, { groups, ranges }: {
+    groups: Group[];
+    ranges: Range[];
+}) => Item[];
+/** @hidden */
+export declare const inGroup: (occurrence: Occurrence, group: Group) => boolean;
+/** @hidden */
+export declare const inSlot: (occurrence: Occurrence, slot: Slot) => boolean;
+/** @hidden */
+export declare const inRange: (occurrence: Occurrence, range: Range) => boolean;

package/dist/esm/services/itemsService.js

@@ -0,0 +1,76 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { intersects } from '../utils.js';
+import { orderBy } from '@progress/kendo-data-query';
+import { ZonedDate } from '@progress/kendo-date-math';
+/** @hidden */
+export var toItems = function (occurrences, _a, _b) {
+    var timezone = _a.timezone;
+    var groups = _b.groups, ranges = _b.ranges;
+    var result = [];
+    var sorted = orderBy(occurrences, [
+        { field: 'start', dir: 'asc' },
+        { field: 'end', dir: 'desc' },
+        { field: 'isAllDay', dir: 'desc' }
+    ]);
+    sorted.forEach(function (occurrence) {
+        groups.forEach(function (g) {
+            var group = groups.length === 1
+                ? personalizedGroup(occurrence, g)
+                : g;
+            if (inGroup(occurrence, group)) {
+                ranges.forEach(function (range) {
+                    if (inRange(occurrence, range)) {
+                        var itemRef = {};
+                        var refTo = {};
+                        var head = range.end < occurrence.end;
+                        var tail = occurrence.start < range.start;
+                        var zonedStart = ZonedDate.fromLocalDate(occurrence.start, timezone);
+                        var zonedEnd = ZonedDate.fromLocalDate(occurrence.end, timezone);
+                        var item = __assign(__assign({}, occurrence), { refTo: refTo, itemRef: itemRef, head: head, tail: tail, order: null, zonedStart: zonedStart, zonedEnd: zonedEnd, group: group, range: range, slots: [], isRecurring: Boolean(occurrence.recurrenceRule), isException: Boolean(!occurrence.recurrenceRule
+                                && occurrence.recurrenceId !== null && occurrence.recurrenceId !== undefined), isAllDay: Boolean(occurrence.isAllDay) });
+                        result.push(item);
+                    }
+                });
+            }
+        });
+    });
+    return result;
+};
+var personalizedGroup = function (occurrence, group) {
+    return {
+        index: 0,
+        resources: group.resources.filter(function (resource) { return inResource(occurrence, resource); })
+    };
+};
+var inResource = function (occurrence, resource) {
+    return resource.multiple
+        ? (occurrence.dataItem[resource.field] || []).some(function (val) { return resource[resource.valueField] === val; })
+        : occurrence.dataItem[resource.field] === resource[resource.valueField];
+};
+/** @hidden */
+export var inGroup = function (occurrence, group) {
+    return !group.resources.some(function (res) { return res.multiple
+        ? !occurrence.dataItem[res.field].some(function (val) { return res[res.valueField] === val; })
+        : occurrence.dataItem[res.field] !== res[res.valueField]; });
+};
+/** @hidden */
+export var inSlot = function (occurrence, slot) {
+    return intersects(slot.start, slot.end, occurrence.start, occurrence.end);
+};
+/** @hidden */
+export var inRange = function (occurrence, range) {
+    return intersects(range.start, range.end, occurrence.start, occurrence.end)
+        && (range.isAllDay === undefined
+            || occurrence.isAllDay === undefined
+            || (occurrence.isAllDay === range.isAllDay));
+};

package/dist/esm/services/occurrenceService.d.ts

@@ -0,0 +1,7 @@
+import { DataItem, Occurrence } from '../models';
+/** @hidden */
+export declare const toOccurrences: (data: DataItem[], { dateRange, fields, timezone }: {
+    dateRange: any;
+    fields: any;
+    timezone: any;
+}) => Occurrence[];

package/dist/esm/services/occurrenceService.js

@@ -0,0 +1,92 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { getter, clone } from '@progress/kendo-vue-common';
+import { parseRule, expand } from '@progress/kendo-recurrence';
+import { ZonedDate } from '@progress/kendo-date-math';
+import { setField, isMaster } from '../utils.js';
+/** @hidden */
+export var toOccurrences = function (data, _a) {
+    var dateRange = _a.dateRange, fields = _a.fields, timezone = _a.timezone;
+    var result = data
+        .map(readItem(fields))
+        .reduce(occurrenceReducer(dateRange, timezone, fields), [])
+        .filter(function (occurrence) { return !isMaster(occurrence.dataItem, fields); });
+    return result;
+};
+var readItem = function (fields) { return function (dataItem) {
+    var result = {
+        uid: getter(fields.id || 'id')(dataItem),
+        start: getter(fields.start || 'start')(dataItem),
+        startTimezone: getter(fields.startTimezone || 'startTimezone')(dataItem),
+        originalStart: getter(fields.originalStart || 'originalStart')(dataItem),
+        end: getter(fields.end || 'end')(dataItem),
+        endTimezone: getter(fields.endTimezone || 'endTimezone')(dataItem),
+        isAllDay: getter(fields.isAllDay || 'isAllDay')(dataItem),
+        title: getter(fields.title || 'title')(dataItem),
+        description: getter(fields.description || 'description')(dataItem),
+        occurrenceId: getter('occurrenceId')(dataItem),
+        recurrenceRule: getter(fields.recurrenceRule || 'recurrenceRule')(dataItem),
+        recurrenceExceptions: getter(fields.recurrenceExceptions || 'recurrenceExceptions')(dataItem),
+        recurrenceId: getter(fields.recurrenceId || 'recurrenceId')(dataItem),
+        dataItem: clone(dataItem)
+    };
+    return result;
+}; };
+var occurrenceReducer = function (dateRange, timezone, fields) { return function (acc, current) {
+    return __spreadArray(__spreadArray([], acc, true), ((Boolean(current.recurrenceRule)
+        && Boolean(current.recurrenceId === null || current.recurrenceId === undefined)
+        && isMaster(current.dataItem, fields))
+        ? __spreadArray([], occurrences(current, { dateRange: dateRange, timezone: timezone, fields: fields }), true) : [current]), true);
+}; };
+var occurrences = function (item, _a) {
+    var dateRange = _a.dateRange, timezone = _a.timezone, fields = _a.fields;
+    var rrule = item.recurrenceRule;
+    var rule = parseRule({ recurrenceRule: rrule });
+    // changed as for display purposes timezone of the scheduler is the correct one
+    if (!rule.start) {
+        rule.start = ZonedDate.fromLocalDate(item.start, timezone);
+    }
+    if (!rule.end) {
+        rule.end = ZonedDate.fromLocalDate(item.end, timezone);
+    }
+    var exceptionRule = item.recurrenceExceptions;
+    if (exceptionRule) {
+        rule.exceptionDates = exceptionRule
+            .map(function (exDate) {
+            return ZonedDate.fromLocalDate(exDate, timezone);
+        });
+    }
+    var utcRangeStart = dateRange.zonedStart;
+    var utcRangeEnd = dateRange.zonedEnd;
+    var series = expand(rule, {
+        rangeStart: ZonedDate.fromUTCDate(utcRangeStart, timezone),
+        rangeEnd: ZonedDate.fromUTCDate(utcRangeEnd, timezone)
+    });
+    if (!series.events.length) {
+        return [];
+    }
+    var expanded = series.events.map(function (occurrence, idx) {
+        var occurrenceItem = clone(item);
+        var occurrenceDataItem = clone(item.dataItem);
+        occurrenceItem.recurrenceId = occurrenceItem.uid;
+        setField(occurrenceDataItem, fields.recurrenceId, item.uid);
+        occurrenceItem.originalStart = occurrence.start.toLocalDate();
+        setField(occurrenceDataItem, fields.originalStart, occurrence.start.toLocalDate());
+        occurrenceItem.start = occurrence.start.toLocalDate();
+        setField(occurrenceDataItem, fields.start, occurrence.start.toLocalDate());
+        occurrenceItem.end = occurrence.end.toLocalDate();
+        setField(occurrenceDataItem, fields.end, occurrence.end.toLocalDate());
+        occurrenceItem.occurrenceId = String(idx);
+        setField(occurrenceDataItem, 'occurrenceId', String(idx));
+        occurrenceItem.dataItem = occurrenceDataItem;
+        return occurrenceItem;
+    });
+    return expanded;
+};

package/dist/esm/services/rangeService.d.ts

@@ -0,0 +1,6 @@
+import { Range, DateRange } from '../models';
+/** @hidden */
+export declare const toRanges: (dateRange: DateRange, { step, timezone }: {
+    step: any;
+    timezone: any;
+}) => Range[];

package/dist/esm/services/rangeService.js

@@ -0,0 +1,23 @@
+import { ZonedDate } from '@progress/kendo-date-math';
+/** @hidden */
+export var toRanges = function (dateRange, _a) {
+    var step = _a.step, timezone = _a.timezone;
+    var ranges = [];
+    var zonedRangeStart = ZonedDate.fromLocalDate(dateRange.start, timezone);
+    var zonedRangeEnd = ZonedDate.fromLocalDate(dateRange.end, timezone);
+    for (var current = zonedRangeStart.clone(), index = 0; current.getTime() < zonedRangeEnd.getTime(); index++, current = current.addTime(step)) {
+        var zonedStart = current.clone();
+        var zonedEnd = zonedStart.clone().addTime(step);
+        var start = new Date(zonedStart.getTime());
+        var end = new Date(zonedEnd.getTime());
+        var range = {
+            index: index,
+            end: end,
+            start: start,
+            zonedStart: zonedStart,
+            zonedEnd: zonedEnd
+        };
+        ranges.push(range);
+    }
+    return ranges;
+};

package/dist/esm/services/slotsService.d.ts

@@ -0,0 +1,8 @@
+import { Group, Range, Slot, DateRange } from '../models';
+/** @hidden */
+export declare const toSlots: (_dateRange: DateRange, { step }: {
+    step: any;
+}, { groups, ranges }: {
+    groups: Group[];
+    ranges: Range[];
+}) => Slot[];

package/dist/esm/services/slotsService.js

@@ -0,0 +1,42 @@
+import { MS_PER_DAY } from '@progress/kendo-date-math';
+import { MS_PER_MINUTE } from '../constants.js';
+/** @hidden */
+export var toSlots = function (_dateRange, _a, _b) {
+    var step = _a.step;
+    var groups = _b.groups, ranges = _b.ranges;
+    var slots = [];
+    groups.forEach(function (group) {
+        ranges.forEach(function (range) {
+            var viewStart = range.zonedStart;
+            var viewEnd = range.zonedEnd;
+            var offset = (viewEnd.timezoneOffset - viewStart.timezoneOffset);
+            for (var current = viewStart.clone(), index = 0, deficiency = offset < 0 ? offset * MS_PER_MINUTE * -1 : 0; current.getTime() < viewEnd.getTime(); index++, current = current.addTime(step)) {
+                var refTo = {};
+                var zonedStart = current.clone();
+                var zonedEnd = current.addTime(step);
+                var difference = (zonedEnd.timezoneOffset - zonedStart.timezoneOffset) * MS_PER_MINUTE;
+                var canFill = step < Math.abs(difference);
+                if (deficiency && canFill) {
+                    deficiency -= step;
+                    current = current.addTime(-step);
+                }
+                var start = new Date(zonedStart.getTime());
+                var end = new Date(zonedEnd.getTime());
+                var slot = {
+                    refTo: refTo,
+                    index: index,
+                    end: end,
+                    start: start,
+                    zonedStart: zonedStart,
+                    zonedEnd: zonedEnd,
+                    range: range,
+                    group: group,
+                    items: [],
+                    isAllDay: MS_PER_DAY <= step
+                };
+                slots.push(slot);
+            }
+        });
+    });
+    return slots;
+};

package/dist/esm/slots/SchedulerEditSlot.d.ts

@@ -0,0 +1,80 @@
+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 { DataItem } from '../models';
+import { DataAction } from '../Scheduler';
+import { SchedulerSlotHandle } from './SchedulerSlot';
+import { SchedulerViewSlotProps } from './SchedulerViewSlot';
+/**
+ * Represents the props of the Kendo UI for Vue [SchedulerEditSlot]({% slug api_scheduler_schedulereditslot %}) component.
+ */
+export interface SchedulerEditSlotProps extends SchedulerViewSlotProps {
+    /**
+     * Overrides the default component responsible for view-specific functionality.
+     *
+     * The default Component is: [SchedulerViewSlot]({% slug api_scheduler_schedulerviewslotprops %}).
+     */
+    viewSlot?: any;
+    /**
+     * Overrides the default component responsible for visualizing the `formItem`.
+     *
+     * The default Component is: [SchedulerForm]({% slug api_scheduler_schedulerform %}).
+     */
+    form?: any;
+    /**
+     * Setting this property will force the `formItem` to be in controlled state, allowing further customization.
+     */
+    formItem?: DataItem | null;
+    /**
+     * Called every time the `formItem` changes.
+     */
+    onFormItemChange?: (event: any) => void;
+    /**
+     * Called when new item has been created in the slot.
+     */
+    onDataaction?: (action: DataAction, event: any) => void;
+}
+/** @hidden */
+export interface SchedulerEditSlotHandle {
+    props: SchedulerEditSlotProps;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerEditSlotState {
+    slot: SchedulerSlotHandle | null;
+    editableSlot: SchedulerEditSlotHandle | null;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerEditSlotComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerEditSlotMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerEditSlotData {
+}
+/**
+ * @hidden
+ */
+export interface SchedulerEditSlotAll extends Vue2type, SchedulerEditSlotMethods, SchedulerEditSlotData, SchedulerEditSlotComputed, SchedulerEditSlotState {
+}
+/**
+ * @hidden
+ */
+declare let SchedulerEditSlotVue2: ComponentOptions<SchedulerEditSlotAll, DefaultData<SchedulerEditSlotData>, DefaultMethods<SchedulerEditSlotAll>, SchedulerEditSlotComputed, RecordPropsDefinition<SchedulerEditSlotProps>>;
+/**
+ * @hidden
+ */
+declare const SchedulerEditSlot: DefineComponent<SchedulerEditSlotProps, any, SchedulerEditSlotData, SchedulerEditSlotComputed, SchedulerEditSlotMethods, {}, {}, {}, string, SchedulerEditSlotProps, SchedulerEditSlotProps, {}>;
+export { SchedulerEditSlot, SchedulerEditSlotVue2 };