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

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

@@ -0,0 +1,57 @@
+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 {
+}
+declare let HorizontalResourceIteratorVue2: ComponentOptions<HorizontalResourceIteratorAll, DefaultData<HorizontalResourceIteratorData>, DefaultMethods<HorizontalResourceIteratorAll>, HorizontalResourceIteratorComputed, RecordPropsDefinition<HorizontalResourceIteratorProps>>;
+/** @hidden */
+export declare const DefaultRowContent: (props: any) => any;
+declare const HorizontalResourceIterator: DefineComponent<HorizontalResourceIteratorProps, any, HorizontalResourceIteratorData, HorizontalResourceIteratorComputed, HorizontalResourceIteratorMethods, {}, {}, {}, string, HorizontalResourceIteratorProps, HorizontalResourceIteratorProps, {}>;
+export { HorizontalResourceIterator, HorizontalResourceIteratorVue2 };

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

@@ -0,0 +1,179 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var inject = allVue.inject;
+import { expandResources, toGroupResources } from './utils';
+import { EMPTY_RESOURCE } from '../../constants';
+import { SchedulerResourceIteratorContext } from '../../context/SchedulerResourceIteratorContext';
+import { getDefaultSlots } from '@progress/kendo-vue-common'; // tslint:enable:max-line-length
+
+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: !gh ? undefined : function () {
+    var v3 = !!gh;
+    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;
+};
+var HorizontalResourceIterator = HorizontalResourceIteratorVue2;
+export { HorizontalResourceIterator, HorizontalResourceIteratorVue2 };

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

@@ -0,0 +1,63 @@
+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 {
+}
+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/es/views/common/SchedulerDrag.js

