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

package/dist/esm/Scheduler.js

@@ -0,0 +1,656 @@
+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);
+};
+
+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));
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { getModelFields, getField, findMaster, setField, toSchedulerGroups, getToday } from './utils.js';
+import { clone, getListeners, getTemplate, templateRendering } from '@progress/kendo-vue-common';
+import { provideIntlService, provideLocalizationService } from '@progress/kendo-vue-intl';
+import { SchedulerHeader } from './components/header/SchedulerHeader.js';
+import { SchedulerNavigation } from './components/header/navigation/SchedulerNavigation.js';
+import { SchedulerViewSelector } from './components/header/view-selector/SchedulerViewSelector.js';
+import { addDays, addMonths } from '@progress/kendo-date-math';
+import { SchedulerFooter } from './components/footer/SchedulerFooter.js';
+import { ToolbarSpacer } from '@progress/kendo-vue-buttons';
+import { NavigationDatePicker } from './components/header/navigation/NavigationDatePicker.js';
+import { BusinessHours } from './components/footer/bussiness-hours/BusinessHours.js';
+import { DayView } from './views/day/DayView'; // import { SchedulerFormProps } from './editors/SchedulerFormEditor.js';
+
+import { validatePackage } from '@progress/kendo-vue-common';
+import { packageMetadata } from './package-metadata.js';
+import { AgendaView, MonthView, WeekView, WorkWeekView } from './main.js';
+import { TimelineView } from './views/time/TimelineView.js';
+import { useEditable } from './hooks.js';
+var DEFAULT_DATE_FORMAT = '{0:D}';
+var DEFAULT_SHORT_DATE_FORMAT = '{0:d}';
+/**
+ * Specifies the available [DataAction]({% slug api_scheduler_data_action %}) types.
+ */
+
+export var DATA_ACTION;
+
+(function (DATA_ACTION) {
+  DATA_ACTION[DATA_ACTION["create"] = 0] = "create";
+  DATA_ACTION[DATA_ACTION["update"] = 1] = "update";
+  DATA_ACTION[DATA_ACTION["remove"] = 2] = "remove";
+})(DATA_ACTION || (DATA_ACTION = {}));
+/** @hidden */
+
+
+var SchedulerVue2 = {
+  name: 'KendoScheduler',
+  props: {
+    dataItems: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    views: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    view: String,
+    defaultView: String,
+    date: Date,
+    rtl: Boolean,
+    height: {
+      type: [Number, String],
+      default: 600
+    },
+    timezone: String,
+    group: Object,
+    resources: [Object, Array],
+    modelFields: Object,
+    tabIndex: {
+      type: Number,
+      default: -1
+    },
+    editable: {
+      type: [Boolean, Object],
+      default: false
+    },
+    defaultDate: {
+      type: Date,
+      default: function _default() {
+        return new Date();
+      }
+    },
+    validator: {
+      type: Function,
+      default: function _default() {
+        return {};
+      }
+    },
+    modifyInitialFormValues: {
+      type: Function,
+      default: function _default(i) {
+        return i;
+      }
+    },
+    header: [String, Function, Object],
+    footer: [String, Function, Object],
+    slotRender: [String, Function, Object],
+    viewSlot: [String, Function, Object],
+    item: [String, Function, Object],
+    viewItem: [String, Function, Object],
+    task: [String, Function, Object],
+    form: [String, Function, Object],
+    resizeHint: [String, Function, Object],
+    dialogProps: Object,
+    formProps: Object,
+    dateHeaderCell: [String, Function, Object],
+    timeHeaderCell: [String, Function, Object]
+  },
+  computed: {
+    wrapperClassName: function wrapperClassName() {
+      return {
+        'k-rtl': this.$props.rtl !== undefined ? this.$props.rtl : this.dir === 'rtl',
+        'k-widget': true,
+        'k-scheduler': true,
+        'k-scheduler-flex': true,
+        'k-floatwrap': true
+      };
+    },
+    fields: function fields() {
+      return getModelFields(this.$props.modelFields).fields;
+    }
+  },
+  provide: function provide() {
+    return {
+      ks: this.ks,
+      setActiveViewName: this.handleActiveViewNameChange,
+      setActiveDate: this.handleDateChange,
+      itemDoubleClick: this.handleItemDoubleClick,
+      itemClick: this.handleItemClick,
+      slotDoubleClick: this.handleSlotDoubleClick,
+      slotClick: this.handleSlotClick,
+      taskDoubleClick: this.handleTaskDoubleClick,
+      taskClick: this.handleTaskClick,
+      ksValidator: this.validator,
+      ksModifyInitialFormValues: this.modifyInitialFormValues
+    };
+  },
+  data: function data() {
+    this.intl = provideIntlService(this);
+    this.localization = provideLocalizationService(this);
+    var currentDate = this.$props.date || this.$props.defaultDate;
+    var activeViewName = this.$props.view || this.$props.defaultView || this.views[0] && this.views[0].name || 'day';
+    var view = this.views.find(function (currentView) {
+      return currentView.name === activeViewName;
+    }) || this.views[0] || h(DayView);
+    var dateFormat = this.getViewPropValue(view, 'selectedDateFormat', activeViewName) || DEFAULT_DATE_FORMAT;
+    var shortDateFormat = this.getViewPropValue(view, 'selectedShortDateFormat', activeViewName) || DEFAULT_SHORT_DATE_FORMAT;
+    var dateRange = this.getViewComponentByName(activeViewName).props.dateRange.default()({
+      intl: this.intl,
+      date: currentDate,
+      timezone: this.$props.timezone,
+      numberOfDays: this.getViewPropValue(view, 'numberOfDays', activeViewName),
+      workWeekStart: this.getViewPropValue(view, 'workWeekStart', activeViewName) || this.intl.firstDay(),
+      workWeekEnd: this.getViewPropValue(view, 'workWeekEnd', activeViewName) || (this.intl.firstDay() + this.getViewPropValue(view, 'numberOfDays', activeViewName)) % 6
+    });
+    return {
+      ks: {
+        activeViewName: activeViewName,
+        currentDate: currentDate,
+        showWorkHours: view.showWorkHours !== undefined ? view.showWorkHours : true,
+        timezone: this.$props.timezone,
+        props: __assign({}, this.$props),
+        views: this.views,
+        view: view,
+        fields: getModelFields(this.$props.modelFields).fields,
+        groups: toSchedulerGroups(this.$props.group, this.$props.resources),
+        dateRange: dateRange,
+        orientation: this.$props.group && this.$props.group.orientation ? this.$props.group.orientation : 'horizontal',
+        dateFormat: dateFormat,
+        shortDateFormat: shortDateFormat,
+        scheduler: this,
+        dataItems: this.dataItems
+      }
+    };
+  },
+  watch: {
+    view: function view(newName) {
+      this.updatePassedState(newName);
+    },
+    timezone: function timezone(newName) {
+      this.ks.timezone = newName;
+      this.updatePassedState();
+    },
+    dataItems: function dataItems(newDataItems) {
+      this.ks.dataItems = newDataItems;
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this2 = this;
+
+    var _this = this;
+
+    var h = gh || createElement;
+    validatePackage(packageMetadata);
+    var timezone = this.$props.timezone; //  const dir = useDir(element);
+
+    var view = this.views.find(function (currentView) {
+      return currentView.name === _this.ks.activeViewName;
+    }) || this.views[0] || h(DayView);
+    var slotDuration = this.getViewPropValue(this.ks.view, 'slotDuration', this.ks.activeViewName);
+    var header = templateRendering.call(this, view.header || this.$props.header, getListeners.call(this));
+    var footer = templateRendering.call(this, view.footer || this.$props.footer, getListeners.call(this));
+    var slotRender = templateRendering.call(this, view.slot || this.$props.slotRender, {});
+    var viewSlot = templateRendering.call(this, view.viewSlot || this.$props.viewSlot, {});
+    var item = templateRendering.call(this, view.item || this.$props.item, {});
+    var viewItem = templateRendering.call(this, view.viewItem || this.$props.viewItem, {});
+    var task = templateRendering.call(this, view.task || this.$props.task, {});
+    var dateHeaderCell = templateRendering.call(this, view.dateHeaderCell || this.$props.dateHeaderCell, {});
+    var timeHeaderCell = templateRendering.call(this, view.timeHeaderCell || this.$props.timeHeaderCell, {});
+    var resizeHint = templateRendering.call(this, view.resizeHint || this.$props.resizeHint, {});
+    this.ks.form = templateRendering.call(this, view.form || this.$props.form, {});
+    this.ks.dialogProps = view.dialogProps || this.$props.dialogProps;
+    this.ks.formProps = view.formProps || this.$props.formProps;
+    var currentEditable = useEditable(view.editable !== undefined ? view.editable : this.$props.editable);
+    var ViewSelector = SchedulerViewSelector;
+    var viewComponent = this.getViewComponentByName(this.ks.activeViewName || view.name);
+
+    var viewProps = __assign(__assign(__assign({}, this.$props), this.ks.view), {
+      showWorkHours: this.ks.showWorkHours,
+      dataItems: undefined,
+      views: undefined,
+      defaultDate: undefined,
+      dateRange: this.ks.dateRange,
+      slotRender: slotRender,
+      viewSlot: viewSlot,
+      item: item,
+      viewItem: viewItem,
+      task: task,
+      dateHeaderCell: dateHeaderCell,
+      timeHeaderCell: timeHeaderCell,
+      resizeHint: resizeHint,
+      editable: currentEditable
+    });
+
+    var headerRender;
+    var headerRenderDefaultRendering = // @ts-ignore  function children
+    h(SchedulerHeader, this.v3 ? function () {
+      return [h(SchedulerNavigation, {
+        onPrevclick: _this2.handlePrevClick,
+        on: _this2.v3 ? undefined : {
+          "prevclick": _this2.handlePrevClick,
+          "nextclick": _this2.handleNextClick,
+          "todayclick": _this2.handleTodayClick
+        },
+        onNextclick: _this2.handleNextClick,
+        onTodayclick: _this2.handleTodayClick
+      }), h(NavigationDatePicker, {
+        value: _this2.ks.currentDate,
+        attrs: _this2.v3 ? undefined : {
+          value: _this2.ks.currentDate
+        },
+        onChange: _this2.handleDatePickerChange,
+        on: _this2.v3 ? undefined : {
+          "change": _this2.handleDatePickerChange
+        }
+      }), h(ToolbarSpacer), h(ViewSelector)];
+    } : [h(SchedulerNavigation, {
+      onPrevclick: _this2.handlePrevClick,
+      on: _this2.v3 ? undefined : {
+        "prevclick": _this2.handlePrevClick,
+        "nextclick": _this2.handleNextClick,
+        "todayclick": _this2.handleTodayClick
+      },
+      onNextclick: _this2.handleNextClick,
+      onTodayclick: _this2.handleTodayClick
+    }), h(NavigationDatePicker, {
+      value: _this2.ks.currentDate,
+      attrs: _this2.v3 ? undefined : {
+        value: _this2.ks.currentDate
+      },
+      onChange: _this2.handleDatePickerChange,
+      on: _this2.v3 ? undefined : {
+        "change": _this2.handleDatePickerChange
+      }
+    }), h(ToolbarSpacer), h(ViewSelector)]);
+    headerRender = getTemplate.call(this, {
+      h: h,
+      template: header,
+      defaultRendering: headerRenderDefaultRendering,
+      additionalProps: {
+        currentDate: this.ks.currentDate
+      },
+      additionalListeners: {
+        prevclick: this.handlePrevClick,
+        nextclick: this.handleNextClick,
+        todayclick: this.handleTodayClick,
+        datepickerchange: this.handleDatePickerChange
+      }
+    });
+    var footerRender;
+    var footerRenderDefaultRendering = // @ts-ignore  function children
+    h(SchedulerFooter, this.v3 ? function () {
+      return [// @ts-ignore  function children
+      h(BusinessHours, {
+        slotDuration: slotDuration,
+        attrs: _this2.v3 ? undefined : {
+          slotDuration: slotDuration
+        },
+        onClick: _this2.handleShowWorkHoursClick,
+        on: _this2.v3 ? undefined : {
+          "click": _this2.handleShowWorkHoursClick
+        }
+      })];
+    } : [h(BusinessHours, {
+      slotDuration: slotDuration,
+      attrs: _this2.v3 ? undefined : {
+        slotDuration: slotDuration
+      },
+      onClick: _this2.handleShowWorkHoursClick,
+      on: _this2.v3 ? undefined : {
+        "click": _this2.handleShowWorkHoursClick
+      }
+    })]);
+    footerRender = getTemplate.call(this, {
+      h: h,
+      template: footer,
+      defaultRendering: footerRenderDefaultRendering,
+      additionalProps: {
+        slotDuration: slotDuration
+      },
+      additionalListeners: {
+        showworkhoursclick: this.handleShowWorkHoursClick
+      }
+    });
+    return h("div", {
+      id: this.$props.id,
+      attrs: this.v3 ? undefined : {
+        id: this.$props.id,
+        tabindex: this.$props.tabIndex // Aria
+        //  dir={dir}
+        ,
+        role: this.$props.role,
+        "aria-label": this.$props.ariaLabel,
+        "aria-labelledby": this.$props.ariaLabelledby // Handlers
+
+      },
+      style: {
+        height: this.$props.height + 'px'
+      },
+      "class": this.wrapperClassName,
+      tabindex: this.$props.tabIndex,
+      role: this.$props.role,
+      "aria-label": this.$props.ariaLabel,
+      "aria-labelledby": this.$props.ariaLabelledby,
+      onFocusin: this.handleFocus,
+      on: this.v3 ? undefined : {
+        "focusin": this.handleFocus,
+        "focusout": this.handleBlur
+      },
+      onFocusout: this.handleBlur
+    }, [headerRender, view && h(viewComponent, __assign({
+      key: this.ks.view.name,
+      onDataaction: this.handleDataAction,
+      on: this.v3 ? undefined : {
+        'dataaction': this.handleDataAction
+      },
+      props: this.v3 ? undefined : viewProps
+    }, viewProps)), footerRender]);
+  },
+  methods: {
+    getViewComponentByName: function getViewComponentByName(viewName) {
+      switch (viewName.toLowerCase()) {
+        case 'week':
+          return WeekView;
+
+        case 'workweek':
+          return WorkWeekView;
+
+        case 'agenda':
+          return AgendaView;
+
+        case 'timeline':
+          return TimelineView;
+
+        case 'month':
+          return MonthView;
+
+        default:
+          return DayView;
+      }
+    },
+    getViewPropValue: function getViewPropValue(view, propName, activeViewName) {
+      var componentProp = this.getViewComponentByName(activeViewName).props[propName];
+      return view[propName] || (componentProp ? componentProp.default : undefined);
+    },
+    handleDataChange: function handleDataChange(_a) {
+      var _b = _a.created,
+          created = _b === void 0 ? [] : _b,
+          _c = _a.updated,
+          updated = _c === void 0 ? [] : _c,
+          _d = _a.deleted,
+          deleted = _d === void 0 ? [] : _d;
+      var args = {
+        created: created,
+        updated: updated,
+        deleted: deleted
+      };
+      this.$emit('datachange', args);
+    },
+    handleCreate: function handleCreate(action) {
+      var created = [action.dataItem];
+      this.handleDataChange({
+        created: created
+      });
+    },
+    handleUpdate: function handleUpdate(action) {
+      var _this = this;
+
+      var created = [];
+      var updated = [];
+
+      if (action.series) {
+        if (Array.isArray(action.dataItem)) {
+          action.dataItem.map(function (dataItem) {
+            var masterClone = clone(findMaster(action.dataItem, _this.fields, _this.dataItems));
+            var newDataItem = clone(dataItem);
+            setField(newDataItem, _this.fields.originalStart, getField(masterClone, _this.fields.originalStart));
+            setField(newDataItem, _this.fields.recurrenceId, getField(masterClone, _this.fields.recurrenceId));
+            setField(newDataItem, _this.fields.recurrenceExceptions, getField(masterClone, _this.fields.recurrenceExceptions));
+            updated.push(newDataItem);
+          });
+        } else {
+          var masterClone = clone(findMaster(action.dataItem, this.fields, this.dataItems));
+          var newDataItem = clone(action.dataItem);
+          setField(newDataItem, this.fields.originalStart, getField(masterClone, this.fields.originalStart));
+          setField(newDataItem, this.fields.recurrenceId, getField(masterClone, this.fields.recurrenceId));
+          setField(newDataItem, this.fields.recurrenceExceptions, getField(masterClone, this.fields.recurrenceExceptions));
+          updated.push(newDataItem);
+        }
+      } else {
+        if (Array.isArray(action.dataItem)) {
+          action.dataItem.map(function (dataItem) {
+            var isException = getField(dataItem, _this.fields.recurrenceRule) !== null && getField(dataItem, _this.fields.recurrenceRule) !== undefined;
+            var isRecurring = getField(dataItem, _this.fields.recurrenceId) !== null && getField(dataItem, _this.fields.recurrenceId) !== undefined;
+
+            if (isRecurring && isException) {
+              var masterClone = clone(findMaster(dataItem, _this.fields, _this.dataItems));
+              var exceptionDate = getField(dataItem, _this.fields.originalStart);
+              var currentExceptions = getField(masterClone, _this.fields.recurrenceExceptions) || [];
+              setField(masterClone, _this.fields.recurrenceExceptions, __spreadArray(__spreadArray([], currentExceptions, true), [exceptionDate], false));
+              setField(dataItem, _this.fields.recurrenceRule, null);
+              updated.push(masterClone);
+              created.push(dataItem);
+            } else {
+              updated.push(dataItem);
+            }
+          });
+        } else {
+          var isException = getField(action.dataItem, this.fields.recurrenceRule) !== null && getField(action.dataItem, this.fields.recurrenceRule) !== undefined;
+          var isRecurring = getField(action.dataItem, this.fields.recurrenceId) !== null && getField(action.dataItem, this.fields.recurrenceId) !== undefined;
+
+          if (isRecurring && isException) {
+            var masterClone = clone(findMaster(action.dataItem, this.fields, this.dataItems));
+            var exceptionDate = getField(action.dataItem, this.fields.originalStart);
+            var currentExceptions = getField(masterClone, this.fields.recurrenceExceptions) || [];
+            setField(masterClone, this.fields.recurrenceExceptions, __spreadArray(__spreadArray([], currentExceptions, true), [exceptionDate], false));
+            setField(action.dataItem, this.fields.recurrenceRule, null);
+            updated.push(masterClone);
+            created.push(action.dataItem);
+          } else {
+            updated.push(action.dataItem);
+          }
+        }
+      }
+
+      this.handleDataChange({
+        updated: updated,
+        created: created
+      });
+    },
+    handleRemove: function handleRemove(action) {
+      var updated = [];
+      var deleted = [];
+
+      if (action.series) {
+        var masterClone = clone(findMaster(action.dataItem, this.fields, this.dataItems));
+        var dataItem = clone(action.dataItem);
+        setField(dataItem, this.fields.originalStart, getField(masterClone, this.fields.originalStart));
+        setField(dataItem, this.fields.recurrenceId, getField(masterClone, this.fields.recurrenceId));
+        setField(dataItem, this.fields.recurrenceRule, getField(masterClone, this.fields.recurrenceRule));
+        setField(dataItem, this.fields.recurrenceExceptions, getField(masterClone, this.fields.recurrenceExceptions));
+        deleted.push(dataItem);
+      } else {
+        var isException = getField(action.dataItem, this.fields.recurrenceRule) !== null && getField(action.dataItem, this.fields.recurrenceRule) !== undefined;
+
+        if (!isException) {
+          deleted.push(action.dataItem);
+        } else {
+          var masterClone = clone(findMaster(action.dataItem, this.fields, this.dataItems));
+          var exceptionDate = getField(action.dataItem, this.fields.originalStart);
+          var currentExceptions = getField(masterClone, this.fields.recurrenceExceptions) || [];
+          setField(masterClone, this.fields.recurrenceExceptions, __spreadArray(__spreadArray([], currentExceptions, true), [exceptionDate], false));
+          setField(action.dataItem, this.fields.recurrenceRule, null);
+          updated.push(masterClone);
+        }
+      }
+
+      this.handleDataChange({
+        updated: updated,
+        deleted: deleted
+      });
+    },
+    handleDataAction: function handleDataAction(action) {
+      switch (action.type) {
+        case DATA_ACTION.create:
+          this.handleCreate(action);
+          break;
+
+        case DATA_ACTION.update:
+          this.handleUpdate(action);
+          break;
+
+        case DATA_ACTION.remove:
+          this.handleRemove(action);
+          break;
+
+        default:
+          break;
+      }
+    },
+    handleActiveViewNameChange: function handleActiveViewNameChange(newView, event) {
+      this.updatePassedState(newView);
+      this.$emit('viewchange', __assign(__assign({
+        viewName: newView
+      }, event), {
+        target: this.ks.scheduler.$el
+      }));
+    },
+    handleDateChange: function handleDateChange(newDate, event) {
+      this.setDate(newDate, __assign(__assign({}, event), {
+        target: this.ks.scheduler.$el
+      }));
+    },
+    handleDatePickerChange: function handleDatePickerChange(event) {
+      if (!event.value) {
+        return;
+      }
+
+      this.setDate(event.value, __assign(__assign({}, event), {
+        target: this.ks.scheduler.$el,
+        nativeEvent: event.event
+      }));
+    },
+    handleNextClick: function handleNextClick(event) {
+      event.preventDefault();
+      var offset = this.getViewPropValue(this.ks.view, 'step', this.ks.activeViewName) || this.getViewPropValue(this.ks.view, 'numberOfDays', this.ks.activeViewName) || 1;
+      var isMonthView = offset > 27;
+      var newDate = isMonthView ? addMonths(this.ks.currentDate, Math.round(offset / 27)) : addDays(this.ks.currentDate, offset);
+      this.setDate(newDate, event);
+    },
+    handlePrevClick: function handlePrevClick(event) {
+      event.preventDefault();
+      var offset = this.getViewPropValue(this.ks.view, 'step', this.ks.activeViewName) || this.getViewPropValue(this.ks.view, 'numberOfDays', this.ks.activeViewName) || 1;
+      var isMonthView = offset > 27;
+      var newDate = isMonthView ? addMonths(this.ks.currentDate, -Math.round(offset / 27)) : addDays(this.ks.currentDate, -offset);
+      this.setDate(newDate, event);
+    },
+    handleTodayClick: function handleTodayClick(event) {
+      event.preventDefault();
+      var newDate = getToday();
+      this.setDate(newDate, event);
+    },
+    handleShowWorkHoursClick: function handleShowWorkHoursClick() {
+      this.ks.showWorkHours = !this.ks.showWorkHours;
+    },
+    handleFocus: function handleFocus() {
+      if (this.$el) {
+        this.$el.style.boxShadow = '0 0.5px 0.5px 0.5px rgba(0, 0, 0, .12)';
+      }
+    },
+    handleBlur: function handleBlur() {
+      if (this.$el) {
+        this.$el.style.boxShadow = '';
+      }
+    },
+    handleItemClick: function handleItemClick(args) {
+      this.$emit('itemclick', args);
+    },
+    handleItemDoubleClick: function handleItemDoubleClick(args) {
+      this.$emit('itemdoubleclick', args);
+    },
+    handleSlotClick: function handleSlotClick(args) {
+      this.$emit('slotclick', args);
+    },
+    handleSlotDoubleClick: function handleSlotDoubleClick(args) {
+      this.$emit('slotdoubleclick', args);
+    },
+    handleTaskClick: function handleTaskClick(args) {
+      this.$emit('taskclick', args);
+    },
+    handleTaskDoubleClick: function handleTaskDoubleClick(args) {
+      this.$emit('taskdoubleclick', args);
+    },
+    setDate: function setDate(newDate, event) {
+      this.ks.currentDate = newDate;
+      this.updatePassedState();
+      this.$emit('datechange', {
+        date: newDate,
+        event: event
+      });
+    },
+    updatePassedState: function updatePassedState(newViewName) {
+      var newView = newViewName || this.ks.activeViewName;
+      this.ks.activeViewName = newView;
+      this.ks.view = this.views.find(function (currentView) {
+        return currentView.name === newView;
+      }) || this.views[0] || h(DayView);
+      this.ks.dateFormat = this.getViewPropValue(this.ks.view, 'selectedDateFormat', newView) || DEFAULT_DATE_FORMAT;
+      this.ks.shortDateFormat = this.getViewPropValue(this.ks.view, 'selectedShortDateFormat', newView) || DEFAULT_SHORT_DATE_FORMAT;
+      this.ks.dateRange = this.getViewComponentByName(newView).props.dateRange.default()({
+        intl: this.intl,
+        date: this.ks.currentDate,
+        timezone: this.$props.timezone,
+        numberOfDays: this.getViewPropValue(this.ks.view, 'numberOfDays', this.ks.activeViewName),
+        workWeekStart: this.getViewPropValue(this.ks.view, 'workWeekStart', this.ks.activeViewName) || this.intl.firstDay(),
+        workWeekEnd: this.getViewPropValue(this.ks.view, 'workWeekEnd', this.ks.activeViewName) || (this.intl.firstDay() + this.getViewPropValue(this.ks.view, 'numberOfDays', this.ks.activeViewName)) % 6
+      });
+    }
+  }
+};
+/** @hidden */
+
+var Scheduler = SchedulerVue2;
+export { Scheduler, SchedulerVue2 };

package/dist/esm/additionalTypes.ts

@@ -0,0 +1,21 @@
+// @ts-ignore
+import { DefineComponent } from 'vue';
+// @ts-ignore
+import * as Vue from 'vue';
+
+/**
+ * @hidden
+ */
+// @ts-ignore
+type Vue2type = Vue.default;
+
+/**
+ * @hidden
+ */
+// @ts-ignore
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+/**
+ * @hidden
+ */
+// @ts-ignore
+export { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type };