@progress/kendo-vue-scheduler 5.3.0-dev.202410141143 → 5.3.0-develop.2

package/items/SchedulerEditItem.mjs

@@ -0,0 +1,904 @@
+/**
+ * @license
+ *-------------------------------------------------------------------------------------------
+ * Copyright © 2024 Progress Software Corporation. All rights reserved.
+ * Licensed under commercial license. See LICENSE.md in the package root for more information
+ *-------------------------------------------------------------------------------------------
+ */
+import { defineComponent as R, createVNode as f, h as S } from "vue";
+import { DATA_ACTION as y } from "../constants/main.mjs";
+import { getDefaultSlots as A, getTemplate as D, clone as E, Keys as m } from "@progress/kendo-vue-common";
+import { SchedulerViewItem as v } from "./SchedulerViewItem.mjs";
+import { FORM_ITEM_ACTION as o } from "./hooks/use-form-item.mjs";
+import { SHOW_OCCURRENCE_DIALOG_ACTION as s, showOccurrenceDialogReducer as b } from "./hooks/use-show-occurrence-dialog.mjs";
+import { REMOVE_ITEM_ACTION as c } from "./hooks/use-remove-item.mjs";
+import { SHOW_REMOVE_DIALOG_ACTION as l, showRemoveDialogReducer as z } from "./hooks/use-show-remove-item-dialog.mjs";
+import { DRAG_ITEM_ACTION as a, useDragItem as w } from "./hooks/use-drag-item.mjs";
+import { RESIZE_ITEM_ACTION as r, useResizeItem as O } from "./hooks/use-resize-item.mjs";
+import { SERIES_ACTION as d, seriesReducer as M } from "./hooks/use-series.mjs";
+import { ITEMS_SELECT_ACTION as h } from "../hooks/use-items-selection.mjs";
+import { compareItems as C, findMaster as k, compareSlots as u } from "../utils/main.mjs";
+import { ITEMS_FOCUS_ACTION as g } from "../hooks/use-items-focus.mjs";
+import { SLOTS_FOCUS_ACTION as p } from "../hooks/use-slots-focus.mjs";
+const L = /* @__PURE__ */ R({
+  name: "KendoSchedulerEditItem",
+  inheritAttrs: !1,
+  props: {
+    tabIndex: {
+      type: Number,
+      default: void 0
+    },
+    item: [String, Function, Object],
+    viewItem: [String, Function, Object],
+    drag: [String, Function, Object],
+    resize: [String, Function, Object],
+    form: [String, Function, Object],
+    removeDialog: [String, Function, Object],
+    occurrenceDialog: [String, Function, Object],
+    formItem: Object,
+    dragItem: Object,
+    resizeItem: Object,
+    removeItem: Object,
+    showOccurrenceDialog: {
+      type: Boolean,
+      default: void 0
+    },
+    showRemoveDialog: {
+      type: Boolean,
+      default: void 0
+    },
+    series: {
+      type: Boolean,
+      default: void 0
+    },
+    uid: [String, Number],
+    start: Date,
+    end: Date,
+    originalStart: Date,
+    startTimezone: String,
+    endTimezone: String,
+    isAllDay: Boolean,
+    title: String,
+    description: String,
+    occurrenceId: String,
+    recurrenceExceptions: Array,
+    recurrenceRule: String,
+    recurrenceId: [String, Number],
+    dataItem: Object,
+    head: Boolean,
+    tail: Boolean,
+    order: Number,
+    zonedStart: Object,
+    zonedEnd: Object,
+    slots: Array,
+    group: Object,
+    range: Object,
+    isException: Boolean,
+    isRecurring: Boolean,
+    id: String,
+    className: String,
+    itemStyle: Object,
+    editable: [Object, Boolean],
+    selected: Boolean,
+    vertical: Boolean,
+    dragHint: Boolean,
+    resizeHint: Boolean,
+    format: String,
+    ignoreIsAllDay: Boolean,
+    itemRef: Object,
+    onRemoveclick: Function,
+    onDataaction: Function,
+    onFormItemChange: Function,
+    onDragitemchange: Function,
+    onResizeitemchange: Function
+  },
+  inject: {
+    bv: {
+      default: null
+    },
+    ks: {
+      default: null
+    },
+    dispatchFocusedItems: {
+      default: null
+    },
+    dispatchFocusedSlots: {
+      default: null
+    },
+    dispatchSelectedItems: {
+      default: null
+    }
+  },
+  provide() {
+    return {
+      ei: this.ei,
+      ksCancel: this.handleCancel,
+      ksFormSubmit: this.handleFormSubmit,
+      ksOccurrenceClick: this.handleOccurrenceClick,
+      ksSeriesClick: this.handleSeriesClick,
+      ksRemoveConfirm: this.handleRemoveConfirm
+    };
+  },
+  data() {
+    return {
+      ei: {
+        props: this.$props,
+        form: this.$props.formItem,
+        drag: this.drag,
+        resize: this.resize,
+        remove: this.remove,
+        showRemoveDialog: this.showRemoveDialog,
+        showOccurrenceDialog: this.showOccurrenceDialog
+      },
+      currentFormItem: null,
+      currentSelected: null,
+      currentSeries: null,
+      currentRemoveItem: null,
+      currentDragItem: null,
+      currentResizeItem: null,
+      currentShowRemoveDialog: null,
+      currentShowOccurrenceDialog: null
+      //    item: null
+    };
+  },
+  computed: {
+    currentTabIndex() {
+      const t = this.bv.items.length && this.bv.items[0].dataItem.id === this.dataItem.id;
+      return this.$props.tabIndex !== void 0 ? this.$props.tabIndex === null ? void 0 : this.$props.tabIndex : this.bv.selectedItems.length === 0 && t ? 0 : void 0;
+    },
+    compSelected() {
+      return this.selected !== void 0 ? this.selected : this.currentSelected;
+    },
+    compSeries() {
+      return this.series !== void 0 ? this.series : this.currentSeries;
+    },
+    compFormItem() {
+      return this.formItem !== void 0 ? this.formItem : this.currentFormItem;
+    },
+    compRemoveItem() {
+      return this.removeItem !== void 0 ? this.removeItem : this.currentRemoveItem;
+    },
+    compDragItem() {
+      return this.dragItem !== void 0 ? this.dragItem : this.currentDragItem;
+    },
+    compResizeItem() {
+      return this.resizeItem !== void 0 ? this.resizeItem : this.currentResizeItem;
+    },
+    compShowRemoveDialog() {
+      return this.showRemoveDialog !== void 0 ? this.showRemoveDialog : this.currentShowRemoveDialog;
+    },
+    compShowOccurrenceDialog() {
+      return this.showOccurrenceDialog !== void 0 ? this.showOccurrenceDialog : this.currentShowOccurrenceDialog;
+    },
+    actionsReducerMap() {
+      return {
+        [d.set]: this.dispatchSeries,
+        [d.toggle]: this.dispatchSeries,
+        [d.reset]: this.dispatchSeries,
+        [h.select]: this.dispatchItemSelection,
+        [h.add]: this.dispatchItemSelection,
+        [h.remove]: this.dispatchItemSelection,
+        [h.reset]: this.dispatchItemSelection,
+        [h.selectNext]: this.dispatchItemSelection,
+        [h.selectPrev]: this.dispatchItemSelection,
+        [o.set]: this.dispatchFormItem,
+        [o.setMaster]: this.dispatchFormItem,
+        [o.reset]: this.dispatchFormItem,
+        [o.complete]: this.dispatchFormItem,
+        [c.set]: this.dispatchRemoveItem,
+        [c.reset]: this.dispatchRemoveItem,
+        [c.complete]: this.dispatchRemoveItem,
+        [s.close]: this.dispatchShowOccurrenceDialog,
+        [s.open]: this.dispatchShowOccurrenceDialog,
+        [s.set]: this.dispatchShowOccurrenceDialog,
+        [s.toggle]: this.dispatchShowOccurrenceDialog,
+        [s.reset]: this.dispatchShowOccurrenceDialog,
+        [l.close]: this.dispatchShowRemoveDialog,
+        [l.open]: this.dispatchShowRemoveDialog,
+        [l.set]: this.dispatchShowRemoveDialog,
+        [l.toggle]: this.dispatchShowRemoveDialog,
+        [l.reset]: this.dispatchShowRemoveDialog,
+        [a.start]: this.dispatchDragItem,
+        [a.drag]: this.dispatchDragItem,
+        [a.complete]: this.dispatchDragItem,
+        [a.completeOccurrence]: this.dispatchDragItem,
+        [a.completeSeries]: this.dispatchDragItem,
+        [a.set]: this.dispatchDragItem,
+        [a.reset]: this.dispatchDragItem,
+        [a.dragSelected]: this.dispatchDragItem,
+        [r.start]: this.dispatchResizeItem,
+        [r.startDrag]: this.dispatchResizeItem,
+        [r.startDragSelected]: this.dispatchResizeItem,
+        [r.endDrag]: this.dispatchResizeItem,
+        [r.endDragSelected]: this.dispatchResizeItem,
+        [r.complete]: this.dispatchResizeItem,
+        [r.completeOccurrence]: this.dispatchResizeItem,
+        [r.completeSeries]: this.dispatchResizeItem,
+        [r.set]: this.dispatchResizeItem,
+        [r.reset]: this.dispatchResizeItem,
+        [g.next]: this.dispatchViewItemsFocus,
+        [g.prev]: this.dispatchViewItemsFocus,
+        [p.left]: this.dispatchViewSlotsFocus,
+        [p.right]: this.dispatchViewSlotsFocus,
+        [p.up]: this.dispatchViewSlotsFocus,
+        [p.down]: this.dispatchViewSlotsFocus,
+        null: () => {
+        }
+      };
+    }
+  },
+  render() {
+    const t = A(this), e = !!(this.bv.selectedItems && this.bv.selectedItems.some((I) => C(I, this, this.ignoreIsAllDay)));
+    let i;
+    const n = f(v, {
+      ignoreIsAllDay: this.ignoreIsAllDay,
+      item: this.item,
+      uid: this.uid,
+      start: this.start,
+      end: this.end,
+      originalStart: this.originalStart,
+      startTimezone: this.startTimezone,
+      endTimezone: this.endTimezone,
+      isAllDay: this.isAllDay,
+      title: this.title,
+      description: this.description,
+      occurrenceId: this.occurrenceId,
+      recurrenceExceptions: this.recurrenceExceptions,
+      recurrenceRule: this.recurrenceRule,
+      recurrenceId: this.recurrenceId,
+      dataItem: this.dataItem,
+      head: this.head,
+      tail: this.tail,
+      order: this.order,
+      zonedStart: this.zonedStart,
+      zonedEnd: this.zonedEnd,
+      slots: this.slots,
+      group: this.group,
+      range: this.range,
+      isException: this.isException,
+      isRecurring: this.isRecurring,
+      id: this.id,
+      className: this.className,
+      itemStyle: this.itemStyle,
+      editable: this.editable,
+      vertical: this.vertical,
+      dragHint: this.dragHint,
+      resizeHint: this.resizeHint,
+      format: this.format,
+      showOccurrenceDialog: this.compShowOccurrenceDialog,
+      showRemoveDialog: this.compShowRemoveDialog,
+      formItem: this.compFormItem,
+      dragItem: this.compDragItem,
+      resizeItem: this.compResizeItem,
+      removeItem: this.compRemoveItem,
+      itemRef: this.item,
+      selected: e,
+      tabIndex: this.currentTabIndex,
+      onKeydown: this.handleKeyDown,
+      onKeyup: this.handleKeyUp,
+      onFocus: this.handleFocus,
+      onMouseup: this.handleMouseUp,
+      onMousedown: this.handleMouseDown,
+      onClick: this.handleClick,
+      onDoubleclick: this.handleDoubleClick,
+      onRemoveclick: this.handleRemoveClick,
+      onPress: this.handlePress,
+      onDrag: this.handleDrag,
+      onRelease: this.handleRelease,
+      onResizepress: this.handleResizePress,
+      onResizeenddrag: this.handleResizeEndDrag,
+      onResizestartdrag: this.handleResizeStartDrag,
+      onResizerelease: this.handleResizeRelease
+    }, null);
+    return i = D.call(this, {
+      h: S,
+      template: this.$props.viewItem,
+      defaultRendering: n,
+      defaultSlots: t,
+      additionalListeners: {
+        //   keydown: this.handleKeyDown,
+        // keyup: this.handleKeyUp,
+        // Focus
+        //  focus: this.handleFocus,
+        // Mouse
+        // mouseup: this.handleMouseUp,
+        // mousedown: this.handleMouseDown,
+        //  click: this.handleClick,
+        doubleclick: this.handleDoubleClick,
+        removeclick: this.handleRemoveClick,
+        // Drag
+        press: this.handlePress,
+        drag: this.handleDrag,
+        release: this.handleRelease,
+        // Resize
+        resizepress: this.handleResizePress,
+        resizeenddrag: this.handleResizeEndDrag,
+        resizestartdrag: this.handleResizeStartDrag,
+        resizerelease: this.handleResizeRelease
+      }
+    }), i;
+  },
+  methods: {
+    dispatchSeries(t, e) {
+      const i = M(this.compSeries, t);
+      this.currentSeries = i, this.$emit("serieschange", i);
+    },
+    dispatchItemSelection(t, e) {
+      this.dispatchSelectedItems(t, e);
+    },
+    dispatchRemoveItem(t, e) {
+      let i;
+      switch (t.type) {
+        case c.set:
+          i = t.payload;
+          break;
+        case c.reset:
+          i = null;
+          break;
+        case c.complete:
+          this.compRemoveItem && this.$emit("dataaction", {
+            type: y.remove,
+            series: this.compSeries,
+            dataItem: this.compRemoveItem
+          }), i = null;
+          break;
+        default:
+          i = this.compRemoveItem;
+          break;
+      }
+      this.currentRemoveItem = i, this.$emit("removeitemchange", i);
+    },
+    dispatchShowOccurrenceDialog(t, e) {
+      const i = b(this.compShowOccurrenceDialog, t);
+      this.currentShowOccurrenceDialog = i, this.$emit("showremovedialogchange", i);
+    },
+    dispatchShowRemoveDialog(t, e) {
+      const i = z(this.compShowRemoveDialog, t);
+      this.currentShowRemoveDialog = i, this.$emit("showremovedialogchange", i);
+    },
+    dispatchDragItem(t, e) {
+      w.call(this, t);
+    },
+    dispatchResizeItem(t, e) {
+      O.call(this, t, e);
+    },
+    dispatchViewSlotsFocus(t, e) {
+      this.dispatchFocusedSlots(t, e);
+    },
+    dispatchViewItemsFocus(t, e) {
+      this.dispatchFocusedItems(t, e);
+    },
+    dispatchFormItem(t, e) {
+      let i;
+      switch (t.type) {
+        case o.set:
+          i = t.payload;
+          break;
+        case o.reset:
+          i = null;
+          break;
+        case o.setMaster:
+          i = E(k(t.payload, this.ks.fields, this.ks.dataItems));
+          break;
+        case o.complete:
+          this.compFormItem && (this.$emit("dataaction", {
+            type: y.update,
+            series: this.compSeries,
+            dataItem: t.payload
+          }), i = null);
+          break;
+        default:
+          i = this.compFormItem;
+          break;
+      }
+      this.currentFormItem = i, this.$emit("formitemchange", i);
+    },
+    handleFocus(t) {
+      if (this.onFocusAction) {
+        const e = this.onFocusAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }));
+      }
+      this.$emit("focus", t);
+    },
+    handleMouseDown(t) {
+      if (this.onMouseDownAction) {
+        const e = this.onMouseDownAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }));
+      }
+      this.$emit("mousedown", t);
+    },
+    handleMouseUp(t) {
+      if (this.onMouseUpAction) {
+        const e = this.onMouseUpAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }));
+      }
+      this.$emit("mouseup", t);
+    },
+    handleClick(t) {
+      if (this.onClickAction) {
+        const e = this.onClickAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }));
+      }
+      this.$emit("click", t);
+    },
+    handleDoubleClick(t) {
+      if (this.onDoubleClickAction) {
+        const e = this.onDoubleClickAction(t, this.$props), i = this;
+        e && (Array.isArray(e) ? e.filter(Boolean).map((n) => n && i.actionsReducerMap[n.type]({
+          ...n,
+          item: i.dataItem
+        }, t)) : i.actionsReducerMap[e.type]({
+          ...e,
+          item: i.dataItem
+        }));
+      }
+      this.$emit("doubleclick", t);
+    },
+    handleRemoveClick(t) {
+      if (this.onRemoveClickAction) {
+        const e = this.onRemoveClickAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }));
+      }
+      this.$emit("removeclick", t);
+    },
+    handlePress(t) {
+      if (this.onPressAction) {
+        const e = this.onPressAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t));
+      }
+      this.$emit("press", t);
+    },
+    handleDrag(t) {
+      if (this.onDragAction) {
+        const e = this.onDragAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("drag", t);
+    },
+    handleRelease(t) {
+      if (this.onReleaseAction) {
+        const e = this.onReleaseAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("release", t);
+    },
+    handleResizePress(t) {
+      if (this.onResizePressAction) {
+        const e = this.onResizePressAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("resizepress", t);
+    },
+    handleResizeStartDrag(t) {
+      if (this.onResizeStartDragAction) {
+        const e = this.onResizeStartDragAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("resizestartdrag", t);
+    },
+    handleResizeEndDrag(t) {
+      if (this.onResizeEndDragAction) {
+        const e = this.onResizeEndDragAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("resizeenddrag", t);
+    },
+    handleResizeRelease(t) {
+      if (this.onResizeReleaseAction) {
+        const e = this.onResizeReleaseAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.dragEvent.originalEvent));
+      }
+      this.$emit("resizerelease", t);
+    },
+    handleFormSubmit(t) {
+      if (this.onFormSubmitAction) {
+        const e = this.onFormSubmitAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t));
+      }
+      this.$emit("formsubmit", t);
+    },
+    handleCancel(t) {
+      if (this.onCancelAction) {
+        const e = this.onCancelAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t));
+      }
+      this.$emit("cancel", t);
+    },
+    handleOccurrenceClick(t) {
+      if (this.onOccurrenceClickAction) {
+        const e = this.onOccurrenceClickAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t));
+      }
+      this.$emit("occurrenceclick", t);
+    },
+    handleSeriesClick(t) {
+      if (this.onSeriesClickAction) {
+        const e = this.onSeriesClickAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t));
+      }
+      this.$emit("seriesclick", t);
+    },
+    handleKeyDown(t) {
+      if (this.onKeyDownAction) {
+        const e = this.onKeyDownAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this
+        }, t.event)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this
+        }, t.event));
+      }
+      this.$emit("keydown", t);
+    },
+    handleKeyUp(t) {
+      if (this.onKeyUpAction) {
+        const e = this.onKeyUpAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.event)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.event));
+      }
+      this.$emit("keyup", t);
+    },
+    handleRemoveConfirm(t) {
+      if (this.onRemoveConfirmAction) {
+        const e = this.onRemoveConfirmAction(t, this.$props);
+        e && (Array.isArray(e) ? e.filter(Boolean).map((i) => i && this.actionsReducerMap[i.type]({
+          ...i,
+          item: this.dataItem
+        }, t.event)) : this.actionsReducerMap[e.type]({
+          ...e,
+          item: this.dataItem
+        }, t.event));
+      }
+      this.$emit("removeconfirm", t);
+    },
+    onClickAction(t, e) {
+      return [{
+        type: t.event.metaKey || t.event.ctrlKey ? this.compSelected && !this.compDragItem && !this.compResizeItem ? h.remove : h.add : h.select
+      }];
+    },
+    onDoubleClickAction(t, e) {
+      return e.editable ? [{
+        type: o.set,
+        payload: e.dataItem
+      }, e.isRecurring && {
+        type: s.open
+      }].filter(Boolean) : [];
+    },
+    onRemoveClickAction(t, e) {
+      return e.editable ? [{
+        type: c.set,
+        payload: e.dataItem
+      }, e.isRecurring ? {
+        type: s.open
+      } : {
+        type: l.open
+      }] : [];
+    },
+    onPressAction(t, e) {
+      return e.editable ? {
+        type: a.start,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onDragAction(t, e) {
+      return e.editable ? {
+        type: t.dragEvent.originalEvent.metaKey || t.dragEvent.originalEvent.ctrlKey ? a.dragSelected : a.drag,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onReleaseAction(t, e) {
+      return e.editable && this.compDragItem ? e.isRecurring && !e.isException && this.compSeries === null ? {
+        type: s.open
+      } : {
+        type: e.isRecurring ? this.compSeries ? a.completeSeries : a.completeOccurrence : a.complete,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onResizePressAction(t, e) {
+      return e.editable ? {
+        type: r.start,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onResizeStartDragAction(t, e) {
+      return e.editable ? {
+        type: t.dragEvent.originalEvent.metaKey || t.dragEvent.originalEvent.ctrlKey ? r.startDragSelected : r.startDrag,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onResizeEndDragAction(t, e) {
+      return e.editable ? {
+        type: t.dragEvent.originalEvent.metaKey || t.dragEvent.originalEvent.ctrlKey ? r.endDragSelected : r.endDrag,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onResizeReleaseAction(t, e) {
+      return e.editable && this.compResizeItem ? e.isRecurring && !e.isException && this.compSeries === null ? {
+        type: s.open
+      } : {
+        type: e.isRecurring ? this.compSeries ? r.completeSeries : r.completeOccurrence : r.complete,
+        payload: {
+          x: t.dragEvent.clientX,
+          y: t.dragEvent.clientY
+        }
+      } : [];
+    },
+    onOccurrenceClickAction(t, e) {
+      if (this.compDragItem)
+        return [{
+          type: a.completeOccurrence
+        }, {
+          type: s.close
+        }];
+      if (this.compResizeItem)
+        return [{
+          type: r.completeOccurrence
+        }, {
+          type: s.close
+        }];
+      if (this.compFormItem)
+        return [{
+          type: d.set,
+          payload: !1
+        }, {
+          type: o.set,
+          payload: e.dataItem
+        }, {
+          type: s.close
+        }];
+      if (this.compRemoveItem)
+        return [{
+          type: d.set,
+          payload: !1
+        }, {
+          type: c.set,
+          payload: e.dataItem
+        }, {
+          type: l.open
+        }, {
+          type: s.close
+        }];
+    },
+    onSeriesClickAction(t, e) {
+      if (this.compDragItem)
+        return [{
+          type: a.completeSeries
+        }, {
+          type: s.close
+        }];
+      if (this.compResizeItem)
+        return [{
+          type: r.completeSeries
+        }, {
+          type: s.close
+        }];
+      if (this.compFormItem)
+        return [{
+          type: d.set,
+          payload: !0
+        }, {
+          type: o.setMaster,
+          payload: e.dataItem
+        }, {
+          type: s.close
+        }];
+      if (this.compRemoveItem)
+        return [{
+          type: d.set,
+          payload: !0
+        }, {
+          type: c.set,
+          payload: e.dataItem
+        }, {
+          type: l.open
+        }, {
+          type: s.close
+        }];
+    },
+    onKeyDownAction(t, e) {
+      let i;
+      switch (t.event.keyCode) {
+        case m.enter:
+          return [{
+            type: o.set,
+            payload: e.dataItem
+          }, e.isRecurring && {
+            type: s.open
+          }];
+        case m.tab:
+          return [{
+            type: t.event.shiftKey ? g.prev : g.next,
+            ignoreIsAllDay: e.ignoreIsAllDay
+          }, {
+            type: t.event.shiftKey ? h.selectPrev : h.selectNext,
+            ignoreIsAllDay: e.ignoreIsAllDay
+          }];
+        case m.up:
+          return i = this.bv.slots.find((n) => u(n.cSlot, e.slots[0])), [!!(e.slots.length && i) && {
+            type: p.up,
+            slot: i
+          }];
+        case m.right:
+          return i = this.bv.slots.find((n) => u(n.cSlot, e.slots[0])), [!!(e.slots.length && i) && {
+            type: p.right,
+            slot: i
+          }];
+        case m.down:
+          return i = this.bv.slots.find((n) => u(n.cSlot, e.slots[e.slots.length - 1])), [!!(e.slots.length && i) && {
+            type: p.down,
+            slot: i
+          }];
+        case m.left:
+          return i = this.bv.slots.find((n) => u(n.cSlot.cSlot, e.slots[0])), [!!(e.slots.length && i) && {
+            type: p.left,
+            slot: i
+          }];
+        case m.delete:
+        case m.backspace:
+          return [{
+            type: c.set,
+            payload: e.dataItem
+          }, e.isRecurring ? {
+            type: s.open
+          } : {
+            type: l.open
+          }];
+        default:
+          return;
+      }
+    },
+    onFormSubmitAction(t) {
+      return {
+        type: o.complete,
+        payload: t.value
+      };
+    },
+    onRemoveConfirmAction() {
+      return [{
+        type: c.complete
+      }, {
+        type: s.close
+      }];
+    },
+    onCancelAction() {
+      return [{
+        type: d.reset
+      }, {
+        type: c.reset
+      }, {
+        type: o.reset
+      }, {
+        type: a.reset
+      }, {
+        type: r.reset
+      }, {
+        type: l.reset
+      }, {
+        type: s.reset
+      }];
+    }
+  }
+});
+export {
+  L as SchedulerEditItem
+};