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

package/dist/esm/hooks/use-slots-selection.js

@@ -0,0 +1,60 @@
+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));
+};
+/**
+ * Represents the available `action` types for the `SchedulerSlotsSelectAction` objects.
+ *
+ * The available actions are:
+ * - `SLOTS_SELECT_SELECT`
+ * - `SLOTS_SELECT_RESET`
+ * - `SLOTS_SELECT_ADD`
+ */
+
+
+export var SLOTS_SELECT_ACTION;
+
+(function (SLOTS_SELECT_ACTION) {
+  SLOTS_SELECT_ACTION["select"] = "SLOTS_SELECT_SELECT";
+  SLOTS_SELECT_ACTION["reset"] = "SLOTS_SELECT_RESET";
+  SLOTS_SELECT_ACTION["add"] = "SLOTS_SELECT_ADD";
+})(SLOTS_SELECT_ACTION || (SLOTS_SELECT_ACTION = {}));
+/** @hidden */
+
+
+export var dispatchSelectedSlots = function dispatchSelectedSlots(action) {
+  switch (action.type) {
+    case SLOTS_SELECT_ACTION.select:
+      if (!action.slot) {
+        return;
+      }
+
+      this.bv.selectedSlots = [action.slot];
+      break;
+
+    case SLOTS_SELECT_ACTION.reset:
+      this.bv.selectedSlots = [];
+      break;
+
+    case SLOTS_SELECT_ACTION.add:
+      if (!action.slot) {
+        return;
+      }
+
+      if (!this.bv.selectedSlots.some(function (ss) {
+        return ss === action.slot;
+      })) {
+        this.bv.selectedSlots = __spreadArray(__spreadArray([], this.bv.selectedSlots, true), [action.slot], false);
+      }
+
+      break;
+
+    default:
+      break;
+  }
+};

package/dist/esm/hooks/useAsyncMouseEnterLeave.d.ts

@@ -0,0 +1,10 @@
+/** @hidden */
+export interface AsyncMouseEnterLeaveArgs {
+    handleMouseEnter: (event: any) => void;
+    handleMouseLeave: (event: any) => void;
+}
+/** @hidden */
+export declare const useAsyncMouseEnterLeave: ({ handleMouseEnter, handleMouseLeave }: AsyncMouseEnterLeaveArgs) => {
+    onMouseEnter: (event: any) => void;
+    onMouseLeave: (event: any) => void;
+};

package/dist/esm/hooks/useAsyncMouseEnterLeave.js

@@ -0,0 +1,29 @@
+/** @hidden */
+export var useAsyncMouseEnterLeave = function useAsyncMouseEnterLeave(_a) {
+  var handleMouseEnter = _a.handleMouseEnter,
+      handleMouseLeave = _a.handleMouseLeave;
+  var tick = {}.current;
+
+  var nextTick = function nextTick(f) {
+    clearTimeout(tick);
+    tick = window.setTimeout(function () {
+      return f();
+    });
+  };
+
+  var onMouseEnter = function onMouseEnter(event) {
+    clearTimeout(tick);
+    handleMouseEnter(event);
+  };
+
+  var onMouseLeave = function onMouseLeave(event) {
+    nextTick(function () {
+      return handleMouseLeave(event);
+    });
+  };
+
+  return {
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave
+  };
+};

package/dist/esm/hooks/useCellSync.d.ts

@@ -0,0 +1,9 @@
+/** @hidden */
+export interface CellSyncArgs {
+    element: any;
+    selector: string;
+    attribute?: string;
+    explicitDepth: boolean;
+}
+/** @hidden */
+export declare const useCellSync: (args: CellSyncArgs) => void;

package/dist/esm/hooks/useCellSync.js

