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

package/dist/esm/editors/ZonedDateTime.d.ts

@@ -0,0 +1,51 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { DatePickerProps, DateTimePickerProps } from '@progress/kendo-vue-dateinputs';
+import { Omit } from '../models/Omit';
+/**
+ * @hidden
+ */
+export declare type ZonedDateTimeProps = Omit<(DatePickerProps | DateTimePickerProps), 'value'> & {
+    as?: any;
+    value?: string | Date;
+    isAllDay: boolean;
+};
+/**
+ * @hidden
+ */
+export interface ZonedDateTimeState {
+}
+/**
+ * @hidden
+ */
+export interface ZonedDateTimeComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface ZonedDateTimeMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface ZonedDateTimeData {
+}
+/**
+ * @hidden
+ */
+export interface ZonedDateTimeAll extends Vue2type, ZonedDateTimeMethods, ZonedDateTimeData, ZonedDateTimeComputed, ZonedDateTimeState {
+}
+/**
+ * @hidden
+ */
+declare let ZonedDateTimeVue2: ComponentOptions<ZonedDateTimeAll, DefaultData<ZonedDateTimeData>, DefaultMethods<ZonedDateTimeAll>, ZonedDateTimeComputed, RecordPropsDefinition<ZonedDateTimeProps>>;
+/**
+ * @hidden
+ */
+declare const ZonedDateTime: DefineComponent<ZonedDateTimeProps, any, ZonedDateTimeData, ZonedDateTimeComputed, ZonedDateTimeMethods, {}, {}, {}, string, ZonedDateTimeProps, ZonedDateTimeProps, {}>;
+export { ZonedDateTime, ZonedDateTimeVue2 };

package/dist/esm/editors/ZonedDateTime.js

@@ -0,0 +1,117 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+var inject = allVue.inject;
+import { DatePicker, DateTimePicker } from '@progress/kendo-vue-dateinputs';
+import { ZonedDate, toLocalDate } from '@progress/kendo-date-math';
+/**
+ * @hidden
+ */
+
+var ZonedDateTimeVue2 = {
+  name: 'KendoZonedDateTime',
+  // @ts-ignore
+  emits: {
+    change: null
+  },
+  props: __assign(__assign({}, DateTimePicker.props), {
+    value: [String, Date],
+    isAllDay: Boolean,
+    as: [String, Function, Object]
+  }),
+  inject: {
+    ks: {
+      default: null
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+
+    var _a = this.$props,
+        Component = _a.as,
+        other = __rest(_a, ["as"]);
+
+    var timezone = this.ks.timezone;
+
+    var dtpProps = __assign(__assign({}, other), {
+      format: this.isAllDay ? 'd' : 'g',
+      value: this.readDateAsLocal(other.value, timezone)
+    });
+
+    var NeededPicker = this.isAllDay ? DatePicker : DateTimePicker;
+    var dtp = h(NeededPicker, __assign({
+      onChange: this.handleChange,
+      on: this.v3 ? undefined : {
+        'change': this.handleChange
+      },
+      attrs: this.v3 ? undefined : dtpProps
+    }, dtpProps));
+    return dtp;
+  },
+  methods: {
+    handleChange: function handleChange(event) {
+      this.$emit('change', {
+        value: this.readDateWithTimezone(event.target.value, this.ks.timezone)
+      });
+    },
+    readDateAsLocal: function readDateAsLocal(value, timezone) {
+      if (value) {
+        return toLocalDate(ZonedDate.fromLocalDate(value, timezone).toUTCDate());
+      }
+
+      return value;
+    },
+    readDateWithTimezone: function readDateWithTimezone(value, timezone) {
+      if (value) {
+        return ZonedDate.fromUTCDate(new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds(), value.getMilliseconds())), timezone).toLocalDate();
+      }
+
+      return value;
+    }
+  }
+};
+/**
+ * @hidden
+ */
+
+var ZonedDateTime = ZonedDateTimeVue2;
+export { ZonedDateTime, ZonedDateTimeVue2 };

