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

package/dist/esm/drag/DropClue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => DropClueData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface DropClueData extends Vue2type {
+    ref?: string;
+    visible?: boolean;
+    top?: number;
+    left?: number;
+    height?: number;
+}
+/**
+ * @hidden
+ */
+declare let DropClueVue2: ComponentOptions<Vue2type, DefaultData<DropClueData>, DefaultMethods<{}>, {}, RecordPropsDefinition<{}>>;
+/**
+ * @hidden
+ */
+declare const DropClue: DefineComponent<{}, any, DropClueData, {}, {}, {}, {}, {}, string, {}, {}, {}>;
+export { DropClue, DropClueVue2 };

package/dist/esm/drag/DropClue.js

@@ -0,0 +1,46 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+/**
+ * @hidden
+ */
+
+var DropClueVue2 = {
+  data: function data() {
+    return {
+      height: 0,
+      visible: false,
+      left: 0,
+      top: 0
+    };
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    return this.visible && h("div", {
+      "class": "k-grouping-dropclue",
+      style: {
+        zIndex: 10000,
+        display: 'block',
+        top: this.top + 'px',
+        left: this.left + 'px',
+        height: this.height + 'px'
+      }
+    });
+  }
+};
+/**
+ * @hidden
+ */
+
+var DropClue = DropClueVue2;
+export { DropClue, DropClueVue2 };