@@ -0,0 +1,95 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var inject = allVue.inject;
+import { toItems, toOccurrences } from '../../services';
+import { SchedulerItem } from '../../items/SchedulerItem';
+import { SchedulerViewItem } from '../../items/SchedulerViewItem'; // import { useSchedulerViewRangesContext, useSchedulerViewSlotsContext } from '../../context';
+// import {
+//     useSchedulerPropsContext,
+//     useSchedulerGroupsContext,
+//     useSchedulerFieldsContext,
+//     useSchedulerDateRangeContext
+// } from '../../context/SchedulerContext';
+
+import { mapItemsToSlots } from '../../utils'; // tslint:enable:max-line-length
+
+var SchedulerDragVue2 = {
+  name: 'KendoSchedulerDrag',
+  props: {
+    ignoreIsAllDay: Boolean,
+    dataItem: Object,
+    vertical: Boolean,
+    viewItem: [String, Function, Object],
+    item: {
+      type: Object,
+      default: function _default() {
+        return SchedulerItem;
+      }
+    }
+  },
+  inject: {
+    ks: {
+      default: null
+    }
+  },
+  computed: {
+    occurrences: function occurrences() {
+      return toOccurrences([this.$props.dataItem], {
+        dateRange: this.dateRange,
+        fields: this.fields,
+        timezone: this.ks.timezone
+      });
+    },
+    items: function items() {
+      return toItems(this.occurrences, {
+        timezone: this.ks.timezone
+      }, {
+        groups: this.groups,
+        ranges: this.ranges
+      });
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement; // const ranges = useSchedulerViewRangesContext();
+    // const { timezone } = useSchedulerPropsContext();
+    // const groups = useSchedulerGroupsContext();
+    // const fields = useSchedulerFieldsContext();
+    // const dateRange = useSchedulerDateRangeContext();
+    //  const [viewSlots] = useSchedulerViewSlotsContext();
+
+    var slots = (this.viewSlots || []).map(function (s) {
+      return s.current.props;
+    });
+    mapItemsToSlots(this.items, slots);
+    return (// fragment
+      h("div", [this.items.map(function (_item, idx) {
+        return h(SchedulerViewItem, {
+          key: idx // {...item}
+          ,
+          item: this.$props.item,
+          attrs: this.v3 ? undefined : {
+            item: this.$props.item,
+            dragHint: true,
+            vertical: this.$props.vertical,
+            ignoreIsAllDay: this.$props.ignoreIsAllDay
+          },
+          dragHint: true,
+          vertical: this.$props.vertical,
+          ignoreIsAllDay: this.$props.ignoreIsAllDay
+        });
+      }, this)])
+    );
+  }
+};
+var SchedulerDrag = SchedulerDragVue2;
+export { SchedulerDrag, SchedulerDragVue2 };

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

@@ -0,0 +1,65 @@
+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 {
+}
+declare let SchedulerResizeVue2: ComponentOptions<SchedulerResizeAll, DefaultData<SchedulerResizeData>, DefaultMethods<SchedulerResizeAll>, SchedulerResizeComputed, RecordPropsDefinition<SchedulerResizeProps>>;
+declare const SchedulerResize: DefineComponent<SchedulerResizeProps, any, SchedulerResizeData, SchedulerResizeComputed, SchedulerResizeMethods, {}, {}, {}, string, SchedulerResizeProps, SchedulerResizeProps, {}>;
+export { SchedulerResize, SchedulerResizeVue2 };

package/dist/es/views/common/SchedulerResize.js

@@ -0,0 +1,97 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var inject = allVue.inject;
+import { toItems, toOccurrences } from '../../services';
+import { SchedulerItem } from '../../items/SchedulerItem';
+import { SchedulerViewItem } from '../../items/SchedulerViewItem'; // import { useSchedulerViewRangesContext, useSchedulerViewSlotsContext } from '../../context';
+// import {
+//     useSchedulerPropsContext,
+//     useSchedulerGroupsContext,
+//     useSchedulerFieldsContext,
+//     useSchedulerDateRangeContext
+// } from '../../context/SchedulerContext';
+
+import { mapItemsToSlots } from '../../utils'; // tslint:enable:max-line-length
+
+var SchedulerResizeVue2 = {
+  name: 'KendoSchedulerResize',
+  props: {
+    ignoreIsAllDay: Boolean,
+    dataItem: Object,
+    vertical: Boolean,
+    viewItem: [String, Function, Object],
+    item: {
+      type: Object,
+      default: function _default() {
+        return SchedulerItem;
+      }
+    }
+  },
+  inject: {
+    ks: {
+      default: null
+    }
+  },
+  computed: {
+    occurrences: function occurrences() {
+      return toOccurrences([this.$props.dataItem], {
+        dateRange: this.dateRange,
+        fields: this.fields,
+        timezone: this.ks.timezone
+      });
+    },
+    items: function items() {
+      return toItems(this.occurrences, {
+        timezone: this.ks.timezone
+      }, {
+        groups: this.groups,
+        ranges: this.ranges
+      });
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement; // const ranges = useSchedulerViewRangesContext();
+    // const { timezone } = useSchedulerPropsContext();
+    // const groups = useSchedulerGroupsContext();
+    // const fields = useSchedulerFieldsContext();
+    // const dateRange = useSchedulerDateRangeContext();
+    // const [viewSlots] = useSchedulerViewSlotsContext();
+
+    var slots = (this.viewSlots || []).map(function (s) {
+      return s.current.props;
+    });
+    mapItemsToSlots(this.items, slots);
+    return (// fragment
+      h("div", [this.items.map(function (_item, idx) {
+        return h(SchedulerViewItem, {
+          key: idx //     {...item}
+          ,
+          format: this.$props.format,
+          attrs: this.v3 ? undefined : {
+            format: this.$props.format,
+            item: this.$props.item,
+            resizeHint: true,
+            vertical: this.$props.vertical,
+            ignoreIsAllDay: this.$props.ignoreIsAllDay
+          },
+          item: this.$props.item,
+          resizeHint: true,
+          vertical: this.$props.vertical,
+          ignoreIsAllDay: this.$props.ignoreIsAllDay
+        });
+      }, this)])
+    );
+  }
+};
+var SchedulerResize = SchedulerResizeVue2;
+export { SchedulerResize, SchedulerResizeVue2 };

package/dist/es/views/common/VerticalResourceIterator.d.ts

@@ -0,0 +1,53 @@
+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 VerticalResourceIteratorProps {
+    group?: SchedulerGroup;
+    resources?: SchedulerResource[];
+    nested?: boolean;
+    wrapGroup?: boolean;
+    cellContent?: any;
+    emptyCell?: boolean;
+}
+/** @hidden */
+export interface RenderResourcesArgs {
+    resources: any[];
+    cellContent: any;
+    children: any;
+    depth: number;
+    groupIndex: number;
+}
+/**
+ * @hidden
+ */
+export interface VerticalResourceIteratorState {
+}
+/**
+ * @hidden
+ */
+export interface VerticalResourceIteratorComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface VerticalResourceIteratorMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface VerticalResourceIteratorData {
+}
+/**
+ * @hidden
+ */
+export interface VerticalResourceIteratorAll extends Vue2type, VerticalResourceIteratorMethods, VerticalResourceIteratorData, VerticalResourceIteratorComputed, VerticalResourceIteratorState {
+}
+declare let VerticalResourceIteratorVue2: ComponentOptions<VerticalResourceIteratorAll, DefaultData<VerticalResourceIteratorData>, DefaultMethods<VerticalResourceIteratorAll>, VerticalResourceIteratorComputed, RecordPropsDefinition<VerticalResourceIteratorProps>>;
+declare const VerticalResourceIterator: DefineComponent<VerticalResourceIteratorProps, any, VerticalResourceIteratorData, VerticalResourceIteratorComputed, VerticalResourceIteratorMethods, {}, {}, {}, string, VerticalResourceIteratorProps, VerticalResourceIteratorProps, {}>;
+export { VerticalResourceIterator, VerticalResourceIteratorVue2 };