package/dist/esm/editors/common.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hidden
+ */
+export declare const labelUserSelect: any;
+/**
+ * @hidden
+ */
+export declare const readDateWithTimezone: (value: any, timezone: string) => Date;
+/**
+ * @hidden
+ */
+export declare const readDateAsLocal: (value: any, timezone?: string) => Date;

package/dist/esm/editors/common.js

@@ -0,0 +1,29 @@
+import { ZonedDate, toLocalDate } from '@progress/kendo-date-math';
+import { toUTCDateTime } from '../utils.js';
+/**
+ * @hidden
+ */
+export var labelUserSelect = {
+    userSelect: 'none',
+    msUserSelect: 'none',
+    MozUserSelect: 'none',
+    WebkitUserSelect: 'none'
+};
+/**
+ * @hidden
+ */
+export var readDateWithTimezone = function (value, timezone) {
+    if (value) {
+        return ZonedDate.fromUTCDate(toUTCDateTime(value), timezone).toLocalDate();
+    }
+    return value;
+};
+/**
+ * @hidden
+ */
+export var readDateAsLocal = function (value, timezone) {
+    if (value) {
+        return toLocalDate(ZonedDate.fromLocalDate(value, timezone).toUTCDate());
+    }
+    return value;
+};

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

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

package/dist/esm/hooks/index.js

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

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