@@ -0,0 +1,51 @@
+import { getPadding } from '../views/common/utils.js';
+import { getBorders } from '../views/common/utils.js';
+/** @hidden */
+
+export var useCellSync = function useCellSync(args) {
+  var element = args.element;
+
+  var syncWidth = function syncWidth() {
+    if (!element) {
+      return;
+    }
+
+    var widest = [];
+    var biggestPadding = [];
+    var biggestBorder = [];
+    var elements = element.querySelectorAll(args.selector);
+    elements.forEach(function (el) {
+      var width = el.getBoundingClientRect().width;
+      var level = args.explicitDepth && args.attribute !== undefined ? el.getAttribute(args.attribute) : 0;
+      var padding = getPadding(el, true);
+      var border = getBorders(el, true);
+
+      if (level === null) {
+        return;
+      }
+
+      if (!biggestBorder[level] || border > biggestBorder[level]) {
+        biggestBorder[level] = border;
+      }
+
+      if (!biggestPadding[level] || padding > biggestPadding[level]) {
+        biggestPadding[level] = padding;
+      }
+
+      if (!widest[level] || width > widest[level]) {
+        widest[level] = width;
+      }
+    });
+    elements.forEach(function (el) {
+      var level = args.explicitDepth ? el.getAttribute(args.attribute) : 0;
+
+      if (level === null) {
+        return;
+      }
+
+      el.style.minWidth = "".concat(widest[level] - biggestPadding[level] - biggestBorder[level], "px");
+    });
+  };
+
+  syncWidth();
+};

package/dist/esm/hooks/useEditable.d.ts

@@ -0,0 +1,3 @@
+import { EditableProp } from '../models';
+/** @hidden */
+export declare const useEditable: (editable?: EditableProp | boolean) => EditableProp;

package/dist/esm/hooks/useEditable.js

@@ -0,0 +1,19 @@
+/** @hidden */
+export var useEditable = function useEditable(editable) {
+  var context = {};
+  var settings = editable !== undefined ? editable : context.editable || false;
+  var edit = settings === true || settings !== undefined && settings !== false && settings.edit === true;
+  var resize = settings === true || settings !== undefined && settings !== false && settings.resize === true;
+  var remove = settings === true || settings !== undefined && settings !== false && settings.remove === true;
+  var drag = settings === true || settings !== undefined && settings !== false && settings.drag === true;
+  var add = settings === true || settings !== undefined && settings !== false && settings.add === true;
+  var select = settings === true || settings !== undefined && settings !== false && settings.select === true;
+  return {
+    add: add,
+    edit: edit,
+    drag: drag,
+    remove: remove,
+    resize: resize,
+    select: select
+  };
+};

package/dist/esm/hooks/usePropOrState.d.ts

@@ -0,0 +1,2 @@
+/** @hidden */
+export declare const usePropOrState: <S extends unknown>(prop?: any, defaultValue?: any) => [S, any];

package/dist/esm/hooks/usePropOrState.js

@@ -0,0 +1,8 @@
+import { noop } from '@progress/kendo-vue-common';
+/** @hidden */
+
+export var usePropOrState = function usePropOrState(prop, defaultValue) {
+  var state = defaultValue[0],
+      setState = defaultValue[1];
+  return prop !== undefined ? [prop, noop] : [state, setState];
+};

package/dist/esm/hooks/useRowSync.d.ts

@@ -0,0 +1,10 @@
+/** @hidden */
+export interface RowSyncArgs {
+    element: any;
+    selector: string;
+    horizontalAttribute: string;
+    verticalAttribute: string;
+    applyTo: string;
+}
+/** @hidden */
+export declare const useRowSync: (args: RowSyncArgs, _inputs?: any[]) => void;

package/dist/esm/hooks/useRowSync.js

@@ -0,0 +1,55 @@
+import { getPadding, setRect } from '../views/common/utils.js';
+import { BORDER_WIDTH } from '../constants.js';
+
+var stripSelectorSymbol = function stripSelectorSymbol(str) {
+  return str.slice(1, str.length);
+};
+/** @hidden */
+
+
+export var useRowSync = function useRowSync(args, _inputs) {
+  var element = args.element;
+
+  var syncHeight = function syncHeight() {
+    if (!element || !element.current) {
+      return;
+    }
+
+    var highest = [[]];
+    var elements = Array.from(element.current.querySelectorAll(args.selector)).filter(function (el) {
+      return !el.classList.contains(stripSelectorSymbol(args.applyTo));
+    });
+    elements.forEach(function (el) {
+      var height = el.clientHeight;
+      var x = el.getAttribute(args.horizontalAttribute);
+      var y = el.getAttribute(args.verticalAttribute);
+
+      if (x === null || y === null) {
+        return;
+      }
+
+      if (!highest[x]) {
+        highest[x] = [];
+      }
+
+      if (!highest[x][y] || height > highest[x][y]) {
+        highest[x][y] = height - BORDER_WIDTH;
+      }
+    });
+    var targets = Array.from(element.current.querySelectorAll(args.applyTo));
+    targets.forEach(function (el) {
+      var x = el.getAttribute(args.horizontalAttribute);
+      var y = el.getAttribute(args.verticalAttribute);
+
+      if (x === null || y === null) {
+        return;
+      }
+
+      var slotPadding = getPadding(el);
+      var height = highest[x][y] - slotPadding;
+      setRect(el, {
+        height: height
+      }, true);
+    });
+  };
+};

