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

package/dist/esm/views/agenda/AgendaViewHead.js

@@ -0,0 +1,58 @@
+// @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 { provideLocalizationService } from '@progress/kendo-vue-intl';
+import { messages, dateTitle, timeTitle, eventTitle } from '../../messages.js';
+/**
+ * @hidden
+ */
+
+var AgendaViewHeadVue2 = {
+  name: 'KendoAgendaViewHead',
+  props: {
+    monthSlots: Array,
+    dateHeaderCell: [String, Function, Object]
+  },
+  inject: {
+    ri: {
+      default: null
+    },
+    kendoLocalizationService: {
+      default: null
+    },
+    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 localization = provideLocalizationService(this);
+    return h("div", {
+      "class": "k-scheduler-row",
+      key: this.ri.groupIndex
+    }, [h("div", {
+      "class": "k-scheduler-cell k-heading-cell k-group-cell k-scheduler-datecolumn"
+    }, [localization.toLanguageString(dateTitle, messages[dateTitle])]), h("div", {
+      "class": "k-scheduler-cell k-heading-cell k-group-cell k-scheduler-timecolumn"
+    }, [localization.toLanguageString(timeTitle, messages[timeTitle])]), h("div", {
+      "class": "k-scheduler-cell k-heading-cell k-scheduler-eventcolumn"
+    }, [localization.toLanguageString(eventTitle, messages[eventTitle])])]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var AgendaViewHead = AgendaViewHeadVue2;
+export { AgendaViewHead, AgendaViewHeadVue2 };

package/dist/esm/views/agenda/AgendaViewHeaderItem.d.ts

@@ -0,0 +1,46 @@
+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 { Range } from '../../models';
+/** @hidden */
+export interface AgendaViewHeaderItemProps {
+    range: Range;
+}
+/**
+ * @hidden
+ */
+export interface AgendaViewHeaderItemState {
+}
+/**
+ * @hidden
+ */
+export interface AgendaViewHeaderItemComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface AgendaViewHeaderItemMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface AgendaViewHeaderItemData {
+}
+/**
+ * @hidden
+ */
+export interface AgendaViewHeaderItemAll extends Vue2type, AgendaViewHeaderItemMethods, AgendaViewHeaderItemData, AgendaViewHeaderItemComputed, AgendaViewHeaderItemState {
+}
+/**
+ * @hidden
+ */
+declare let AgendaViewHeaderItemVue2: ComponentOptions<AgendaViewHeaderItemAll, DefaultData<AgendaViewHeaderItemData>, DefaultMethods<AgendaViewHeaderItemAll>, AgendaViewHeaderItemComputed, RecordPropsDefinition<AgendaViewHeaderItemProps>>;
+/**
+ * @hidden
+ */
+declare const AgendaViewHeaderItem: DefineComponent<AgendaViewHeaderItemProps, any, AgendaViewHeaderItemData, AgendaViewHeaderItemComputed, AgendaViewHeaderItemMethods, {}, {}, {}, string, AgendaViewHeaderItemProps, AgendaViewHeaderItemProps, {}>;
+export { AgendaViewHeaderItem, AgendaViewHeaderItemVue2 };

package/dist/esm/views/agenda/AgendaViewHeaderItem.js

@@ -0,0 +1,49 @@
+// @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 { provideIntlService } from '@progress/kendo-vue-intl';
+/**
+ * @hidden
+ */
+
+var AgendaViewHeaderItemVue2 = {
+  name: 'KendoAgendaViewHeaderItem',
+  props: {
+    range: Object
+  },
+  inject: {
+    kendoIntlService: {
+      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 intl = provideIntlService(this);
+    return h("div", {
+      "class": "k-scheduler-cell k-scheduler-datecolumn k-group-cell"
+    }, [h("div", [h("strong", {
+      "class": "k-scheduler-agendaday"
+    }, [intl.formatDate(this.$props.range.zonedStart, 'dd')]), h("em", {
+      "class": "k-scheduler-agendaweek"
+    }, [intl.formatDate(this.$props.range.zonedStart, 'EEEE')]), h("span", {
+      "class": "k-scheduler-agendadate"
+    }, [intl.formatDate(this.$props.range.zonedStart, 'y')])])]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var AgendaViewHeaderItem = AgendaViewHeaderItemVue2;
+export { AgendaViewHeaderItem, AgendaViewHeaderItemVue2 };

package/dist/esm/views/common/HorizontalResourceIterator.d.ts

@@ -0,0 +1,61 @@
+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 { SchedulerResource, SchedulerGroup } from '../../models';
+/** @hidden */
+export interface HorizontalResourceIteratorProps {
+    group?: SchedulerGroup;
+    resources?: SchedulerResource[];
+    nested?: boolean;
+    rowContent?: any;
+    childRowContent?: any;
+    rowContentProps?: any;
+}
+/** @hidden */
+export interface RenderResourcesArgs {
+    resources: any[];
+    nested: boolean;
+    groupIndex: number;
+    children: any;
+    rowContent: any;
+    childRowContent: any;
+    rowContentProps?: any;
+}
+/**
+ * @hidden
+ */
+export interface HorizontalResourceIteratorState {
+}
+/**
+ * @hidden
+ */
+export interface HorizontalResourceIteratorComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface HorizontalResourceIteratorMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface HorizontalResourceIteratorData {
+}
+/**
+ * @hidden
+ */
+export interface HorizontalResourceIteratorAll extends Vue2type, HorizontalResourceIteratorMethods, HorizontalResourceIteratorData, HorizontalResourceIteratorComputed, HorizontalResourceIteratorState {
+}
+/**
+ * @hidden
+ */
+declare let HorizontalResourceIteratorVue2: ComponentOptions<HorizontalResourceIteratorAll, DefaultData<HorizontalResourceIteratorData>, DefaultMethods<HorizontalResourceIteratorAll>, HorizontalResourceIteratorComputed, RecordPropsDefinition<HorizontalResourceIteratorProps>>;
+/** @hidden */
+export declare const DefaultRowContent: (props: any) => any;
+/** @hidden */
+declare const HorizontalResourceIterator: DefineComponent<HorizontalResourceIteratorProps, any, HorizontalResourceIteratorData, HorizontalResourceIteratorComputed, HorizontalResourceIteratorMethods, {}, {}, {}, string, HorizontalResourceIteratorProps, HorizontalResourceIteratorProps, {}>;
+export { HorizontalResourceIterator, HorizontalResourceIteratorVue2 };

package/dist/esm/views/common/HorizontalResourceIterator.js

@@ -0,0 +1,185 @@
+// @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 { expandResources, toGroupResources } from './utils.js';
+import { EMPTY_RESOURCE } from '../../constants.js';
+import { SchedulerResourceIteratorContext } from '../../context/SchedulerResourceIteratorContext.js';
+import { getDefaultSlots } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var HorizontalResourceIteratorVue2 = {
+  name: 'KendoHorizontalResourceIterator',
+  props: {
+    group: Object,
+    resources: Array,
+    nested: Boolean,
+    rowContent: [String, Function, Object],
+    childRowContent: [String, Function, Object],
+    rowContentProps: {
+      type: Object,
+      default: function _default() {
+        return {};
+      }
+    }
+  },
+  // @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,
+        nested = _a.nested,
+        rowContentProps = _a.rowContentProps;
+    var rowContent = this.$props.rowContent || DefaultRowContent;
+    var childRowContent = this.$props.childRowContent || rowContent;
+    var resources = toGroupResources(this.$props.group, this.$props.resources);
+    var defaultSlot = getDefaultSlots(this);
+    var groupIndex = 0;
+
+    var renderResources = function renderResources(args) {
+      var children = args.children;
+      var deepestResources = expandResources(args.resources, args.resources.length - 1);
+      var ChildRowContent = args.childRowContent;
+      var hasGroups = args.resources.length > 0;
+      return h("div", {
+        "class": "k-scheduler-row"
+      }, [h(ChildRowContent, {
+        timeHeaderCell: args.rowContentProps.timeHeaderCell,
+        attrs: this.v3 ? undefined : {
+          timeHeaderCell: args.rowContentProps.timeHeaderCell,
+          isMaster: args.rowContentProps.isMaster,
+          isLast: args.rowContentProps.isLast,
+          contentSlot: args.rowContentProps.contentSlot,
+          resources: args.resources
+        },
+        isMaster: args.rowContentProps.isMaster,
+        isLast: args.rowContentProps.isLast,
+        contentSlot: args.rowContentProps.contentSlot,
+        resources: args.resources
+      }), (deepestResources.length ? deepestResources : EMPTY_RESOURCE).map(function (resource, cGroupIndex) {
+        return (// @ts-ignore  function children
+          h(SchedulerResourceIteratorContext, {
+            key: cGroupIndex,
+            resource: resource,
+            attrs: this.v3 ? undefined : {
+              resource: resource,
+              groupIndex: hasGroups ? cGroupIndex : 0
+            },
+            groupIndex: hasGroups ? cGroupIndex : 0
+          }, this.v3 ? function () {
+            return [defaultSlot];
+          } : [defaultSlot])
+        );
+      }, this)]);
+    };
+
+    var renderResourcesRecursively = function renderResourcesRecursively(args) {
+      var children = args.children;
+
+      if (args.groupIndex === args.resources.length) {
+        return renderResources.call(this, {
+          resources: args.resources,
+          rowContent: args.rowContent,
+          children: children,
+          nested: args.nested,
+          groupIndex: args.groupIndex,
+          rowContentProps: args.rowContentProps,
+          childRowContent: args.childRowContent
+        });
+      }
+
+      var expandedResources = expandResources(args.resources, args.groupIndex);
+      var RowContent = args.rowContent;
+      return [args.nested ? h("div", {
+        "class": "k-scheduler-row"
+      }, [h(RowContent, {
+        resources: args.resources,
+        attrs: this.v3 ? undefined : {
+          resources: args.resources,
+          groupIndex: args.groupIndex,
+          timeHeaderCell: args.rowContentProps.timeHeaderCell,
+          isMaster: args.rowContentProps.isMaster,
+          isLast: args.rowContentProps.isLast,
+          contentSlot: args.rowContentProps.contentSlot
+        },
+        groupIndex: args.groupIndex,
+        timeHeaderCell: args.rowContentProps.timeHeaderCell,
+        isMaster: args.rowContentProps.isMaster,
+        isLast: args.rowContentProps.isLast,
+        contentSlot: args.rowContentProps.contentSlot
+      }), expandedResources.map(function (expandedResource, expandedResourceIndex) {
+        return h("div", {
+          key: expandedResourceIndex,
+          "class": "k-scheduler-cell k-heading-cell"
+        }, [expandedResource.text]);
+      })]) : h(RowContent, {
+        resources: args.resources,
+        attrs: this.v3 ? undefined : {
+          resources: args.resources,
+          groupIndex: args.groupIndex,
+          timeHeaderCell: args.rowContentProps.timeHeaderCell,
+          isMaster: args.rowContentProps.isMaster,
+          isLast: args.rowContentProps.isLast,
+          contentSlot: args.rowContentProps.contentSlot
+        },
+        groupIndex: args.groupIndex,
+        timeHeaderCell: args.rowContentProps.timeHeaderCell,
+        isMaster: args.rowContentProps.isMaster,
+        isLast: args.rowContentProps.isLast,
+        contentSlot: args.rowContentProps.contentSlot
+      }), expandedResources.map(function (expandedResource, expandedResourceIndex) {
+        return h("div", {
+          key: expandedResourceIndex,
+          "class": "k-scheduler-cell k-heading-cell"
+        }, [expandedResource.text]);
+      }, this), renderResourcesRecursively.call(this, {
+        resources: resources,
+        children: defaultSlot,
+        nested: nested,
+        rowContent: rowContent,
+        rowContentProps: args.rowContentProps,
+        childRowContent: childRowContent,
+        groupIndex: args.groupIndex + 1
+      })];
+    };
+
+    return h("div", {
+      "class": "k-scheduler-group k-group-horizontal"
+    }, [nested ? renderResourcesRecursively.call(this, {
+      resources: resources,
+      children: defaultSlot,
+      nested: nested,
+      groupIndex: groupIndex,
+      rowContent: rowContent,
+      rowContentProps: rowContentProps,
+      childRowContent: childRowContent
+    }) : renderResources.call(this, {
+      resources: resources,
+      children: defaultSlot,
+      rowContent: rowContent,
+      nested: !!nested,
+      groupIndex: groupIndex,
+      rowContentProps: rowContentProps,
+      childRowContent: childRowContent
+    })]);
+  }
+};
+/** @hidden */
+
+export var DefaultRowContent = function DefaultRowContent(props) {
+  return props.children;
+};
+/** @hidden */
+
+var HorizontalResourceIterator = HorizontalResourceIteratorVue2;
+export { HorizontalResourceIterator, HorizontalResourceIteratorVue2 };

package/dist/esm/views/common/SchedulerDrag.d.ts

@@ -0,0 +1,64 @@
+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 { DataItem } from '../../models';
+/**
+ * Represents the props of the Kendo UI for Vue [SchedulerDrag] component.
+ */
+export interface SchedulerDragProps {
+    /** @hidden */
+    ignoreIsAllDay?: boolean;
+    /**
+     * Specifies the `DataItem` to be visualized as a Drag item.
+     */
+    dataItem: DataItem;
+    /**
+     * Specifies the orientation of the SchedulerItem inside the Drag.
+     */
+    vertical?: boolean;
+    /**
+     * Overrides the default component responsible for visualizing a single item.
+     *
+     * The default Component is: [SchedulerItem].
+     */
+    item?: any;
+    /**
+     * Overrides the default component responsible for positioning the item inside the view.
+     *
+     * The default Component is: [SchedulerViewItem]().
+     */
+    viewItem?: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerDragState {
+}
+/**
+ * @hidden
+ */
+export interface SchedulerDragComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerDragMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerDragData {
+}
+/**
+ * @hidden
+ */
+export interface SchedulerDragAll extends Vue2type, SchedulerDragMethods, SchedulerDragData, SchedulerDragComputed, SchedulerDragState {
+}
+/** @hidden */
+declare let SchedulerDragVue2: ComponentOptions<SchedulerDragAll, DefaultData<SchedulerDragData>, DefaultMethods<SchedulerDragAll>, SchedulerDragComputed, RecordPropsDefinition<SchedulerDragProps>>;
+declare const SchedulerDrag: DefineComponent<SchedulerDragProps, any, SchedulerDragData, SchedulerDragComputed, SchedulerDragMethods, {}, {}, {}, string, SchedulerDragProps, SchedulerDragProps, {}>;
+export { SchedulerDrag, SchedulerDragVue2 };

package/dist/esm/views/common/SchedulerDrag.js

@@ -0,0 +1,147 @@
+// @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 { toItems, toOccurrences } from '../../services.js';
+import { SchedulerItem } from '../../items/SchedulerItem.js';
+import { SchedulerViewItem } from '../../items/SchedulerViewItem'; // import { useSchedulerViewRangesContext, useSchedulerViewSlotsContext } from '../../context.js';
+// import {
+//     useSchedulerPropsContext,
+//     useSchedulerGroupsContext,
+//     useSchedulerFieldsContext,
+//     useSchedulerDateRangeContext
+// } from '../../context/SchedulerContext.js';
+
+import { mapItemsToSlots } from '../../utils.js';
+/** @hidden */
+
+var SchedulerDragVue2 = {
+  name: 'KendoSchedulerDrag',
+  inheritAttrs: false,
+  props: {
+    ignoreIsAllDay: Boolean,
+    dataItem: Object,
+    vertical: Boolean,
+    viewItem: [String, Function, Object],
+    item: {
+      type: Object,
+      default: function _default() {
+        return SchedulerItem;
+      }
+    }
+  },
+  inject: {
+    ks: {
+      default: null
+    },
+    bv: {
+      default: null
+    }
+  },
+  computed: {
+    occurrences: function occurrences() {
+      return toOccurrences([this.$props.dataItem], {
+        dateRange: this.ks.dateRange,
+        fields: this.ks.fields,
+        timezone: this.ks.timezone
+      });
+    },
+    items: function items() {
+      return toItems(this.occurrences, {
+        timezone: this.ks.timezone
+      }, {
+        groups: this.ks.groups,
+        ranges: this.bv.ranges
+      });
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var slots = (this.bv.slots || []).map(function (s) {
+      return s;
+    });
+    mapItemsToSlots(this.items, slots);
+    var itemsToRender = this.v3 ? this.items : this.items && this.items.length ? [this.items[0]] : [];
+
+    if (!itemsToRender.length) {
+      return null;
+    }
+
+    return itemsToRender.map(function (item, idx) {
+      return h(SchedulerViewItem, {
+        key: idx,
+        uid: item.uid,
+        attrs: this.v3 ? undefined : {
+          uid: item.uid,
+          start: item.start,
+          end: item.end,
+          originalStart: item.originalStart,
+          startTimezone: item.startTimezone,
+          endTimezone: item.endTimezone,
+          isAllDay: item.isAllDay,
+          title: item.title,
+          description: item.description,
+          occurrenceId: item.occurrenceId,
+          recurrenceExceptions: item.recurrenceExceptions,
+          recurrenceRule: item.recurrenceRule,
+          recurrenceId: item.recurrenceId,
+          dataItem: item.dataItem,
+          itemRef: item.itemRef,
+          head: item.head,
+          tail: item.tail,
+          order: item.order,
+          zonedStart: item.zonedStart,
+          zonedEnd: item.zonedEnd,
+          slots: item.slots,
+          group: item.group,
+          range: item.range,
+          isException: item.isException,
+          isRecurring: item.isRecurring //   item={this.$props.item}
+          ,
+          dragHint: true,
+          vertical: this.$props.vertical,
+          ignoreIsAllDay: this.$props.ignoreIsAllDay
+        },
+        start: item.start,
+        end: item.end,
+        originalStart: item.originalStart,
+        startTimezone: item.startTimezone,
+        endTimezone: item.endTimezone,
+        isAllDay: item.isAllDay,
+        title: item.title,
+        description: item.description,
+        occurrenceId: item.occurrenceId,
+        recurrenceExceptions: item.recurrenceExceptions,
+        recurrenceRule: item.recurrenceRule,
+        recurrenceId: item.recurrenceId,
+        dataItem: item.dataItem,
+        itemRef: item.itemRef,
+        head: item.head,
+        tail: item.tail,
+        order: item.order,
+        zonedStart: item.zonedStart,
+        zonedEnd: item.zonedEnd,
+        slots: item.slots,
+        group: item.group,
+        range: item.range,
+        isException: item.isException,
+        isRecurring: item.isRecurring,
+        dragHint: true,
+        vertical: this.$props.vertical,
+        ignoreIsAllDay: this.$props.ignoreIsAllDay
+      });
+    }, this);
+  }
+};
+var SchedulerDrag = SchedulerDragVue2;
+export { SchedulerDrag, SchedulerDragVue2 };

package/dist/esm/views/common/SchedulerResize.d.ts

@@ -0,0 +1,67 @@
+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 { DataItem } from '../../models';
+/**
+ * Represents the props of the Kendo UI for Vue [SchedulerResize]() component.
+ */
+export interface SchedulerResizeProps {
+    /** @hidden */
+    format?: string;
+    /** @hidden */
+    ignoreIsAllDay?: boolean;
+    /**
+     * Specifies the `DataItem` to be visualized as a Resize item.
+     */
+    dataItem: DataItem;
+    /**
+     * Specifies the orientation of the SchedulerItem inside the Drag.
+     */
+    vertical?: boolean;
+    /**
+     * Overrides the default component responsible for visualizing a single item.
+     *
+     * The default Component is: [SchedulerItem].
+     */
+    item?: any;
+    /**
+     * Overrides the default component responsible for positioning the item inside the view.
+     *
+     * The default Component is: [SchedulerViewItem]().
+     */
+    viewItem?: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerResizeState {
+}
+/**
+ * @hidden
+ */
+export interface SchedulerResizeComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerResizeMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface SchedulerResizeData {
+}
+/**
+ * @hidden
+ */
+export interface SchedulerResizeAll extends Vue2type, SchedulerResizeMethods, SchedulerResizeData, SchedulerResizeComputed, SchedulerResizeState {
+}
+/** @hidden */
+declare let SchedulerResizeVue2: ComponentOptions<SchedulerResizeAll, DefaultData<SchedulerResizeData>, DefaultMethods<SchedulerResizeAll>, SchedulerResizeComputed, RecordPropsDefinition<SchedulerResizeProps>>;
+/** @hidden */
+declare const SchedulerResize: DefineComponent<SchedulerResizeProps, any, SchedulerResizeData, SchedulerResizeComputed, SchedulerResizeMethods, {}, {}, {}, string, SchedulerResizeProps, SchedulerResizeProps, {}>;
+export { SchedulerResize, SchedulerResizeVue2 };