@progress/kendo-vue-data-tools 3.5.1 → 3.5.2-dev.202209020458

package/dist/es/drag/ColumnResizer.js

@@ -0,0 +1,89 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { Draggable } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+
+var ColumnResizerVue2 = {
+  mounted: function mounted() {
+    if (this.$el) {
+      this.draggable = this.$refs.draggable;
+    }
+  },
+  methods: {
+    drag: function drag(event) {
+      var element = this.draggable && this.draggable.element;
+
+      if (element) {
+        this.$emit('resize', event, element, false);
+      }
+    },
+    release: function release(event) {
+      var element = this.draggable && this.draggable.element;
+
+      if (element) {
+        this.$emit('resize', event, element, true);
+      }
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var _this = this;
+
+    var h = gh || createElement;
+    var resizeStyle = {
+      // TODO: move to theme
+      cursor: 'col-resize',
+      display: 'block',
+      height: '1000%',
+      position: 'absolute',
+      // [this.props.isRtl ? 'left' : 'right']: 0,
+      top: 0,
+      width: '.5em'
+    };
+    return (// @ts-ignore  function children
+      h(Draggable, {
+        onDrag: this.drag,
+        on: this.v3 ? undefined : {
+          "drag": this.drag,
+          "release": this.release
+        },
+        onRelease: this.release,
+        ref: 'draggable'
+      }, this.v3 ? function () {
+        return [h("span", {
+          "class": "k-column-resizer",
+          draggable: false,
+          attrs: _this.v3 ? undefined : {
+            draggable: false
+          },
+          style: resizeStyle
+        })];
+      } : [h("span", {
+        "class": "k-column-resizer",
+        draggable: false,
+        attrs: _this.v3 ? undefined : {
+          draggable: false
+        },
+        style: resizeStyle
+      })])
+    );
+  }
+};
+/**
+ * @hidden
+ */
+
+var ColumnResizer = ColumnResizerVue2;
+export { ColumnResizer, ColumnResizerVue2 };

package/dist/es/drag/CommonDragLogic.d.ts

@@ -0,0 +1,35 @@
+import { ExtendedColumnProps } from '../interfaces/ColumnProps';
+/**
+ * @hidden
+ */
+export declare type handler = (prevIndex: number, nextIndex: number, event: any) => void;
+/**
+ * @hidden
+ */
+export declare class CommonDragLogic {
+    columns: ExtendedColumnProps[];
+    reorderable: boolean;
+    groupable: boolean;
+    dropElementClue: any | null;
+    dragElementClue: any | null;
+    private startColumn;
+    private startGroup;
+    private currentColumn;
+    private currentGroup;
+    private columnReorder;
+    private groupReorder;
+    private columnToGroup;
+    private groupPanelDivElement;
+    constructor(columnReorder: handler, groupReorder: handler, columnToGroup: handler);
+    refGroupPanelDiv: (e: any | null) => void;
+    refDropElementClue: (e: any | null) => void;
+    refDragElementClue: (e: any | null) => void;
+    pressHandler: (event: any, element: HTMLElement) => void;
+    dragHandler: (event: any, element: HTMLElement) => void;
+    releaseHandler: (event: any) => void;
+    private getColumnIndex;
+    private getGroupIndex;
+    private isValid;
+    private updateDragElementClue;
+    private updateDropElementClue;
+}

package/dist/es/drag/CommonDragLogic.js

@@ -0,0 +1,177 @@
+import { getIndex } from '../utils/main';
+import { canUseDOM } from '@progress/kendo-vue-common';
+/**
+ * @hidden
+ */
+var CommonDragLogic = /** @class */ (function () {
+    function CommonDragLogic(columnReorder, groupReorder, columnToGroup) {
+        var _this = this;
+        this.reorderable = false;
+        this.groupable = false;
+        this.dropElementClue = null;
+        this.dragElementClue = null;
+        this.startColumn = -1;
+        this.startGroup = -1;
+        this.currentColumn = -1;
+        this.currentGroup = -1;
+        this.groupPanelDivElement = null;
+        this.refGroupPanelDiv = function (e) {
+            _this.groupPanelDivElement = e;
+        };
+        this.refDropElementClue = function (e) {
+            _this.dropElementClue = e;
+            if (_this.dropElementClue && canUseDOM) {
+                document.body.appendChild(_this.dropElementClue.$el);
+            }
+        };
+        this.refDragElementClue = function (e) {
+            _this.dragElementClue = e;
+            if (_this.dragElementClue && canUseDOM) {
+                document.body.appendChild(_this.dragElementClue.$el);
+            }
+        };
+        this.pressHandler = function (event, element) {
+            if (!event.isTouch) {
+                event.originalEvent.preventDefault();
+            }
+            var startColumn = _this.getColumnIndex(event, element);
+            _this.startGroup = _this.getGroupIndex(event);
+            if (startColumn >= 0) {
+                var col = _this.columns[startColumn];
+                if (col.reorderable && _this.reorderable || col.groupable && _this.groupable) {
+                    _this.startColumn = startColumn;
+                }
+            }
+        };
+        this.dragHandler = function (event, element) {
+            if (!event.isTouch) {
+                event.originalEvent.preventDefault();
+            }
+            event.originalEvent.stopPropagation();
+            if (_this.startColumn === -1 && _this.startGroup === -1) {
+                return;
+            }
+            _this.currentColumn = _this.getColumnIndex(event, element);
+            _this.currentGroup = _this.getGroupIndex(event);
+            if (_this.groupPanelDivElement && _this.startGroup >= 0) {
+                _this.currentGroup = Math.min(_this.currentGroup, _this.groupPanelDivElement.children.length - 2);
+            }
+            var invalidIndex = !_this.isValid();
+            if (invalidIndex) {
+                _this.currentColumn = -1;
+                _this.currentGroup = -1;
+            }
+            var targetElement = (_this.currentColumn >= 0) ?
+                element.children[_this.columns[_this.currentColumn].index] :
+                _this.groupPanelDivElement && _this.groupPanelDivElement.children[_this.currentGroup];
+            _this.updateDragElementClue(event, element, targetElement, invalidIndex);
+            _this.updateDropElementClue(event, element, targetElement, invalidIndex);
+        };
+        this.releaseHandler = function (event) {
+            var prevColumnIndex = _this.startColumn;
+            var nextColumnIndex = _this.currentColumn;
+            var prevGroupIndex = _this.startGroup;
+            var nextGroupIndex = _this.currentGroup;
+            if (_this.dropElementClue) {
+                _this.dropElementClue.visible = false;
+            }
+            if (_this.dragElementClue) {
+                _this.dragElementClue.visible = false;
+            }
+            var isValid = _this.isValid();
+            _this.startColumn = _this.startGroup = _this.currentColumn = _this.currentGroup = -1;
+            if (!isValid) {
+                return;
+            }
+            if (prevColumnIndex >= 0 && nextColumnIndex >= 0) {
+                _this.columnReorder(prevColumnIndex, nextColumnIndex, event.originalEvent);
+            }
+            else if (prevGroupIndex >= 0 && nextGroupIndex >= 0) {
+                _this.groupReorder(prevGroupIndex, nextGroupIndex, event.originalEvent);
+            }
+            else if (prevColumnIndex >= 0 && nextGroupIndex >= 0) {
+                _this.columnToGroup(prevColumnIndex, nextGroupIndex, event.originalEvent);
+            }
+        };
+        this.columnReorder = columnReorder;
+        this.groupReorder = groupReorder;
+        this.columnToGroup = columnToGroup;
+    }
+    CommonDragLogic.prototype.getColumnIndex = function (event, parent) {
+        if (!parent || (parent.parentElement === this.groupPanelDivElement)) {
+            return -1;
+        }
+        var index = getIndex(event, parent);
+        if (index === -1) {
+            return -1;
+        }
+        var _loop_1 = function (i) {
+            if (parent.parentNode.children[i] === parent) {
+                return { value: this_1.columns.findIndex(function (c) { return ((c.index === index) && (c.depth === i)); }) };
+            }
+        };
+        var this_1 = this;
+        for (var i = 0; i < parent.parentNode.children.length; i++) {
+            var state_1 = _loop_1(i);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+        return -1;
+    };
+    CommonDragLogic.prototype.getGroupIndex = function (event) {
+        return getIndex(event, this.groupPanelDivElement);
+    };
+    CommonDragLogic.prototype.isValid = function () {
+        if (this.startGroup >= 0) {
+            // group can be moved into group only
+            return this.currentGroup >= 0 && this.currentGroup !== this.startGroup;
+        }
+        if (this.startColumn === -1) {
+            return false;
+        }
+        if (this.currentGroup >= 0) {
+            // column to group is possible
+            return this.columns[this.startColumn].groupable === true && this.groupable === true;
+        }
+        // reorder is possible
+        return this.reorderable === true &&
+            this.currentColumn >= 0 &&
+            this.currentColumn !== this.startColumn &&
+            this.columns[this.startColumn].reorderable === true &&
+            this.columns[this.currentColumn].parentIndex === this.columns[this.startColumn].parentIndex;
+    };
+    CommonDragLogic.prototype.updateDragElementClue = function (event, element, targetElement, invalidIndex) {
+        if (!this.dragElementClue) {
+            return;
+        }
+        var innerText = this.startColumn >= 0 ?
+            element.children[this.columns[this.startColumn].index].innerText :
+            element.innerText;
+        this.dragElementClue.visible = true;
+        this.dragElementClue.top = (event.pageY + 10);
+        this.dragElementClue.left = event.pageX;
+        this.dragElementClue.innerText = innerText;
+        this.dragElementClue.status = (invalidIndex || !targetElement) ? 'k-i-cancel' : 'k-i-add';
+    };
+    CommonDragLogic.prototype.updateDropElementClue = function (event, element, targetElement, invalidIndex) {
+        if (!this.dropElementClue) {
+            return;
+        }
+        if (invalidIndex || !targetElement) {
+            this.dropElementClue.visible = false;
+            return;
+        }
+        var rect = targetElement.getBoundingClientRect();
+        var left = rect.left + event.pageX - event.clientX - 6;
+        if (this.currentColumn > this.startColumn || this.currentGroup > this.startGroup && this.startGroup !== -1) {
+            left += rect.width;
+        }
+        var top = rect.top + event.pageY - event.clientY;
+        this.dropElementClue.visible = true;
+        this.dropElementClue.top = top;
+        this.dropElementClue.left = left;
+        this.dropElementClue.height = (this.currentColumn >= 0) ? element.clientHeight : rect.height;
+    };
+    return CommonDragLogic;
+}());
+export { CommonDragLogic };

package/dist/es/drag/DragClue.d.ts

@@ -0,0 +1,25 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => DragClueData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+/**
+ * @hidden
+ */
+export interface DragClueData extends Vue2type {
+    ref?: string;
+    visible?: boolean;
+    top?: number;
+    left?: number;
+    innerText?: string;
+    status?: 'k-i-cancel' | 'k-i-add';
+}
+/**
+ * @hidden
+ */
+declare let DragClueVue2: ComponentOptions<Vue2type, DefaultData<DragClueData>, DefaultMethods<{}>, {}, RecordPropsDefinition<{}>>;
+/**
+ * @hidden
+ */
+declare const DragClue: DefineComponent<{}, any, DragClueData, {}, {}, {}, {}, {}, string, {}, {}, {}>;
+export { DragClue, DragClueVue2 };

package/dist/es/drag/DragClue.js

@@ -0,0 +1,52 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+/**
+ * @hidden
+ */
+
+var DragClueVue2 = {
+  data: function data() {
+    return {
+      visible: false,
+      top: 0,
+      left: 0,
+      innerText: '',
+      status: 'k-i-cancel'
+    };
+  },
+  // @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-header k-drag-clue",
+      style: {
+        display: 'block',
+        position: 'absolute',
+        zIndex: 20000,
+        padding: '8px 12px',
+        top: this.top + 'px',
+        left: this.left + 'px'
+      }
+    }, [h("span", {
+      "class": 'k-icon k-drag-status ' + this.status + ' k-icon-with-modifier'
+    }, [h("span", {
+      "class": "k-icon k-icon-modifier"
+    })]), this.innerText]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var DragClue = DragClueVue2;
+export { DragClue, DragClueVue2 };

package/dist/es/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/es/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/es/filter/Expression.js

@@ -37,7 +37,7 @@ import { Button, Toolbar, ToolbarItem } from '@progress/kendo-vue-buttons';
 import { DropDownList } from '@progress/kendo-vue-dropdowns';
 import { provideLocalizationService } from '@progress/kendo-vue-intl';
 import { unaryOperator, stringOperator } from './operators';
-import { messages, filterClose } from '../messages';
+import { messages, filterClose } from '../messages/main';
 import { TextFilter } from './filters/TextFilter';
 import { NumericFilter } from './filters/NumericFilter';
 import { BooleanFilter } from './filters/BooleanFilter';

package/dist/es/filter/FieldSettings.d.ts

@@ -1,4 +1,4 @@
-import { FilterOperator } from '../filteringCells';
+import { FilterOperator } from '../interfaces/FilterOperator';
 /**
  * The FieldSettings object.
  */

package/dist/es/filter/GroupToolbar.js

@@ -32,7 +32,7 @@ var isV3 = allVue.version && allVue.version[0] === '3';
 import { Button, Toolbar, ToolbarItem, ButtonGroup } from '@progress/kendo-vue-buttons';
 import { provideLocalizationService } from '@progress/kendo-vue-intl';
 import { stringOperator } from './operators';
-import { messages, filterAndLogic, filterOrLogic, filterAddExpression, filterAddGroup, filterClose } from '../messages';
+import { messages, filterAndLogic, filterOrLogic, filterAddExpression, filterAddGroup, filterClose } from '../messages/main';
 /**
  * @hidden
  */

package/dist/es/filter/filters/BooleanFilter.js

@@ -4,7 +4,7 @@ var allVue = Vue;
 var gh = allVue.h;
 var isV3 = allVue.version && allVue.version[0] === '3';
 import { EnumFilter } from './EnumFilter';
-import { filterIsTrue, filterIsFalse } from '../../messages';
+import { filterIsTrue, filterIsFalse } from '../../messages/main';
 /**
  * @hidden
  */

package/dist/es/filter/filters/EnumFilter.js

@@ -21,7 +21,7 @@ var gh = allVue.h;
 var isV3 = allVue.version && allVue.version[0] === '3';
 import { DropDownList } from '@progress/kendo-vue-dropdowns';
 import { provideLocalizationService } from '@progress/kendo-vue-intl';
-import { messages } from './../../messages';
+import { messages } from '../../messages/main';
 /**
  * @hidden
  */

package/dist/es/filter/filters/TextFilter.d.ts

@@ -3,7 +3,7 @@ declare type DefaultData<V> = object | ((this: V) => {});
 declare type DefaultMethods<V> = {
     [key: string]: (this: V, ...args: any[]) => any;
 };
-import { FilterOperator } from '../../filteringCells';
+import { FilterOperator } from '../../interfaces/FilterOperator';
 import { FilterDescriptor } from '@progress/kendo-data-query';
 /**
  * The props of the TextFilter component.

package/dist/{esm/filter/index.d.ts → es/filter/main.d.ts}

@@ -1,4 +1,4 @@
-export * from './filters';
+export * from './filters/main';
 export * from './Expression';
 export * from './FieldSettings';
 export * from './Filter';

package/dist/{npm/filter/index.d.ts → es/filter/main.js}

@@ -1,4 +1,4 @@
-export * from './filters';
+export * from './filters/main';
 export * from './Expression';
 export * from './FieldSettings';
 export * from './Filter';

package/dist/es/filter/operators.d.ts

@@ -1,4 +1,4 @@
-import { FilterOperator } from '../filteringCells';
+import { FilterOperator } from '../interfaces/FilterOperator';
 /**
  * Represents the operators for the TextFilter, NumericFilter, DateFilter and BooleanFilter components.
  *

package/dist/es/filter/operators.js

@@ -7,7 +7,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { filterEqOperator, filterNotEqOperator, filterIsNullOperator, filterIsNotNullOperator, filterIsEmptyOperator, filterIsNotEmptyOperator, filterStartsWithOperator, filterContainsOperator, filterNotContainsOperator, filterEndsWithOperator, filterGteOperator, filterGtOperator, filterLteOperator, filterLtOperator, filterAfterOrEqualOperator, filterAfterOperator, filterBeforeOperator, filterBeforeOrEqualOperator } from './../messages';
+import { filterEqOperator, filterNotEqOperator, filterIsNullOperator, filterIsNotNullOperator, filterIsEmptyOperator, filterIsNotEmptyOperator, filterStartsWithOperator, filterContainsOperator, filterNotContainsOperator, filterEndsWithOperator, filterGteOperator, filterGtOperator, filterLteOperator, filterLtOperator, filterAfterOrEqualOperator, filterAfterOperator, filterBeforeOperator, filterBeforeOrEqualOperator } from '../messages/main';
 var textOperators = [
     { text: filterContainsOperator, operator: 'contains' },
     { text: filterNotContainsOperator, operator: 'doesnotcontain' },

package/dist/es/filterCommon.d.ts

@@ -0,0 +1,75 @@
+import { FilterOperators } from './interfaces/FilterOperators';
+import { FilterOperator } from './interfaces/FilterOperator';
+/**
+ * @hidden
+ */
+export declare const filterLogicList: {
+    text: string;
+    operator: string;
+}[];
+/**
+ * @hidden
+ */
+export declare const operators: FilterOperators;
+/**
+ * @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: FilterOperators | FilterOperator[], 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;
+};