package/dist/esm/hooks/useSchedulerSlot.d.ts

@@ -0,0 +1,6 @@
+import { SchedulerSlotProps } from '../main';
+/** @hidden */
+export declare const useSchedulerSlot: (_props: SchedulerSlotProps) => {
+    slot: any;
+    element: any;
+};

package/dist/esm/hooks/useSchedulerSlot.js

@@ -0,0 +1,7 @@
+// import { useSchedulerViewSlotsContext } from '../context.js';
+// import { COLLECTION_ACTION } from '@progress/kendo-vue-common';
+
+/** @hidden */
+export var useSchedulerSlot = function useSchedulerSlot(_props) {
+  return [];
+};

package/dist/esm/hooks/useSlotExpand.d.ts

@@ -0,0 +1,3 @@
+import { SchedulerSlotExpandableConfig } from '../slots/SchedulerViewSlot';
+/** @hidden */
+export declare const useSlotExpand: (slot: any, _scheduler: any, config?: boolean | SchedulerSlotExpandableConfig) => void;

package/dist/esm/hooks/useSlotExpand.js

@@ -0,0 +1,70 @@
+import { getPadding, setRect, getRect } from '../views/common/utils.js';
+import { BORDER_WIDTH } from '../constants.js';
+import { isObject } from '@progress/kendo-vue-common'; // import { useSchedulerElementContext } from '../context.js';
+
+/** @hidden */
+
+export var useSlotExpand = function useSlotExpand(slot, _scheduler, config) {
+  var timeout = undefined;
+  var initialHeight = 0;
+
+  var getInitialHeight = function getInitialHeight() {
+    if (!slot) {
+      return;
+    }
+
+    var element = slot.$el;
+
+    if (!element) {
+      return;
+    }
+
+    element.style.minHeight = null;
+    initialHeight = element.clientHeight;
+  };
+
+  var expand = function expand() {
+    if (!config || !slot) {
+      return;
+    }
+
+    var element = slot.$el;
+    var props = slot.$props;
+
+    if (!element || !slot.bv.items.length) {
+      return;
+    }
+
+    var slotPadding = getPadding(element);
+    var highest = 0;
+    var existing = props.items.filter(function (i) {
+      return i.refTo;
+    });
+    existing.forEach(function (item) {
+      var currentItem = slot.bv.items.find(function (i) {
+        return i.uid === item.uid;
+      });
+
+      if (!currentItem) {
+        return;
+      }
+
+      var height = getRect(currentItem.getElement()).height;
+      highest += height;
+    });
+    var minHeight = existing.length * BORDER_WIDTH * 2 + highest - (slotPadding || 0) + (isObject(config) && config.offsetTop ? config.offsetTop : 0) + (isObject(config) && config.offsetBottom ? config.offsetBottom : 0);
+
+    if (existing.length) {
+      if (minHeight > initialHeight - slotPadding) {
+        setRect(element, {
+          height: minHeight
+        }, true);
+      }
+    } else if (element) {
+      element.style.minHeight = null;
+    }
+  };
+
+  getInitialHeight();
+  expand();
+};

package/dist/esm/hooks/useWorkHours.d.ts

@@ -0,0 +1,2 @@
+/** @hidden */
+export declare const useWorkHours: (_showWorkHours?: boolean, _defaultShowWorkHours?: boolean) => any[];

package/dist/esm/hooks/useWorkHours.js

@@ -0,0 +1,4 @@
+/** @hidden */
+export var useWorkHours = function useWorkHours(_showWorkHours, _defaultShowWorkHours) {
+  return [];
+};