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

package/dist/esm/items/hooks/use-drag-item.js

@@ -0,0 +1,255 @@
+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 { clone } from '@progress/kendo-vue-common'; // import { useSchedulerFieldsContext, useSchedulerGroupsContext,
+// useSchedulerViewSelectedItemsContext } from '../../context.js';
+// import { useControlledState } from '../../hooks/useControlledState.js';
+
+import { DATA_ACTION } from '../../main.js';
+import { getField, setField, slotDive } from '../../utils.js';
+/**
+ * Represents the available `action` types for the `SchedulerItemDragItemAction` objects.
+ *
+ * The available types are:
+ * - `DRAG_ITEM_SET'`
+ * - `DRAG_ITEM_START'`
+ * - `DRAG_ITEM_DRAG'`
+ * - `DRAG_ITEM_COMPLETE'`
+ * - `DRAG_ITEM_COMPLETE_OCCURRENCE'`
+ * - `DRAG_ITEM_COMPLETE_SERIES'`
+ * - `DRAG_ITEM_RESET'`
+ * - `DRAG_ITEM_DRAG_SELECTED`
+ */
+
+export var DRAG_ITEM_ACTION;
+
+(function (DRAG_ITEM_ACTION) {
+  DRAG_ITEM_ACTION["set"] = "DRAG_ITEM_SET";
+  DRAG_ITEM_ACTION["start"] = "DRAG_ITEM_START";
+  DRAG_ITEM_ACTION["drag"] = "DRAG_ITEM_DRAG";
+  DRAG_ITEM_ACTION["complete"] = "DRAG_ITEM_COMPLETE";
+  DRAG_ITEM_ACTION["completeOccurrence"] = "DRAG_ITEM_COMPLETE_OCCURRENCE";
+  DRAG_ITEM_ACTION["completeSeries"] = "DRAG_ITEM_COMPLETE_SERIES";
+  DRAG_ITEM_ACTION["reset"] = "DRAG_ITEM_RESET";
+  DRAG_ITEM_ACTION["dragSelected"] = "DRAG_ITEM_DRAG_SELECTED";
+})(DRAG_ITEM_ACTION || (DRAG_ITEM_ACTION = {}));
+
+var offset = 0;
+var initialXRef = 0;
+var initialYRef = 0;
+var oldSlot = null;
+/** @hidden */
+
+export var useDragItem = function useDragItem(action) {
+  var _this = this;
+
+  var dataItem = clone(this.dataItem);
+
+  switch (action.type) {
+    case DRAG_ITEM_ACTION.set:
+      {
+        this.currentDragItem = action.payload;
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.reset:
+      {
+        this.currentDragItem = null;
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.dragSelected:
+      {
+        if (Math.abs(initialXRef - action.payload.x) < 10 && Math.abs(initialYRef - action.payload.y) < 10) {
+          return;
+        }
+
+        var slot = slotDive(action.payload.x, action.payload.y, 7);
+
+        if (!slot) {
+          return;
+        }
+
+        if (slot === oldSlot) {
+          return;
+        }
+
+        var slotStart = slot.getAttribute('data-slot-start');
+        var slotIsAllDay = slot.getAttribute('data-slot-allday') === 'true';
+
+        if (!this.ignoreIsAllDay && slotIsAllDay !== this.isAllDay) {
+          return;
+        }
+
+        var itemStart = new Date(getField(dataItem, this.ks.fields.start));
+        var distance_1 = Number(slotStart) - itemStart.getTime();
+        var newDragItems = this.bv.selectedItems.map(function (si) {
+          if (!si) {
+            return null;
+          }
+
+          var selectedDataItem = clone(si.props.dataItem);
+          var selectedStart = new Date(si.props.start.getTime() + distance_1);
+          var selectedEnd = new Date(si.props.end.getTime() + distance_1);
+          setField(selectedDataItem, _this.ks.fields.start, selectedStart);
+          setField(selectedDataItem, _this.ks.fields.end, selectedEnd);
+          return selectedDataItem;
+        }).filter(Boolean);
+        oldSlot = slot;
+        this.currentDragItem = __spreadArray([], newDragItems, true);
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.start:
+      {
+        var clientX = action.payload.x;
+        var clientY = action.payload.y;
+        initialXRef = clientX;
+        initialYRef = clientY;
+        var slot = slotDive(clientX, clientY, 7);
+
+        if (!slot) {
+          return;
+        }
+
+        var slotStart = slot.getAttribute('data-slot-start');
+        var itemStart = getField(dataItem, this.ks.fields.start);
+
+        if (slotStart === null) {
+          return;
+        }
+
+        offset = Number(slotStart) - new Date(itemStart).getTime();
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.drag:
+      {
+        if (Math.abs(initialXRef - action.payload.x) < 10 && Math.abs(initialYRef - action.payload.y) < 10) {
+          return;
+        }
+
+        var slot = slotDive(action.payload.x, action.payload.y, 7);
+
+        if (!slot) {
+          return;
+        }
+
+        if (slot === oldSlot) {
+          return;
+        }
+
+        var slotStart = slot.getAttribute('data-slot-start');
+        var slotGroupIndex_1 = slot.getAttribute('data-slot-group');
+        var slotIsAllDay = slot.getAttribute('data-slot-allday') === 'true';
+
+        if (!this.ignoreIsAllDay && slotIsAllDay !== this.isAllDay) {
+          return;
+        }
+
+        var itemStart = new Date(getField(dataItem, this.ks.fields.start));
+        var itemEnd = new Date(getField(dataItem, this.ks.fields.end));
+        var duration = itemEnd.getTime() - itemStart.getTime();
+        var start = new Date(Number(slotStart) - Number(offset));
+        var end = new Date(Number(slotStart) - Number(offset) + duration);
+        var group = this.ks.groups.find(function (g) {
+          return g.index === Number(slotGroupIndex_1);
+        });
+        setField(dataItem, this.ks.fields.start, start);
+        setField(dataItem, this.ks.fields.end, end);
+
+        if (group && this.ks.groups.length > 1) {
+          group.resources.forEach(function (resource) {
+            if (!resource.multiple) {
+              setField(dataItem, resource.field, resource[resource.valueField]);
+            }
+          });
+        }
+
+        oldSlot = slot;
+
+        if (dataItem) {
+          this.currentDragItem = dataItem;
+        }
+
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.complete:
+      {
+        var currentDataItem = this.compDragItem;
+        this.currentDragItem = null;
+
+        if (currentDataItem) {
+          this.$emit('dataaction', {
+            type: DATA_ACTION.update,
+            series: false,
+            dataItem: currentDataItem
+          });
+        }
+
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.completeOccurrence:
+      {
+        var newDataItem = Array.isArray(this.compDragItem) ? this.compDragItem.slice() : clone(this.compDragItem);
+        var currentDataItem = this.compDragItem;
+        this.currentDragItem = null;
+
+        if (currentDataItem) {
+          this.$emit('dataaction', {
+            type: DATA_ACTION.update,
+            series: false,
+            dataItem: newDataItem
+          });
+        }
+
+        break;
+      }
+
+    case DRAG_ITEM_ACTION.completeSeries:
+      {
+        var newDataItems = void 0;
+
+        if (Array.isArray(this.compDragItem)) {
+          newDataItems = this.compDragItem.map(function (di) {
+            var updated = clone(di);
+            setField(updated, _this.ks.fields.start, getField(di, _this.ks.fields.start));
+            setField(updated, _this.ks.fields.end, getField(di, _this.ks.fields.end));
+            return updated;
+          });
+        } else {
+          var updated = clone(this.compDragItem);
+          setField(updated, this.ks.fields.start, getField(this.compDragItem, this.ks.fields.start));
+          setField(updated, this.ks.fields.end, getField(this.compDragItem, this.ks.fields.end));
+          newDataItems = updated;
+        }
+
+        this.currentDragItem = null;
+
+        if (newDataItems) {
+          this.$emit('dataaction', {
+            type: DATA_ACTION.update,
+            series: true,
+            dataItem: newDataItems
+          });
+        }
+
+        break;
+      }
+
+    default:
+      this.currentDragItem = this.compDragItem;
+      break;
+  }
+
+  this.$emit('dragitemchange', this.currentDragItem);
+};

package/dist/esm/items/hooks/use-form-item.d.ts

@@ -0,0 +1,22 @@
+import { DataItem } from '../../models';
+/** @hidden */
+export declare enum FORM_ITEM_ACTION {
+    set = "FORM_ITEM_SET",
+    setMaster = "FORM_ITEM_SET_MASTER",
+    reset = "FORM_ITEM_RESET",
+    complete = "FORM_ITEM_COMPLETE"
+}
+/** @hidden */
+export declare type SchedulerItemFormItemAction = {
+    type: FORM_ITEM_ACTION;
+    payload?: DataItem;
+};
+/** @hidden */
+export declare const useFormItem: (_config: {
+    series: boolean;
+    onDataaction?: any;
+}, _state: [
+    DataItem,
+    DataItem,
+    any
+]) => any[];

package/dist/esm/items/hooks/use-form-item.js

@@ -0,0 +1,50 @@
+/** @hidden */
+export var FORM_ITEM_ACTION;
+
+(function (FORM_ITEM_ACTION) {
+  FORM_ITEM_ACTION["set"] = "FORM_ITEM_SET";
+  FORM_ITEM_ACTION["setMaster"] = "FORM_ITEM_SET_MASTER";
+  FORM_ITEM_ACTION["reset"] = "FORM_ITEM_RESET";
+  FORM_ITEM_ACTION["complete"] = "FORM_ITEM_COMPLETE";
+})(FORM_ITEM_ACTION || (FORM_ITEM_ACTION = {}));
+/** @hidden */
+
+
+export var useFormItem = function useFormItem(_config, _state) {
+  // const [formItem, setFormItem] = useControlledState<DataItem | null>(...state);
+  // const fields = useSchedulerFieldsContext();
+  // const [data] = useSchedulerDataContext();
+  // const handleFormItemAction = (
+  //     action: SchedulerItemFormItemAction,
+  //     event?: any | BaseEvent<any> | { preventDefault: any }
+  // ) => {
+  //     let newFormItem;
+  //     switch(action.type) {
+  //         case FORM_ITEM_ACTION.set:
+  //             newFormItem = action.payload;
+  //             break;
+  //         case FORM_ITEM_ACTION.reset:
+  //             newFormItem = null;
+  //             break;
+  //         case FORM_ITEM_ACTION.setMaster:
+  //             newFormItem = clone(findMaster(action.payload, fields, data));
+  //             break;
+  //         case FORM_ITEM_ACTION.complete:
+  //             if(config.onDataAction && formItem) {
+  //                 config.onDataAction.call(undefined,{
+  //                     type: DATA_ACTION.update,
+  //                     series: config.series,
+  //                     dataItem: action.payload
+  //                 });
+  //                 newFormItem = null;
+  //             }
+  //             break;
+  //         default:
+  //             newFormItem = formItem;
+  //             break;
+  //     }
+  //     setFormItem(newFormItem, event);
+  // };
+  // return [formItem, setFormItem, handleFormItemAction];
+  return [];
+};

package/dist/esm/items/hooks/use-remove-item.d.ts

@@ -0,0 +1,30 @@
+import { DataItem } from '../../models';
+/**
+ * Represents the available `action` types for the `SchedulerItemRemoveItemAction` objects.
+ *
+ * The available types are:
+ * - `REMOVE_ITEM_SET`
+ * - `REMOVE_ITEM_RESET`
+ * - `REMOVE_ITEM_COMPLETE`
+ */
+export declare enum REMOVE_ITEM_ACTION {
+    set = "REMOVE_ITEM_SET",
+    reset = "REMOVE_ITEM_RESET",
+    complete = "REMOVE_ITEM_COMPLETE"
+}
+/**
+ * Represents the object passed to the `remove-item` reducer.
+ */
+export declare type SchedulerItemRemoveItemAction = {
+    type: REMOVE_ITEM_ACTION;
+    payload?: DataItem;
+};
+/** @hidden */
+export declare const useRemoveItem: (_config: {
+    series: boolean;
+    onDataaction?: any;
+}, _state: [
+    DataItem,
+    DataItem,
+    any
+]) => any[];

package/dist/esm/items/hooks/use-remove-item.js

@@ -0,0 +1,48 @@
+/**
+ * Represents the available `action` types for the `SchedulerItemRemoveItemAction` objects.
+ *
+ * The available types are:
+ * - `REMOVE_ITEM_SET`
+ * - `REMOVE_ITEM_RESET`
+ * - `REMOVE_ITEM_COMPLETE`
+ */
+export var REMOVE_ITEM_ACTION;
+
+(function (REMOVE_ITEM_ACTION) {
+  REMOVE_ITEM_ACTION["set"] = "REMOVE_ITEM_SET";
+  REMOVE_ITEM_ACTION["reset"] = "REMOVE_ITEM_RESET";
+  REMOVE_ITEM_ACTION["complete"] = "REMOVE_ITEM_COMPLETE";
+})(REMOVE_ITEM_ACTION || (REMOVE_ITEM_ACTION = {}));
+/** @hidden */
+
+
+export var useRemoveItem = function useRemoveItem(_config, _state) {
+  // const [removeItem, setRemoveItem] = useControlledState<DataItem | null>(...state);
+  // const handleRemoveItemAction = (action: SchedulerItemRemoveItemAction) => {
+  //     let newRemoveItem;
+  //     switch(action.type) {
+  //         case REMOVE_ITEM_ACTION.set:
+  //             newRemoveItem = action.payload;
+  //             break;
+  //         case REMOVE_ITEM_ACTION.reset:
+  //             newRemoveItem = null;
+  //             break;
+  //         case REMOVE_ITEM_ACTION.complete:
+  //             if(config.onDataAction && removeItem) {
+  //                 config.onDataAction.call(undefined,{
+  //                     type: DATA_ACTION.remove,
+  //                     series: config.series,
+  //                     dataItem: removeItem
+  //                 });
+  //             }
+  //             newRemoveItem = null;
+  //             break;
+  //         default:
+  //             newRemoveItem = removeItem;
+  //             break;
+  //     }
+  //     setRemoveItem(newRemoveItem);
+  // };
+  // return [removeItem, setRemoveItem, handleRemoveItemAction];
+  return [];
+};

package/dist/esm/items/hooks/use-resize-item.d.ts

@@ -0,0 +1,39 @@
+import { DataItem } from '../../models';
+import { SchedulerEditItemAll } from '../SchedulerEditItem';
+/**
+ * Represents the available `action` types for the `SchedulerItemResizeItemAction` objects.
+ *
+ * The available types are:
+ * - `RESIZE_ITEM_SET`
+ * - `RESIZE_ITEM_START`
+ * - `RESIZE_ITEM_START_DRAG`
+ * - `RESIZE_ITEM_START_DRAG_SELECTED`
+ * - `RESIZE_ITEM_END_DRAG`
+ * - `RESIZE_ITEM_END_DRAG_SELECTED`
+ * - `RESIZE_ITEM_COMPLETE`
+ * - `RESIZE_ITEM_COMPLETE_OCCURRENCE`
+ * - `RESIZE_ITEM_COMPLETE_SERIES`
+ * - `RESIZE_ITEM_RESET`
+ */
+export declare enum RESIZE_ITEM_ACTION {
+    set = "RESIZE_ITEM_SET",
+    start = "RESIZE_ITEM_START",
+    startDrag = "RESIZE_ITEM_START_DRAG",
+    startDragSelected = "RESIZE_ITEM_START_DRAG_SELECTED",
+    endDrag = "RESIZE_ITEM_END_DRAG",
+    endDragSelected = "RESIZE_ITEM_END_DRAG_SELECTED",
+    complete = "RESIZE_ITEM_COMPLETE",
+    completeOccurrence = "RESIZE_ITEM_COMPLETE_OCCURRENCE",
+    completeSeries = "RESIZE_ITEM_COMPLETE_SERIES",
+    reset = "RESIZE_ITEM_RESET"
+}
+/**
+ * Represents the object passed to the `resize-item` reducer.
+ */
+export interface SchedulerItemResizeItemAction {
+    type: RESIZE_ITEM_ACTION;
+    payload?: DataItem;
+    event?: any;
+}
+/** @hidden */
+export declare const useResizeItem: (this: SchedulerEditItemAll, action: SchedulerItemResizeItemAction, event: any) => void;