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

package/dist/npm/hooks/usePropOrState.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePropOrState = void 0;
+
+var kendo_vue_common_1 = require("@progress/kendo-vue-common");
+/** @hidden */
+
+
+exports.usePropOrState = function (prop, defaultValue) {
+  var state = defaultValue[0],
+      setState = defaultValue[1];
+  return prop !== undefined ? [prop, kendo_vue_common_1.noop] : [state, setState];
+};

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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRowSync = void 0;
+
+var utils_1 = require("../views/common/utils");
+
+var constants_1 = require("../constants");
+
+var stripSelectorSymbol = function stripSelectorSymbol(str) {
+  return str.slice(1, str.length);
+};
+/** @hidden */
+
+
+exports.useRowSync = function (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 - constants_1.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 = utils_1.getPadding(el);
+      var height = highest[x][y] - slotPadding;
+      utils_1.setRect(el, {
+        height: height
+      }, true);
+    });
+  }; //  React.useEffect(syncHeight, inputs);
+
+};

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

@@ -0,0 +1,6 @@
+import { SchedulerItemProps } from '../main';
+/** @hidden */
+export declare const useSchedulerItem: (_props: SchedulerItemProps, _refTo?: any) => {
+    item: any;
+    element: any;
+};

package/dist/npm/hooks/useSchedulerItem.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSchedulerItem = void 0; // import { useSchedulerViewItemsContext } from '../context';
+// import { COLLECTION_ACTION } from '@progress/kendo-vue-common';
+
+/** @hidden */
+
+exports.useSchedulerItem = function (_props, _refTo) {
+  // const { refTo, itemRef } = props;
+  // const item = React.useRef<SchedulerItemHandle>(null);
+  // const element = React.useRef<HTMLDivElement>(null);
+  // const [, dispatchItems] = useSchedulerViewItemsContext();
+  // React.useImperativeHandle(item, () => ({ element: element.current, props }));
+  // React.useImperativeHandle(ref, () => item.current);
+  // React.useImperativeHandle(refTo, () => item.current);
+  // React.useImperativeHandle(itemRef, () => item.current);
+  // React.useLayoutEffect(
+  //     () => {
+  //         dispatchItems({
+  //             type: COLLECTION_ACTION.add,
+  //             item
+  //         });
+  //         return () => {
+  //             dispatchItems({
+  //                 type: COLLECTION_ACTION.remove,
+  //                 item
+  //             });
+  //         };
+  //     }
+  // );
+  // return {
+  //     item,
+  //     element
+  // };
+  return [];
+};

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

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

package/dist/npm/hooks/useSchedulerSlot.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSchedulerSlot = void 0; // import { useSchedulerViewSlotsContext } from '../context';
+// import { COLLECTION_ACTION } from '@progress/kendo-vue-common';
+
+/** @hidden */
+
+exports.useSchedulerSlot = function (_props, _refTo) {
+  // const { refTo } = props;
+  // const slot = React.useRef<SchedulerSlotHandle>(null);
+  // const element = React.useRef<HTMLDivElement>(null);
+  // const [, dispatchSlots] = useSchedulerViewSlotsContext();
+  // React.useImperativeHandle(slot, () => ({ element: element.current, props }));
+  // React.useImperativeHandle(ref, () => slot.current);
+  // React.useImperativeHandle(refTo, () => slot.current);
+  // React.useEffect(
+  //     () => {
+  //         dispatchSlots({
+  //             type: COLLECTION_ACTION.add,
+  //             item: slot
+  //         });
+  //         return () => {
+  //             dispatchSlots({
+  //                 type: COLLECTION_ACTION.remove,
+  //                 item: slot
+  //             });
+  //         };
+  //     }
+  // );
+  // return {
+  //     slot,
+  //     element
+  // };
+  return [];
+};

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

@@ -0,0 +1,112 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSlotExpand = void 0;
+
+var utils_1 = require("../views/common/utils");
+
+var constants_1 = require("../constants"); // import { useSchedulerElementContext } from '../context';
+
+/** @hidden */
+
+
+exports.useSlotExpand = function (slot, _scheduler, config) {
+  var timeout = undefined;
+  var initialHeight = 0;
+
+  var getInitialHeight = function getInitialHeight() {
+    if (!slot) {
+      return;
+    }
+
+    var element = slot.$el;
+
+    if (!element) {
+      return;
+    }
+
+    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 = utils_1.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 = utils_1.getRect(currentItem.$el).height;
+      highest += height;
+    });
+    var minHeight = existing.length * constants_1.BORDER_WIDTH * 2 + highest - (slotPadding || 0) + ((typeof config === "undefined" ? "undefined" : _typeof(config)) === 'object' && config.offsetTop ? config.offsetTop : 0) + ((typeof config === "undefined" ? "undefined" : _typeof(config)) === 'object' && config.offsetBottom ? config.offsetBottom : 0);
+
+    if (existing.length) {
+      if (minHeight > initialHeight - slotPadding) {
+        utils_1.setRect(element, {
+          height: minHeight
+        }, true);
+      }
+    } else if (element) {
+      element.style.minHeight = null;
+    }
+  }; // , [config, slot]);
+  // const handleResize = React.useCallback(() => {
+  //     if(timeout.current !== undefined) {
+  //         window.cancelAnimationFrame(timeout.current);
+  //     }
+  //     timeout.current = window.requestAnimationFrame(() => {
+  //         expand();
+  //     });
+  // },[expand]);
+
+
+  getInitialHeight();
+  expand(); // // eslint-disable-next-line react-hooks/exhaustive-deps
+  // React.useLayoutEffect(getInitialHeight, []);
+  // // eslint-disable-next-line react-hooks/exhaustive-deps
+  // React.useEffect(expand, [slot, slot.current && slot.current.props, config]);
+  // React.useEffect(
+  //     () => {
+  //         if(!slot.current) {return;}
+  //         const props = slot.current.props;
+  //         const existing = props.items.filter((i) => {
+  //             return i.refTo.current;
+  //         });
+  //         const callbacks = existing.map((item: Item) => {
+  //             if(!item.refTo.current || !item.refTo.current.element) {return;}
+  //             if(!scheduler.current) {return;}
+  //             const observer = new (window as any).ResizeObserver(handleResize);
+  //             observer.observe(item.refTo.current.element);
+  //             return () => {
+  //                 observer.disconnect();
+  //             };
+  //         });
+  //         return () => {
+  //             callbacks.forEach(cb => cb && cb());
+  //         };
+  //     },
+  //     [handleResize, scheduler, slot]);
+};

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

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

package/dist/npm/hooks/useWorkHours.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWorkHours = void 0;
+/** @hidden */
+
+exports.useWorkHours = function (_showWorkHours, _defaultShowWorkHours) {
+  // const [show, setShow] = usePropOrState(showWorkHours, defaultShowWorkHours);
+  // const handleShowWorkHoursChange = React.useCallback(
+  //     () => {
+  //         setShow(!show);
+  //     },
+  //     [show, setShow]);
+  // return [show, handleShowWorkHoursChange];
+  return [];
+};