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

package/dist/npm/hooks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './usePropOrState';
+export * from './useCellSync';
+export * from './useRowSync';
+export * from './useAsyncMouseEnterLeave';
+export * from './useEditable';
+export * from './useSlotExpand';
+export * from './useWorkHours';
+export * from './useSchedulerItem';
+export * from './use-items-focus';
+export * from './use-slots-focus';

package/dist/npm/hooks/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./usePropOrState"), exports);
+__exportStar(require("./useCellSync"), exports);
+__exportStar(require("./useRowSync"), exports);
+__exportStar(require("./useAsyncMouseEnterLeave"), exports);
+__exportStar(require("./useEditable"), exports);
+__exportStar(require("./useSlotExpand"), exports);
+__exportStar(require("./useWorkHours"), exports);
+__exportStar(require("./useSchedulerItem"), exports);
+__exportStar(require("./use-items-focus"), exports);
+__exportStar(require("./use-slots-focus"), exports);

package/dist/npm/hooks/use-items-focus.d.ts

@@ -0,0 +1,22 @@
+import { BaseViewAll } from '../components/BaseView';
+/**
+ * Represents the available `action` types for the `SchedulerItemsFocusAction` objects.
+ *
+ * The available types are:
+ * - `ITEMS_FOCUS_NEXT`
+ * - `ITEMS_FOCUS_PREV`
+ */
+export declare enum ITEMS_FOCUS_ACTION {
+    next = "ITEMS_FOCUS_NEXT",
+    prev = "ITEMS_FOCUS_PREV"
+}
+/**
+ * Represents the object passed to the `items-focus` reducer.
+ */
+export interface SchedulerItemsFocusAction {
+    type: ITEMS_FOCUS_ACTION;
+    item?: any;
+    ignoreIsAllDay?: boolean;
+}
+/** @hidden */
+export declare const dispatchFocusedItems: (this: BaseViewAll, action: SchedulerItemsFocusAction, event: any) => void;