package/dist/esm/drag/GroupingIndicator.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;
+};
+/**
+ * @hidden
+ */
+export interface GroupingIndicatorProps {
+    key?: any;
+    title: string;
+    dir: string;
+    onRemove?: (event: any) => void;
+    onSortChange?: (event: any, dir: string) => void;
+    onDrag?: (draggableEvent: any, element: HTMLDivElement) => void;
+    onPress?: (draggableEvent: any, element: HTMLDivElement) => void;
+    onRelease?: (draggableEvent: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface GroupingIndicatorMethods extends Vue2type {
+    press: (event: any) => void;
+    drag: (event: any) => void;
+    release: (event: any) => void;
+    sortChange: (event: any) => void;
+    groupRemove: (event: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface GroupingIndicatorState {
+    element: any | null;
+    draggable: any;
+    indicatorContainerRef: any;
+    v3: boolean;
+}
+/**
+ * @hidden
+ */
+export interface GroupingIndicatorAll extends GroupingIndicatorMethods, GroupingIndicatorState {
+}
+/**
+ * @hidden
+ */
+declare let GroupingIndicatorVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<GroupingIndicatorAll>, {}, RecordPropsDefinition<GroupingIndicatorProps>>;
+/**
+ * @hidden
+ */
+declare const GroupingIndicator: DefineComponent<GroupingIndicatorProps, any, {}, {}, GroupingIndicatorMethods, {}, {}, {}, string, GroupingIndicatorProps, GroupingIndicatorProps, {}>;
+export { GroupingIndicator, GroupingIndicatorVue2 };

package/dist/esm/drag/GroupingIndicator.js

@@ -0,0 +1,153 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+var ref = allVue.ref;
+import { Draggable, getRef, setRef } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var GroupingIndicatorVue2 = {
+  props: {
+    title: String,
+    dir: String // 'asc' | 'desc';
+
+  },
+  mounted: function mounted() {
+    this.element = getRef(this, 'indicatorContainer');
+
+    if (this.element) {
+      this.draggable = this.$refs.draggable;
+    }
+  },
+  methods: {
+    press: function press(event) {
+      if (this.element) {
+        this.$emit('press', event, this.element);
+      }
+    },
+    drag: function drag(event) {
+      if (this.element) {
+        this.$emit('drag', event, this.element);
+      }
+    },
+    release: function release(event) {
+      if (this.element) {
+        this.$emit('release', event, this.element);
+      }
+    },
+    sortChange: function sortChange(event) {
+      event.preventDefault();
+      var sort = this.$props.dir === 'asc' ? 'desc' : 'asc';
+      this.$emit('sortChange', event, sort);
+    },
+    groupRemove: function groupRemove(event) {
+      event.preventDefault();
+      this.$emit('remove', event);
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    var indicatorContainerRef = ref(null);
+    return {
+      v3: v3,
+      indicatorContainerRef: indicatorContainerRef
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    return (// @ts-ignore  function children
+      h(Draggable, {
+        onPress: this.press,
+        on: this.v3 ? undefined : {
+          "press": this.press,
+          "drag": this.drag,
+          "release": this.release
+        },
+        onDrag: this.drag,
+        onRelease: this.release,
+        ref: 'draggable'
+      }, this.v3 ? function () {
+        return [h("div", {
+          "class": "k-indicator-container",
+          ref: setRef(_this, 'indicatorContainer')
+        }, [h("div", {
+          "class": "k-chip k-chip-lg k-rounded-md k-chip-solid k-chip-solid-base"
+        }, [h("span", {
+          "class": 'k-chip-icon k-icon k-i-sort-' + _this.$props.dir + '-sm'
+        }), h("span", {
+          "class": "k-chip-content",
+          tabindex: -1,
+          attrs: _this.v3 ? undefined : {
+            tabindex: -1
+          },
+          onClick: _this.sortChange,
+          on: _this.v3 ? undefined : {
+            "click": _this.sortChange
+          }
+        }, [h("span", {
+          "class": "k-chip-text"
+        }, [_this.$props.title])]), h("span", {
+          "class": "k-chip-actions"
+        }, [h("span", {
+          "class": "k-chip-action",
+          tabindex: -1,
+          attrs: _this.v3 ? undefined : {
+            tabindex: -1
+          },
+          onClick: _this.groupRemove,
+          on: _this.v3 ? undefined : {
+            "click": _this.groupRemove
+          }
+        }, [h("span", {
+          "class": "k-icon k-i-x"
+        })])])])])];
+      } : [h("div", {
+        "class": "k-indicator-container",
+        ref: setRef(_this, 'indicatorContainer')
+      }, [h("div", {
+        "class": "k-chip k-chip-lg k-rounded-md k-chip-solid k-chip-solid-base"
+      }, [h("span", {
+        "class": 'k-chip-icon k-icon k-i-sort-' + _this.$props.dir + '-sm'
+      }), h("span", {
+        "class": "k-chip-content",
+        tabindex: -1,
+        attrs: _this.v3 ? undefined : {
+          tabindex: -1
+        },
+        onClick: _this.sortChange,
+        on: _this.v3 ? undefined : {
+          "click": _this.sortChange
+        }
+      }, [h("span", {
+        "class": "k-chip-text"
+      }, [_this.$props.title])]), h("span", {
+        "class": "k-chip-actions"
+      }, [h("span", {
+        "class": "k-chip-action",
+        tabindex: -1,
+        attrs: _this.v3 ? undefined : {
+          tabindex: -1
+        },
+        onClick: _this.groupRemove,
+        on: _this.v3 ? undefined : {
+          "click": _this.groupRemove
+        }
+      }, [h("span", {
+        "class": "k-icon k-i-x"
+      })])])])])])
+    );
+  }
+};
+/**
+ * @hidden
+ */
+
+var GroupingIndicator = GroupingIndicatorVue2;
+export { GroupingIndicator, GroupingIndicatorVue2 };

package/dist/esm/filterCommon.d.ts

@@ -0,0 +1,75 @@
+import { GridFilterOperators } from './interfaces/GridFilterOperators';
+import { GridFilterOperator } from './interfaces/GridFilterOperator';
+/**
+ * @hidden
+ */
+export declare const filterLogicList: {
+    text: string;
+    operator: string;
+}[];
+/**
+ * @hidden
+ */
+export declare const operators: GridFilterOperators;
+/**
+ * @hidden
+ */
+export declare const IsUnaryFilter: (operator: string | Function) => boolean;
+/**
+ * @hidden
+ */
+export declare const operatorMap: (iterable: Array<any>, service: any) => {
+    text: any;
+    operator: any;
+}[];
+/**
+ * @hidden
+ */
+export declare const defaultBooleanOperator: string;
+/**
+ * @hidden
+ */
+export declare const booleanFilterValues: ({
+    text: string;
+    operator: string;
+} | {
+    text: string;
+    operator: boolean;
+})[];
+/**
+ * @hidden
+ */
+export declare const defaultHideSecondFilter: {
+    text: boolean;
+    numeric: boolean;
+    date: boolean;
+    boolean: boolean;
+};
+/**
+ * @hidden
+ */
+export declare const cellInputChange: (value: any, e: any, props: any) => any;
+/**
+ * @hidden
+ */
+export declare const getDefaultOperator: (filterOperators: GridFilterOperators | GridFilterOperator[], filterType?: string) => any;
+/**
+ * @hidden
+ */
+export declare const getFilterType: (filterType: 'text' | 'numeric' | 'boolean' | 'date' | undefined) => "boolean" | "numeric" | "text" | "date";
+/**
+ * @hidden
+ */
+export declare const cellBoolDropdownChange: (value: any, e: any) => {
+    value: any;
+    operator: string;
+    event: any;
+};
+/**
+ * @hidden
+ */
+export declare const cellOperatorChange: (operator: any, e: any, value: any) => {
+    value: any;
+    operator: any;
+    event: any;
+};

package/dist/esm/filterCommon.js

@@ -0,0 +1,156 @@
+import { messages } from './messages.js';
+/**
+ * @hidden
+ */
+export var filterLogicList = [
+    { text: 'grid.filterAndLogic', operator: 'and' },
+    { text: 'grid.filterOrLogic', operator: 'or' }
+];
+/**
+ * @hidden
+ */
+export var operators = {
+    'text': [
+        { text: 'grid.filterContainsOperator', operator: 'contains' },
+        { text: 'grid.filterNotContainsOperator', operator: 'doesnotcontain' },
+        { text: 'grid.filterEqOperator', operator: 'eq' },
+        { text: 'grid.filterNotEqOperator', operator: 'neq' },
+        { text: 'grid.filterStartsWithOperator', operator: 'startswith' },
+        { text: 'grid.filterEndsWithOperator', operator: 'endswith' },
+        { text: 'grid.filterIsNullOperator', operator: 'isnull' },
+        { text: 'grid.filterIsNotNullOperator', operator: 'isnotnull' },
+        { text: 'grid.filterIsEmptyOperator', operator: 'isempty' },
+        { text: 'grid.filterIsNotEmptyOperator', operator: 'isnotempty' }
+    ],
+    'numeric': [
+        { text: 'grid.filterEqOperator', operator: 'eq' },
+        { text: 'grid.filterNotEqOperator', operator: 'neq' },
+        { text: 'grid.filterGteOperator', operator: 'gte' },
+        { text: 'grid.filterGtOperator', operator: 'gt' },
+        { text: 'grid.filterLteOperator', operator: 'lte' },
+        { text: 'grid.filterLtOperator', operator: 'lt' },
+        { text: 'grid.filterIsNullOperator', operator: 'isnull' },
+        { text: 'grid.filterIsNotNullOperator', operator: 'isnotnull' }
+    ],
+    'date': [
+        { text: 'grid.filterEqOperator', operator: 'eq' },
+        { text: 'grid.filterNotEqOperator', operator: 'neq' },
+        { text: 'grid.filterAfterOrEqualOperator', operator: 'gte' },
+        { text: 'grid.filterAfterOperator', operator: 'gt' },
+        { text: 'grid.filterBeforeOperator', operator: 'lt' },
+        { text: 'grid.filterBeforeOrEqualOperator', operator: 'lte' },
+        { text: 'grid.filterIsNullOperator', operator: 'isnull' },
+        { text: 'grid.filterIsNotNullOperator', operator: 'isnotnull' }
+    ],
+    'boolean': [
+        { text: 'grid.filterEqOperator', operator: 'eq' }
+    ]
+};
+/**
+ * @hidden
+ */
+export var IsUnaryFilter = function (operator) {
+    return operator === 'isnull' || operator === 'isnotnull' || operator === 'isempty' || operator === 'isnotempty';
+};
+/**
+ * @hidden
+ */
+export var operatorMap = function (iterable, service) { return iterable.map(function (operator) { return ({
+    text: service.toLanguageString(operator.text, messages[operator.text]),
+    operator: operator.operator
+}); }); };
+/**
+ * @hidden
+ */
+export var defaultBooleanOperator = 'eq';
+/**
+ * @hidden
+ */
+export var booleanFilterValues = [
+    { text: 'grid.filterBooleanAll', operator: '' },
+    { text: 'grid.filterIsTrue', operator: true },
+    { text: 'grid.filterIsFalse', operator: false }
+];
+/**
+ * @hidden
+ */
+export var defaultHideSecondFilter = {
+    text: false,
+    numeric: false,
+    date: false,
+    boolean: true
+};
+/**
+ * @hidden
+ */
+export var cellInputChange = function (value, e, props) {
+    var defaultOperator = getDefaultOperator(props.operators);
+    var operator = props.operator;
+    switch (props.filterType) {
+        case 'numeric':
+            if (!operator || IsUnaryFilter(operator)) {
+                // change the operator to default
+                operator = defaultOperator;
+            }
+            if (value === null && operator === defaultOperator) {
+                // clear only the default operator
+                operator = '';
+            }
+            break;
+        case 'date':
+            if (!operator || IsUnaryFilter(operator)) {
+                operator = defaultOperator;
+            }
+            if (value === null && operator === defaultOperator) {
+                operator = '';
+            }
+            break;
+        case 'text':
+            if (!operator || IsUnaryFilter(operator)) {
+                operator = defaultOperator;
+            }
+            if (!value && operator === defaultOperator) {
+                operator = '';
+            }
+            break;
+        default: return;
+    }
+    return { value: value, operator: operator, event: e };
+};
+/**
+ * @hidden
+ */
+export var getDefaultOperator = function (filterOperators, filterType) {
+    if (filterType) {
+        return filterOperators[filterType][0].operator;
+    }
+    else {
+        return filterOperators[0].operator;
+    }
+};
+/**
+ * @hidden
+ */
+export var getFilterType = function (filterType) {
+    return filterType || 'text';
+};
+/**
+ * @hidden
+ */
+export var cellBoolDropdownChange = function (value, e) {
+    return {
+        value: value,
+        operator: value === '' ? '' : defaultBooleanOperator,
+        event: e
+    };
+};
+/**
+ * @hidden
+ */
+export var cellOperatorChange = function (operator, e, value) {
+    if (IsUnaryFilter(operator)) {
+        // clear the value to avoid confusion on what is filtered
+        value = null;
+    }
+    return { value: value, operator: operator, event: e };
+};

package/dist/esm/footer/Footer.d.ts

@@ -0,0 +1,52 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => FooterData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface FooterProps {
+    staticHeaders: boolean;
+    row?: any;
+    columnResize: {
+        colGroupFooter: HTMLTableColElement | null;
+    };
+    cols: any[];
+}
+export interface FooterComputed {
+    [key: string]: any;
+    divStyle?: any;
+    tableStyle?: any;
+}
+export interface FooterState {
+    _footerWrap?: any;
+    colGroupHeaderRef: any;
+    footerWrapRef: any;
+    v3: boolean;
+}
+export interface FooterData {
+    scrollbarWidth?: number;
+    rtl?: any;
+    tableWidth?: number;
+    footerScrollLeft?: number;
+}
+export interface FooterMethods {
+    [key: string]: any;
+    setScrollLeft?: (scrollLeft: number) => void;
+    setWidth?: (width: number) => void;
+}
+/**
+ * @hidden
+ */
+export interface FooterAllMethods extends Vue2type, FooterMethods, FooterData, FooterComputed, FooterState {
+}
+/**
+ * @hidden
+ */
+declare let FooterVue2: ComponentOptions<FooterAllMethods, DefaultData<FooterData>, DefaultMethods<FooterAllMethods>, FooterComputed, RecordPropsDefinition<FooterProps>>;
+/**
+ * @hidden
+ */
+declare const Footer: DefineComponent<FooterProps, any, FooterData, FooterComputed, FooterMethods, {}, {}, {}, string, FooterProps, FooterProps, {}>;
+export { Footer, FooterVue2 };

package/dist/esm/footer/Footer.js

@@ -0,0 +1,103 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+var ref = allVue.ref;
+import { BrowserSupportService } from '../utils/browser-support.service.js';
+import { isRtl } from '../utils.js';
+import { getRef, setRef } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var FooterVue2 = {
+  name: 'Footer',
+  props: {
+    staticHeaders: Boolean,
+    row: Object,
+    columnResize: Object,
+    cols: Array
+  },
+  data: function data() {
+    return {
+      scrollbarWidth: 0,
+      rtl: false,
+      tableWidth: null
+    };
+  },
+  computed: {
+    divStyle: {
+      get: function get() {
+        var padding = this.$data.scrollbarWidth + 'px';
+        var right = this.rtl ? 0 : padding;
+        var left = this.rtl ? padding : 0;
+        return {
+          padding: "0 ".concat(right, " 0 ").concat(left)
+        };
+      }
+    },
+    tableStyle: {
+      get: function get() {
+        return this.tableWidth ? {
+          width: this.tableWidth
+        } : null;
+      }
+    }
+  },
+  mounted: function mounted() {
+    this.$data.scrollbarWidth = new BrowserSupportService().scrollbarWidth;
+    this.rtl = isRtl(this.$el);
+    this.$props.columnResize.colGroupFooter = getRef(this, 'colGroupHeader');
+    this._footerWrap = getRef(this, 'footerWrap');
+  },
+  methods: {
+    setScrollLeft: function setScrollLeft(scrollLeft) {
+      if (this._footerWrap) {
+        this._footerWrap.scrollLeft = scrollLeft;
+      }
+    },
+    setWidth: function setWidth(width) {
+      this.$data.tableWidth = width + 'px';
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    var footerWrapRef = ref(null);
+    var colGroupHeaderRef = ref(null);
+    return {
+      v3: v3,
+      colGroupHeaderRef: colGroupHeaderRef,
+      footerWrapRef: footerWrapRef
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+
+    if (!this.$props.staticHeaders) {
+      return h("tfoot", {
+        "class": "k-grid-footer"
+      }, [this.$props.row]);
+    }
+
+    return h("div", {
+      "class": "k-grid-footer",
+      style: this.divStyle
+    }, [h("div", {
+      "class": "k-grid-footer-wrap",
+      ref: setRef(this, 'footerWrap')
+    }, [h("table", {
+      style: this.tableStyle
+    }, [h("colgroup", {
+      ref: setRef(this, 'colGroupHeader')
+    }, [this.$props.cols]), h("tfoot", [this.$props.row])])])]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var Footer = FooterVue2;
+export { Footer, FooterVue2 };

package/dist/esm/footer/FooterRow.d.ts

@@ -0,0 +1,30 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { ExtendedColumnProps } from '../interfaces/ExtendedColumnProps';
+/**
+ * @hidden
+ */
+export interface FooterRowProps {
+    columns: ExtendedColumnProps[];
+    isRtl: boolean;
+}
+export interface FooterRowMethods {
+    [key: string]: any;
+    columnStyles: (column: ExtendedColumnProps) => object;
+}
+/**
+ * @hidden
+ */
+export interface FooterRowAllMethods extends Vue2type, FooterRowMethods {
+}
+/**
+ * @hidden
+ */
+declare let FooterRowVue2: ComponentOptions<FooterRowAllMethods, {}, DefaultMethods<FooterRowAllMethods>, {}, RecordPropsDefinition<FooterRowProps>>;
+/**
+ * @hidden
+ */
+declare const FooterRow: DefineComponent<FooterRowProps, any, {}, {}, FooterRowMethods, {}, {}, {}, string, FooterRowProps, FooterRowProps, {}>;
+export { FooterRow, FooterRowVue2 };