@progress/kendo-vue-scheduler 3.0.8 → 3.0.9-dev.202203010857

package/dist/es/recurrence/RecurrenceFrequencyEditor.d.ts

@@ -0,0 +1,42 @@
+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 { ButtonGroupProps } from '@progress/kendo-vue-buttons';
+/** @hidden */
+export interface RecurrenceFrequencyEditorProps extends ButtonGroupProps {
+    value: string;
+    dataItems: any[];
+    onChange?: (value: string) => void;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceFrequencyEditorState {
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceFrequencyEditorComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceFrequencyEditorMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceFrequencyEditorData {
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceFrequencyEditorAll extends Vue2type, RecurrenceFrequencyEditorMethods, RecurrenceFrequencyEditorData, RecurrenceFrequencyEditorComputed, RecurrenceFrequencyEditorState {
+}
+declare let RecurrenceFrequencyEditorVue2: ComponentOptions<RecurrenceFrequencyEditorAll, DefaultData<RecurrenceFrequencyEditorData>, DefaultMethods<RecurrenceFrequencyEditorAll>, RecurrenceFrequencyEditorComputed, RecordPropsDefinition<RecurrenceFrequencyEditorProps>>;
+declare const RecurrenceFrequencyEditor: DefineComponent<RecurrenceFrequencyEditorProps, any, RecurrenceFrequencyEditorData, RecurrenceFrequencyEditorComputed, RecurrenceFrequencyEditorMethods, {}, {}, {}, string, RecurrenceFrequencyEditorProps, RecurrenceFrequencyEditorProps, {}>;
+export { RecurrenceFrequencyEditor, RecurrenceFrequencyEditorVue2 };

package/dist/es/recurrence/RecurrenceFrequencyEditor.js

@@ -0,0 +1,63 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var inject = allVue.inject;
+import { ButtonGroup, Button } from '@progress/kendo-vue-buttons'; // tslint:enable:max-line-length
+
+var RecurrenceFrequencyEditorVue2 = {
+  name: 'KendoRecurrenceFrequencyEditor',
+  props: {
+    value: String,
+    dataItems: Array
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var _a = this.$props,
+        value = _a.value,
+        dataItems = _a.dataItems;
+    return h(ButtonGroup, {
+      width: '100%',
+      attrs: this.v3 ? undefined : {
+        width: '100%'
+      }
+    }, [dataItems.map(function (item) {
+      return (// @ts-ignore  function children
+        h(Button, {
+          type: "button",
+          attrs: this.v3 ? undefined : {
+            type: "button",
+            selected: item.value === value,
+            "data-value": item.value,
+            togglable: true
+          },
+          key: item.value,
+          selected: item.value === value,
+          onClick: this.handleClick,
+          on: this.v3 ? undefined : {
+            "click": this.handleClick
+          },
+          "data-value": item.value,
+          togglable: true
+        }, this.v3 ? function () {
+          return [item.text];
+        } : [item.text])
+      );
+    }, this)]);
+  },
+  methods: {
+    handleClick: function handleClick(event) {
+      this.$emitd('change', event.currentTarget.dataset.value);
+    }
+  }
+};
+var RecurrenceFrequencyEditor = RecurrenceFrequencyEditorVue2;
+export { RecurrenceFrequencyEditor, RecurrenceFrequencyEditorVue2 };

package/dist/es/recurrence/RecurrenceRepeatOnWeekEditor.d.ts

@@ -0,0 +1,45 @@
+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 { ButtonGroupProps } from '@progress/kendo-vue-buttons';
+/** @hidden */
+export interface RecurrenceRepeatOnWeekEditorProps extends ButtonGroupProps {
+    dataItems?: {
+        text: string;
+        value: number | string;
+    }[];
+    value?: (number | string)[];
+    onChange?: (value: number[]) => void;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceRepeatOnWeekEditorState {
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceRepeatOnWeekEditorComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceRepeatOnWeekEditorMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceRepeatOnWeekEditorData {
+}
+/**
+ * @hidden
+ */
+export interface RecurrenceRepeatOnWeekEditorAll extends Vue2type, RecurrenceRepeatOnWeekEditorMethods, RecurrenceRepeatOnWeekEditorData, RecurrenceRepeatOnWeekEditorComputed, RecurrenceRepeatOnWeekEditorState {
+}
+declare let RecurrenceRepeatOnWeekEditorVue2: ComponentOptions<RecurrenceRepeatOnWeekEditorAll, DefaultData<RecurrenceRepeatOnWeekEditorData>, DefaultMethods<RecurrenceRepeatOnWeekEditorAll>, RecurrenceRepeatOnWeekEditorComputed, RecordPropsDefinition<RecurrenceRepeatOnWeekEditorProps>>;
+declare const RecurrenceRepeatOnWeekEditor: DefineComponent<RecurrenceRepeatOnWeekEditorProps, any, RecurrenceRepeatOnWeekEditorData, RecurrenceRepeatOnWeekEditorComputed, RecurrenceRepeatOnWeekEditorMethods, {}, {}, {}, string, RecurrenceRepeatOnWeekEditorProps, RecurrenceRepeatOnWeekEditorProps, {}>;
+export { RecurrenceRepeatOnWeekEditor, RecurrenceRepeatOnWeekEditorVue2 };

package/dist/es/recurrence/RecurrenceRepeatOnWeekEditor.js

@@ -0,0 +1,127 @@
+var __spreadArrays = this && this.__spreadArrays || function () {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) {
+    s += arguments[i].length;
+  }
+
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) {
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {
+      r[k] = a[j];
+    }
+  }
+
+  return r;
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var inject = allVue.inject;
+import { ButtonGroup, Button } from '@progress/kendo-vue-buttons';
+import { capitalize } from './common'; // tslint:enable:max-line-length
+
+var RecurrenceRepeatOnWeekEditorVue2 = {
+  name: 'KendoRecurrenceRepeatOnWeekEditor',
+  props: {
+    dataItems: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    value: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    var _a = this.$props,
+        value = _a.value,
+        dataItems = _a.dataItems;
+    return (// @ts-ignore  function children
+      h(ButtonGroup, {
+        width: 'auto',
+        attrs: this.v3 ? undefined : {
+          width: 'auto'
+        }
+      }, this.v3 ? function () {
+        return [dataItems.map(function (item) {
+          return (// @ts-ignore  function children
+            h(Button, {
+              type: "button",
+              attrs: this.v3 ? undefined : {
+                type: "button",
+                "data-key": item.value,
+                selected: value.some(function (v) {
+                  return v === item.value;
+                }),
+                togglable: true
+              },
+              key: item.value,
+              "data-key": item.value,
+              selected: value.some(function (v) {
+                return v === item.value;
+              }),
+              togglable: true,
+              onClick: this.handleClick,
+              on: this.v3 ? undefined : {
+                "click": this.handleClick
+              }
+            }, this.v3 ? function () {
+              return [capitalize(item.text)];
+            } : [capitalize(item.text)])
+          );
+        }, _this)];
+      } : [dataItems.map(function (item) {
+        return h(Button, {
+          type: "button",
+          attrs: this.v3 ? undefined : {
+            type: "button",
+            "data-key": item.value,
+            selected: value.some(function (v) {
+              return v === item.value;
+            }),
+            togglable: true
+          },
+          key: item.value,
+          "data-key": item.value,
+          selected: value.some(function (v) {
+            return v === item.value;
+          }),
+          togglable: true,
+          onClick: this.handleClick,
+          on: this.v3 ? undefined : {
+            "click": this.handleClick
+          }
+        }, this.v3 ? function () {
+          return [capitalize(item.text)];
+        } : [capitalize(item.text)]);
+      }, _this)])
+    );
+  },
+  methods: {
+    handleClick: function handleClick(event) {
+      var newValue = Number(event.currentTarget.dataset.key);
+      this.$emit('change', this.value.some(function (i) {
+        return i === newValue;
+      }) ? this.value.filter(function (i) {
+        return i !== newValue;
+      }) : __spreadArrays(this.value, [newValue]));
+    }
+  }
+};
+var RecurrenceRepeatOnWeekEditor = RecurrenceRepeatOnWeekEditorVue2;
+export { RecurrenceRepeatOnWeekEditor, RecurrenceRepeatOnWeekEditorVue2 };

package/dist/es/recurrence/common.d.ts

@@ -0,0 +1,57 @@
+import { OffsetPosition } from './types/OffsetPosition';
+import { RecurrenceRule } from '@progress/kendo-recurrence';
+import { Frequency } from './types/Frequency';
+import { WeekDayRule } from './types/WeekDayRule';
+import { FrequencyEntity } from './types/FrequencyEntity';
+import { MonthEntity } from './types/MonthEntity';
+import { WeekDayEntity } from './types/WeekDayEntity';
+import { OffsetPositionEntity } from './types/OffsetPositionEntity';
+import { EndRule } from './types/EndRule';
+import { RepeatOnRule } from './types/RepeatOnRule';
+import { IntlService } from '@progress/kendo-vue-intl';
+/** @hidden */
+export declare const capitalize: (value: string) => string;
+/** @hidden */
+export declare const OFFSET_POSITIONS: OffsetPosition[];
+/** @hidden */
+export declare const FREQUENCIES: Frequency[];
+/** @hidden */
+export declare const dayRule: WeekDayRule[];
+/** @hidden */
+export declare const weekdayRule: WeekDayRule[];
+/** @hidden */
+export declare const weekendRule: WeekDayRule[];
+/** @hidden */
+export declare const weekDayRuleFromString: (weekDay: string) => WeekDayRule[] | undefined;
+/** @hidden */
+export declare const getRule: (recurrenceRule: string) => RecurrenceRule;
+/** @hidden */
+export declare const getFrequencies: (localizeMessage: any) => FrequencyEntity[];
+/** @hidden */
+export declare const getFrequency: (rrule: RecurrenceRule) => Frequency;
+/** @hidden */
+export declare const getUntil: (rrule: RecurrenceRule) => Date | null;
+/** @hidden */
+export declare const getMonths: (intl: IntlService) => MonthEntity[];
+/** @hidden */
+export declare const getWeekDays: (intl: IntlService) => WeekDayEntity[];
+/** @hidden */
+export declare const getWeekDay: (weekDays: WeekDayEntity[], rrule: RecurrenceRule, start: Date) => WeekDayEntity;
+/** @hidden */
+export declare const getExtendedWeekDays: (intl: IntlService, localizeMessage: any) => WeekDayEntity[];
+/** @hidden */
+export declare const getOffset: (offsets: OffsetPositionEntity[], rrule: RecurrenceRule) => OffsetPositionEntity;
+/** @hidden */
+export declare const getOffsets: (localizeMessage: any) => OffsetPositionEntity[];
+/** @hidden */
+export declare const getEndRule: (rrule: RecurrenceRule) => EndRule;
+/** @hidden */
+export declare const getRepeatOnRule: (rrule: RecurrenceRule) => RepeatOnRule | undefined;
+/** @hidden */
+export declare const getMonth: (months: MonthEntity[], rrule: RecurrenceRule) => MonthEntity;
+/** @hidden */
+export declare const getMonthDay: (rrule: RecurrenceRule, start: Date) => number;
+/** @hidden */
+export declare const getUntilEnd: (start: Date, until: Date | null) => Date;
+/** @hidden */
+export declare const getUntilMin: (start: Date, until: Date | null) => Date;

package/dist/es/recurrence/common.js

@@ -0,0 +1,211 @@
+import { isPresent, isNullOrEmptyString } from '../utils';
+import { parseRule } from '@progress/kendo-recurrence';
+import { toLocalDate } from '@progress/kendo-date-math';
+/** @hidden */
+export var capitalize = function (value) { return value.charAt(0).toUpperCase() + value.slice(1); };
+/** @hidden */
+export var OFFSET_POSITIONS = ['first', 'second', 'third', 'fourth', 'last'];
+/** @hidden */
+export var FREQUENCIES = ['never', 'daily', 'weekly', 'monthly', 'yearly'];
+/** @hidden */
+export var dayRule = [
+    { day: 0, offset: 0 },
+    { day: 1, offset: 0 },
+    { day: 2, offset: 0 },
+    { day: 3, offset: 0 },
+    { day: 4, offset: 0 },
+    { day: 5, offset: 0 },
+    { day: 6, offset: 0 }
+];
+/** @hidden */
+export var weekdayRule = [
+    { day: 1, offset: 0 },
+    { day: 2, offset: 0 },
+    { day: 3, offset: 0 },
+    { day: 4, offset: 0 },
+    { day: 5, offset: 0 }
+];
+/** @hidden */
+export var weekendRule = [
+    { day: 0, offset: 0 },
+    { day: 6, offset: 0 }
+];
+/** @hidden */
+export var weekDayRuleFromString = function (weekDay) {
+    switch (weekDay) {
+        case 'day':
+            return dayRule;
+        case 'weekday':
+            return weekdayRule;
+        case 'weekend':
+            return weekendRule;
+        default:
+            break;
+    }
+    return;
+};
+/** @hidden */
+export var getRule = function (recurrenceRule) {
+    return parseRule({ recurrenceRule: recurrenceRule }) || {};
+};
+/** @hidden */
+export var getFrequencies = function (localizeMessage) {
+    return FREQUENCIES.map(function (freq) { return ({
+        value: freq,
+        text: localizeMessage('Frequencies' + capitalize(freq))
+    }); });
+};
+/** @hidden */
+export var getFrequency = function (rrule) {
+    if (isPresent(rrule) && !isNullOrEmptyString(rrule.freq)) {
+        return rrule.freq;
+    }
+    return 'never';
+};
+/** @hidden */
+export var getUntil = function (rrule) {
+    if (isPresent(rrule.until)) {
+        return toLocalDate(rrule.until);
+    }
+    return null;
+};
+/** @hidden */
+export var getMonths = function (intl) {
+    return intl.dateFormatNames({
+        type: 'months',
+        nameType: 'wide'
+    }).map(function (month, idx) { return ({
+        text: month,
+        value: idx + 1
+    }); });
+};
+/** @hidden */
+export var getWeekDays = function (intl) {
+    var firstDay = intl.firstDay();
+    var abbrNames = intl.dateFormatNames({
+        type: 'days',
+        nameType: 'abbreviated'
+    }).map(function (day, idx) { return ({
+        text: day,
+        value: idx
+    }); });
+    /* Sorting according to first week day */
+    return (abbrNames.slice(firstDay)).concat(abbrNames.slice(0, firstDay));
+};
+/** @hidden */
+export var getWeekDay = function (weekDays, rrule, start) {
+    return weekDays.find(function (item) {
+        var value;
+        if (isPresent(rrule.byWeekDay)) {
+            var weekDaysCount = rrule.byWeekDay.length;
+            switch (weekDaysCount) {
+                case 7:
+                    value = 'day';
+                    break;
+                case 5:
+                    value = 'weekday';
+                    break;
+                case 2:
+                    value = 'weekend';
+                    break;
+                case 1:
+                    value = rrule.byWeekDay[0].day;
+                    break;
+                default:
+                    value = start.getDay();
+                    break;
+            }
+        }
+        return value === item.value;
+    }) || weekDays[0];
+};
+/** @hidden */
+export var getExtendedWeekDays = function (intl, localizeMessage) {
+    var firstDay = intl.firstDay();
+    var wideNames = intl.dateFormatNames({
+        type: 'days',
+        nameType: 'wide'
+    }).map(function (day, idx) { return ({
+        text: day,
+        value: idx
+    }); });
+    var sortedWideNames = (wideNames.slice(firstDay)).concat(wideNames.slice(0, firstDay));
+    var specialRules = [
+        { text: localizeMessage('WeekdaysDay'), value: 'day' },
+        { text: localizeMessage('WeekdaysWeekday'), value: 'weekday' },
+        { text: localizeMessage('WeekdaysWeekendday'), value: 'weekend' }
+    ];
+    return specialRules.concat(sortedWideNames);
+};
+/** @hidden */
+export var getOffset = function (offsets, rrule) {
+    return offsets.find(function (offset) { return offset.value === (rrule.bySetPosition
+        ? rrule.bySetPosition[0]
+        : rrule.byWeekDay && rrule.byWeekDay[0]
+            ? rrule.byWeekDay[0].offset
+            : 1); }) || offsets[0];
+};
+/** @hidden */
+export var getOffsets = function (localizeMessage) {
+    var values = [1, 2, 3, 4, -1];
+    return OFFSET_POSITIONS.map(function (offset, idx) { return ({
+        text: localizeMessage('OffsetPositions' + capitalize(offset)),
+        value: values[idx]
+    }); });
+};
+/** @hidden */
+export var getEndRule = function (rrule) {
+    if (isPresent(rrule.count)) {
+        return 'count';
+    }
+    else if (isPresent(rrule.until)) {
+        return 'until';
+    }
+    else {
+        return 'never';
+    }
+};
+/** @hidden */
+export var getRepeatOnRule = function (rrule) {
+    if (isPresent(rrule.byWeekDay)) {
+        return 'weekday';
+    }
+    else if (isPresent(rrule.byMonthDay)) {
+        return 'monthday';
+    }
+};
+/** @hidden */
+export var getMonth = function (months, rrule) {
+    return months.find(function (month) { return (rrule.byMonth ? rrule.byMonth[0] : null) === month.value; }) || months[0];
+};
+/** @hidden */
+export var getMonthDay = function (rrule, start) {
+    if (isPresent(rrule.byMonthDay) && rrule.byMonthDay.length > 0) {
+        return rrule.byMonthDay[0];
+    }
+    else {
+        return start.getDate();
+    }
+};
+/** @hidden */
+export var getUntilEnd = function (start, until) {
+    var currentStart = start;
+    var currentUntil = until;
+    if (isPresent(currentUntil)) {
+        return currentUntil;
+    }
+    else {
+        return new Date(currentStart.getFullYear(), currentStart.getMonth(), currentStart.getDate(), 23, 59, 59);
+    }
+};
+/** @hidden */
+export var getUntilMin = function (start, until) {
+    var currentStart = start;
+    var currentUntil = until;
+    if (isPresent(currentUntil) && currentUntil < currentStart) {
+        return currentUntil;
+    }
+    else {
+        return currentStart;
+    }
+};

package/dist/es/recurrence/types/EndRule.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare type EndRule = 'count' | 'never' | 'until';

package/dist/es/recurrence/types/Frequency.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare type Frequency = 'never' | 'daily' | 'weekly' | 'monthly' | 'yearly';

package/dist/es/recurrence/types/FrequencyEntity.d.ts

@@ -0,0 +1,8 @@
+import { Frequency } from './Frequency';
+/**
+ * @hidden
+ */
+export interface FrequencyEntity {
+    text: string;
+    value: Frequency;
+}

package/dist/es/recurrence/types/MonthEntity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @hidden
+ */
+export interface MonthEntity {
+    text: string;
+    value: number;
+}

package/dist/es/recurrence/types/OffsetPosition.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare type OffsetPosition = 'first' | 'second' | 'third' | 'fourth' | 'last';

package/dist/es/recurrence/types/OffsetPositionEntity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @hidden
+ */
+export interface OffsetPositionEntity {
+    text: string;
+    value: number;
+}

package/dist/es/recurrence/types/RepeatOnRule.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare type RepeatOnRule = 'monthday' | 'weekday';

package/dist/es/recurrence/types/WeekDayEntity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @hidden
+ */
+export interface WeekDayEntity {
+    text: string;
+    value: number | string;
+}

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

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

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

@@ -0,0 +1 @@
+

package/dist/es/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;