package/dist/npm/hooks/use-items-focus.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dispatchFocusedItems = exports.ITEMS_FOCUS_ACTION = void 0;
+
+var utils_1 = require("../utils");
+/**
+ * Represents the available `action` types for the `SchedulerItemsFocusAction` objects.
+ *
+ * The available types are:
+ * - `ITEMS_FOCUS_NEXT`
+ * - `ITEMS_FOCUS_PREV`
+ */
+
+
+var ITEMS_FOCUS_ACTION;
+
+(function (ITEMS_FOCUS_ACTION) {
+  ITEMS_FOCUS_ACTION["next"] = "ITEMS_FOCUS_NEXT";
+  ITEMS_FOCUS_ACTION["prev"] = "ITEMS_FOCUS_PREV";
+})(ITEMS_FOCUS_ACTION = exports.ITEMS_FOCUS_ACTION || (exports.ITEMS_FOCUS_ACTION = {}));
+/** @hidden */
+
+
+exports.dispatchFocusedItems = function (action, event) {
+  switch (action.type) {
+    case ITEMS_FOCUS_ACTION.next:
+      {
+        if (!action.item || !action.item.current || !this.items) {
+          return;
+        }
+
+        var next = utils_1.findNextItem(action.item, this.items, action.ignoreIsAllDay, false);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    case ITEMS_FOCUS_ACTION.prev:
+      {
+        if (!action.item || !action.item.current || !this.items) {
+          return;
+        }
+
+        var next = utils_1.findNextItem(action.item, this.items, action.ignoreIsAllDay, true);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    default:
+      break;
+  }
+};

package/dist/npm/hooks/use-items-selection.d.ts

@@ -0,0 +1,30 @@
+import { BaseViewAll } from '../components/BaseView';
+/**
+ * Represents the available `action` types for the `SchedulerItemsSelectAction` objects.
+ *
+ * The available types are:
+ * - 'ITEMS_SELECT_SELECT`
+ * - 'ITEMS_SELECT_SELECT_NEXT`
+ * - 'ITEMS_SELECT_SELECT_PREV`
+ * - 'ITEMS_SELECT_RESET`
+ * - 'ITEMS_SELECT_ADD`
+ * - 'ITEMS_SELECT_REMOVE`
+ */
+export declare enum ITEMS_SELECT_ACTION {
+    select = "ITEMS_SELECT_SELECT",
+    selectNext = "ITEMS_SELECT_SELECT_NEXT",
+    selectPrev = "ITEMS_SELECT_SELECT_PREV",
+    reset = "ITEMS_SELECT_RESET",
+    add = "ITEMS_SELECT_ADD",
+    remove = "ITEMS_SELECT_REMOVE"
+}
+/**
+ * Represents the object passed to the `items-select` reducer.
+ */
+export interface SchedulerItemsSelectAction {
+    type: ITEMS_SELECT_ACTION;
+    item?: any;
+    ignoreIsAllDay?: boolean;
+}
+/** @hidden */
+export declare const dispatchSelectedItems: (this: BaseViewAll, action: SchedulerItemsSelectAction, event: any) => void;

package/dist/npm/hooks/use-items-selection.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var __spreadArrays = undefined && undefined.__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;
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dispatchSelectedItems = exports.ITEMS_SELECT_ACTION = void 0;
+
+var utils_1 = require("../utils");
+/**
+ * Represents the available `action` types for the `SchedulerItemsSelectAction` objects.
+ *
+ * The available types are:
+ * - 'ITEMS_SELECT_SELECT`
+ * - 'ITEMS_SELECT_SELECT_NEXT`
+ * - 'ITEMS_SELECT_SELECT_PREV`
+ * - 'ITEMS_SELECT_RESET`
+ * - 'ITEMS_SELECT_ADD`
+ * - 'ITEMS_SELECT_REMOVE`
+ */
+
+
+var ITEMS_SELECT_ACTION;
+
+(function (ITEMS_SELECT_ACTION) {
+  ITEMS_SELECT_ACTION["select"] = "ITEMS_SELECT_SELECT";
+  ITEMS_SELECT_ACTION["selectNext"] = "ITEMS_SELECT_SELECT_NEXT";
+  ITEMS_SELECT_ACTION["selectPrev"] = "ITEMS_SELECT_SELECT_PREV";
+  ITEMS_SELECT_ACTION["reset"] = "ITEMS_SELECT_RESET";
+  ITEMS_SELECT_ACTION["add"] = "ITEMS_SELECT_ADD";
+  ITEMS_SELECT_ACTION["remove"] = "ITEMS_SELECT_REMOVE";
+})(ITEMS_SELECT_ACTION = exports.ITEMS_SELECT_ACTION || (exports.ITEMS_SELECT_ACTION = {}));
+/** @hidden */
+
+
+exports.dispatchSelectedItems = function (action, event) {
+  switch (action.type) {
+    case ITEMS_SELECT_ACTION.select:
+      if (!action.item) {
+        return;
+      }
+
+      this.selectedItems = [action.item];
+      break;
+
+    case ITEMS_SELECT_ACTION.selectNext:
+      {
+        if (!action.item || !action.item.current || !this.items) {
+          return;
+        }
+
+        var next = utils_1.findNextItem(action.item, this.items, action.ignoreIsAllDay, false);
+
+        if (next) {
+          event.preventDefault();
+          this.selectedItems = [next];
+        }
+
+        break;
+      }
+
+    case ITEMS_SELECT_ACTION.selectPrev:
+      {
+        if (!action.item || !action.item.current || !this.items) {
+          return;
+        }
+
+        var next = utils_1.findNextItem(action.item, this.items, action.ignoreIsAllDay, true);
+
+        if (next) {
+          event.preventDefault();
+          this.selectedItems = [next];
+        }
+
+        break;
+      }
+
+    case ITEMS_SELECT_ACTION.reset:
+      this.selectedItems = [];
+      break;
+
+    case ITEMS_SELECT_ACTION.add:
+      if (!action.item) {
+        return;
+      }
+
+      if (!this.selectedItems.some(function (si) {
+        return si === action.item;
+      })) {
+        this.selectedItems = __spreadArrays(this.selectedItems, [action.item]);
+      }
+
+      break;
+
+    case ITEMS_SELECT_ACTION.remove:
+      if (!action.item) {
+        return;
+      }
+
+      this.selectedItems = __spreadArrays(this.selectedItems.filter(function (si) {
+        return si !== action.item;
+      }));
+      break;
+
+    default:
+      break;
+  }
+};

package/dist/npm/hooks/use-slots-focus.d.ts

@@ -0,0 +1,33 @@
+import { BaseViewAll } from '../components/BaseView';
+/**
+ * Represents the available `action` types for the `SchedulerSlotsFocusAction` objects.
+ *
+ * The available actions are:
+ * - `SLOT_FOCUS_UP`
+ * - `SLOT_FOCUS_DOWN`
+ * - `SLOT_FOCUS_LEFT`
+ * - `SLOT_FOCUS_RIGHT`
+ */
+export declare enum SLOTS_FOCUS_ACTION {
+    up = "SLOT_FOCUS_UP",
+    down = "SLOT_FOCUS_DOWN",
+    left = "SLOT_FOCUS_LEFT",
+    right = "SLOT_FOCUS_RIGHT"
+}
+/**
+ * Represents the object passed to the `slots-focus` reducer.
+ */
+export interface SchedulerSlotsFocusAction {
+    type: SLOTS_FOCUS_ACTION;
+    slot: any;
+}
+/** @hidden */
+export declare const dispatchFocusedSlots: (this: BaseViewAll, action: SchedulerSlotsFocusAction, event: any) => void;
+/** @hidden */
+export declare const findUpSlot: (target: any, all: any[]) => any | undefined;
+/** @hidden */
+export declare const findLeftSlot: (target: any, all: any[]) => any | undefined;
+/** @hidden */
+export declare const findRightSlot: (target: any, all: any[]) => any | undefined;
+/** @hidden */
+export declare const findDownSlot: (target: any, all: any[]) => any | undefined;

package/dist/npm/hooks/use-slots-focus.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findDownSlot = exports.findRightSlot = exports.findLeftSlot = exports.findUpSlot = exports.dispatchFocusedSlots = exports.SLOTS_FOCUS_ACTION = void 0;
+/**
+ * Represents the available `action` types for the `SchedulerSlotsFocusAction` objects.
+ *
+ * The available actions are:
+ * - `SLOT_FOCUS_UP`
+ * - `SLOT_FOCUS_DOWN`
+ * - `SLOT_FOCUS_LEFT`
+ * - `SLOT_FOCUS_RIGHT`
+ */
+
+var SLOTS_FOCUS_ACTION;
+
+(function (SLOTS_FOCUS_ACTION) {
+  SLOTS_FOCUS_ACTION["up"] = "SLOT_FOCUS_UP";
+  SLOTS_FOCUS_ACTION["down"] = "SLOT_FOCUS_DOWN";
+  SLOTS_FOCUS_ACTION["left"] = "SLOT_FOCUS_LEFT";
+  SLOTS_FOCUS_ACTION["right"] = "SLOT_FOCUS_RIGHT";
+})(SLOTS_FOCUS_ACTION = exports.SLOTS_FOCUS_ACTION || (exports.SLOTS_FOCUS_ACTION = {}));
+/** @hidden */
+
+
+exports.dispatchFocusedSlots = function (action, event) {
+  switch (action.type) {
+    case SLOTS_FOCUS_ACTION.up:
+      {
+        if (!action.slot.current || !this.slots) {
+          return;
+        }
+
+        var next = exports.findUpSlot(action.slot, this.slots);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.down:
+      {
+        if (!action.slot || !this.slots) {
+          return;
+        }
+
+        var next = exports.findDownSlot(action.slot, this.slots);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.left:
+      {
+        if (!action.slot || !this.slots) {
+          return;
+        }
+
+        var next = exports.findLeftSlot(action.slot, this.slots);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.right:
+      {
+        if (!action.slot || !this.slots) {
+          return;
+        }
+
+        var next = exports.findRightSlot(action.slot, this.slots);
+
+        if (next && next.current && next.current.element) {
+          event.preventDefault();
+          next.current.element.focus();
+        }
+
+        break;
+      }
+
+    default:
+      break;
+  }
+};
+/** @hidden */
+
+
+exports.findUpSlot = function (target, all) {
+  return all.find(function (slot) {
+    return slot.current !== null && target.current !== null && slot.current.props.row === target.current.props.row - 1 && slot.current.props.col === target.current.props.col;
+  });
+};
+/** @hidden */
+
+
+exports.findLeftSlot = function (target, all) {
+  return all.find(function (slot) {
+    return slot.current !== null && target.current !== null && slot.current.props.row === target.current.props.row && slot.current.props.col === target.current.props.col - 1;
+  });
+};
+/** @hidden */
+
+
+exports.findRightSlot = function (target, all) {
+  return all.find(function (slot) {
+    return slot.current !== null && target.current !== null && slot.current.props.row === target.current.props.row && slot.current.props.col === target.current.props.col + 1;
+  });
+};
+/** @hidden */
+
+
+exports.findDownSlot = function (target, all) {
+  return all.find(function (slot) {
+    return slot.current !== null && target.current !== null && slot.current.props.row === target.current.props.row + 1 && slot.current.props.col === target.current.props.col;
+  });
+};

package/dist/npm/hooks/use-slots-selection.d.ts

@@ -0,0 +1,23 @@
+import { BaseViewAll } from '../components/BaseView';
+/**
+ * Represents the available `action` types for the `SchedulerSlotsSelectAction` objects.
+ *
+ * The available actions are:
+ * - `SLOTS_SELECT_SELECT`
+ * - `SLOTS_SELECT_RESET`
+ * - `SLOTS_SELECT_ADD`
+ */
+export declare enum SLOTS_SELECT_ACTION {
+    select = "SLOTS_SELECT_SELECT",
+    reset = "SLOTS_SELECT_RESET",
+    add = "SLOTS_SELECT_ADD"
+}
+/**
+ * Represents the object passed to the `slots-select` reducer.
+ */
+export interface SchedulerSlotsSelectAction {
+    type: SLOTS_SELECT_ACTION;
+    slot?: any;
+}
+/** @hidden */
+export declare const dispatchSelectedSlots: (this: BaseViewAll, action: SchedulerSlotsSelectAction) => void;

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

@@ -0,0 +1,70 @@
+"use strict";
+
+var __spreadArrays = undefined && undefined.__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;
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dispatchSelectedSlots = exports.SLOTS_SELECT_ACTION = void 0;
+/**
+ * Represents the available `action` types for the `SchedulerSlotsSelectAction` objects.
+ *
+ * The available actions are:
+ * - `SLOTS_SELECT_SELECT`
+ * - `SLOTS_SELECT_RESET`
+ * - `SLOTS_SELECT_ADD`
+ */
+
+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 = exports.SLOTS_SELECT_ACTION || (exports.SLOTS_SELECT_ACTION = {}));
+/** @hidden */
+
+
+exports.dispatchSelectedSlots = function (action) {
+  switch (action.type) {
+    case SLOTS_SELECT_ACTION.select:
+      if (!action.slot) {
+        return;
+      }
+
+      this.selectedSlots([action.slot]);
+      break;
+
+    case SLOTS_SELECT_ACTION.reset:
+      this.selectedSlots([]);
+      break;
+
+    case SLOTS_SELECT_ACTION.add:
+      if (!action.slot) {
+        return;
+      }
+
+      if (!this.selectedSlots.some(function (ss) {
+        return ss === action.slot;
+      })) {
+        this.selectedSlots(__spreadArrays(this.selectedSlots, [action.slot]));
+      }
+
+      break;
+
+    default:
+      break;
+  }
+};

package/dist/npm/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/npm/hooks/useAsyncMouseEnterLeave.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAsyncMouseEnterLeave = void 0;
+/** @hidden */
+
+exports.useAsyncMouseEnterLeave = function (_a) {
+  var handleMouseEnter = _a.handleMouseEnter,
+      handleMouseLeave = _a.handleMouseLeave;
+  var tick = {}.current; // React.useRef(0);
+
+  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/npm/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/npm/hooks/useCellSync.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCellSync = void 0;
+
+var utils_1 = require("../views/common/utils");
+
+var utils_2 = require("../views/common/utils");
+/** @hidden */
+
+
+exports.useCellSync = function (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 = utils_1.getPadding(el, true);
+      var border = utils_2.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 = widest[level] - biggestPadding[level] - biggestBorder[level] + "px";
+    });
+  };
+
+  syncWidth();
+};

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

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

package/dist/npm/hooks/useEditable.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEditable = void 0; // import { SchedulerPropsContext } from '../context/SchedulerContext';
+
+/** @hidden */
+
+exports.useEditable = function (editable) {
+  var context = {}; // React.useContext(SchedulerPropsContext);
+
+  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/npm/hooks/usePropOrState.d.ts

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