@@ -0,0 +1,23 @@
+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 {
+    current = "ITEMS_FOCUS_CURRENT",
+    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/esm/hooks/use-items-focus.js

@@ -0,0 +1,73 @@
+import { findCurrentItem, findNextItem } from '../utils.js';
+/**
+ * Represents the available `action` types for the `SchedulerItemsFocusAction` objects.
+ *
+ * The available types are:
+ * - `ITEMS_FOCUS_NEXT`
+ * - `ITEMS_FOCUS_PREV`
+ */
+
+export var ITEMS_FOCUS_ACTION;
+
+(function (ITEMS_FOCUS_ACTION) {
+  ITEMS_FOCUS_ACTION["current"] = "ITEMS_FOCUS_CURRENT";
+  ITEMS_FOCUS_ACTION["next"] = "ITEMS_FOCUS_NEXT";
+  ITEMS_FOCUS_ACTION["prev"] = "ITEMS_FOCUS_PREV";
+})(ITEMS_FOCUS_ACTION || (ITEMS_FOCUS_ACTION = {}));
+/** @hidden */
+
+
+export var dispatchFocusedItems = function dispatchFocusedItems(action, event) {
+  switch (action.type) {
+    case ITEMS_FOCUS_ACTION.current:
+      {
+        if (!action.item || !this.bv.items) {
+          return;
+        }
+
+        var next = findCurrentItem(action.item, this.bv.items, action.ignoreIsAllDay);
+
+        if (next && next.element) {
+          event.preventDefault();
+          next.element.focus();
+        }
+
+        break;
+      }
+
+    case ITEMS_FOCUS_ACTION.next:
+      {
+        if (!action.item || !this.bv.items) {
+          return;
+        }
+
+        var next = findNextItem(action.item, this.bv.items, action.ignoreIsAllDay, false);
+
+        if (next && next.element) {
+          event.preventDefault();
+          next.element.focus();
+        }
+
+        break;
+      }
+
+    case ITEMS_FOCUS_ACTION.prev:
+      {
+        if (!action.item || !this.bv.items) {
+          return;
+        }
+
+        var next = findNextItem(action.item, this.bv.items, action.ignoreIsAllDay, true);
+
+        if (next && next.element) {
+          event.preventDefault();
+          next.element.focus();
+        }
+
+        break;
+      }
+
+    default:
+      break;
+  }
+};

package/dist/esm/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/esm/hooks/use-items-selection.js

@@ -0,0 +1,109 @@
+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 { findNextItem } from '../utils.js';
+/**
+ * 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 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 || (ITEMS_SELECT_ACTION = {}));
+/** @hidden */
+
+
+export var dispatchSelectedItems = function dispatchSelectedItems(action, event) {
+  switch (action.type) {
+    case ITEMS_SELECT_ACTION.select:
+      if (!action.item) {
+        return;
+      }
+
+      this.bv.selectedItems = [action.item];
+      break;
+
+    case ITEMS_SELECT_ACTION.selectNext:
+      {
+        if (!action.item || !this.bv.items) {
+          return;
+        }
+
+        var next = findNextItem(action.item, this.bv.items, action.ignoreIsAllDay, false);
+
+        if (next) {
+          event.preventDefault();
+          this.bv.selectedItems = [next];
+        }
+
+        break;
+      }
+
+    case ITEMS_SELECT_ACTION.selectPrev:
+      {
+        if (!action.item || !this.bv.items) {
+          return;
+        }
+
+        var next = findNextItem(action.item, this.bv.items, action.ignoreIsAllDay, true);
+
+        if (next) {
+          event.preventDefault();
+          this.bv.selectedItems = [next];
+        }
+
+        break;
+      }
+
+    case ITEMS_SELECT_ACTION.reset:
+      this.bv.selectedItems = [];
+      break;
+
+    case ITEMS_SELECT_ACTION.add:
+      if (!action.item) {
+        return;
+      }
+
+      if (!this.bv.selectedItems.some(function (si) {
+        return si === action.item;
+      })) {
+        this.bv.selectedItems = __spreadArray(__spreadArray([], this.bv.selectedItems, true), [action.item], false);
+      }
+
+      break;
+
+    case ITEMS_SELECT_ACTION.remove:
+      if (!action.item) {
+        return;
+      }
+
+      this.bv.selectedItems = __spreadArray([], this.bv.selectedItems.filter(function (si) {
+        return si !== action.item;
+      }), true);
+      break;
+
+    default:
+      break;
+  }
+};

package/dist/esm/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/esm/hooks/use-slots-focus.js

@@ -0,0 +1,118 @@
+/**
+ * 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 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 || (SLOTS_FOCUS_ACTION = {}));
+/** @hidden */
+
+
+export var dispatchFocusedSlots = function dispatchFocusedSlots(action, event) {
+  switch (action.type) {
+    case SLOTS_FOCUS_ACTION.up:
+      {
+        if (!action.slot || !this.bv.slots) {
+          return;
+        }
+
+        var next = findUpSlot(action.slot, this.bv.slots);
+
+        if (next && next.$el) {
+          event.preventDefault();
+          next.$el.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.down:
+      {
+        if (!action.slot || !this.bv.slots) {
+          return;
+        }
+
+        var next = findDownSlot(action.slot, this.bv.slots);
+
+        if (next && next.$el) {
+          event.preventDefault();
+          next.$el.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.left:
+      {
+        if (!action.slot || !this.bv.slots) {
+          return;
+        }
+
+        var next = findLeftSlot(action.slot, this.bv.slots);
+
+        if (next && next.$el) {
+          event.preventDefault();
+          next.$el.focus();
+        }
+
+        break;
+      }
+
+    case SLOTS_FOCUS_ACTION.right:
+      {
+        if (!action.slot || !this.bv.slots) {
+          return;
+        }
+
+        var next = findRightSlot(action.slot, this.bv.slots);
+
+        if (next && next.$el) {
+          event.preventDefault();
+          next.$el.focus();
+        }
+
+        break;
+      }
+
+    default:
+      break;
+  }
+};
+/** @hidden */
+
+export var findUpSlot = function findUpSlot(target, all) {
+  return all.find(function (slot) {
+    return slot !== null && target !== null && slot.$props.row === target.$props.row - 1 && slot.$props.col === target.$props.col;
+  });
+};
+/** @hidden */
+
+export var findLeftSlot = function findLeftSlot(target, all) {
+  return all.find(function (slot) {
+    return slot !== null && target !== null && slot.$props.row === target.$props.row && slot.$props.col === target.$props.col - 1;
+  });
+};
+/** @hidden */
+
+export var findRightSlot = function findRightSlot(target, all) {
+  return all.find(function (slot) {
+    return slot !== null && target !== null && slot.$props.row === target.$props.row && slot.$props.col === target.$props.col + 1;
+  });
+};
+/** @hidden */
+
+export var findDownSlot = function findDownSlot(target, all) {
+  return all.find(function (slot) {
+    return slot !== null && target !== null && slot.$props.row === target.$props.row + 1 && slot.$props.col === target.$props.col;
+  });
+};

package/dist/esm/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;