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

package/dist/npm/header/HeaderSelectionCell.d.ts

@@ -0,0 +1,32 @@
+import { HeaderSelectionCellProps } from '../interfaces/HeaderSelectionCellProps';
+declare type DefaultData<V> = object | ((this: V) => HeaderSelectionCellData);
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../additionalTypes';
+/**
+ * @hidden
+ */
+export interface HeaderSelectionCellMethods extends Vue2type {
+    changeHandle: (e: any) => void;
+}
+/**
+ * @hidden
+ */
+export interface HeaderSelectionCellData {
+    inputId: string;
+}
+/**
+ * @hidden
+ */
+export interface HeaderSelectionCellAll extends HeaderSelectionCellMethods, HeaderSelectionCellData {
+}
+/**
+ * @hidden
+ */
+declare let HeaderSelectionCellVue2: ComponentOptions<Vue2type, DefaultData<HeaderSelectionCellData>, DefaultMethods<HeaderSelectionCellAll>, {}, RecordPropsDefinition<HeaderSelectionCellProps>>;
+/**
+ * @hidden
+ */
+declare const HeaderSelectionCell: DefineComponent<HeaderSelectionCellProps, any, HeaderSelectionCellData, {}, HeaderSelectionCellMethods, {}, {}, {}, string, HeaderSelectionCellProps, HeaderSelectionCellProps, {}>;
+export { HeaderSelectionCell, HeaderSelectionCellVue2 };

package/dist/npm/header/HeaderSelectionCell.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeaderSelectionCellVue2 = exports.HeaderSelectionCell = void 0; // @ts-ignore
+
+var Vue = require("vue");
+
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+
+var kendo_vue_common_1 = require("@progress/kendo-vue-common");
+/**
+ * @hidden
+ */
+
+
+var HeaderSelectionCellVue2 = {
+  props: {
+    field: String,
+    title: String,
+    selectionValue: Boolean,
+    render: [Object, Function, String]
+  },
+  created: function created() {
+    this.inputId = (0, kendo_vue_common_1.guid)();
+  },
+  methods: {
+    changeHandle: function changeHandle(e) {
+      this.$emit('selectionchange', {
+        field: this.$props.field,
+        event: e
+      });
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var renderTemplate = this.$props.render;
+    var defaultRendering = h("span", [[h("input", {
+      key: 0,
+      checked: this.v3 ? this.$props.selectionValue : null,
+      domProps: this.v3 ? undefined : {
+        "checked": this.$props.selectionValue
+      },
+      id: this.inputId,
+      attrs: this.v3 ? undefined : {
+        id: this.inputId,
+        type: "checkbox"
+      },
+      type: "checkbox",
+      "class": "k-checkbox k-checkbox-md k-rounded-md",
+      onChange: this.changeHandle,
+      on: this.v3 ? undefined : {
+        "change": this.changeHandle
+      }
+    }), h("label", {
+      key: 1,
+      "class": "k-checkbox-label",
+      "for": this.inputId,
+      attrs: this.v3 ? undefined : {
+        "for": this.inputId
+      }
+    })]]);
+    return kendo_vue_common_1.getTemplate.call(this, {
+      h: h,
+      template: renderTemplate,
+      defaultRendering: defaultRendering,
+      additionalProps: this.$props,
+      additionalListeners: {
+        selectionchange: this.changeHandle
+      }
+    });
+  }
+};
+exports.HeaderSelectionCellVue2 = HeaderSelectionCellVue2;
+/**
+ * @hidden
+ */
+
+var HeaderSelectionCell = HeaderSelectionCellVue2;
+exports.HeaderSelectionCell = HeaderSelectionCell;

package/dist/npm/header/HeaderThElement.js

@@ -66,7 +66,6 @@ var HeaderThElementVue2 = {
         colSpan = _a.colSpan,
         rowSpan = _a.rowSpan,
         className = _a.className,
-        style = _a.style,
         columnId = _a.columnId,
         navigatable = _a.navigatable,
         ariaColumnIndex = _a.ariaColumnIndex,
@@ -76,6 +75,9 @@ var HeaderThElementVue2 = {
     var navAttrs = this.getKeyboardNavigationAttributes(columnId, navigatable);
     var defaultSlot = (0, kendo_vue_common_1.getDefaultSlots)(this);
     return h("th", {
+      style: {
+        top: '0px'
+      },
       "aria-sort": ariaSort,
       attrs: this.v3 ? undefined : {
         "aria-sort": ariaSort,
@@ -95,7 +97,6 @@ var HeaderThElementVue2 = {
       colspan: colSpan,
       rowspan: rowSpan,
       "class": className,
-      style: style,
       onKeydown: this.onKeyDown,
       on: this.v3 ? undefined : {
         "keydown": this.onKeyDown

package/dist/npm/header/main.d.ts

@@ -0,0 +1,10 @@
+export * from '../interfaces/CellProps';
+export * from '../interfaces/ColumnProps';
+export * from './FilterRow';
+export * from './Header';
+export * from './HeaderCell';
+export * from './HeaderRow';
+export * from './HeaderSelectionCell';
+export * from '../interfaces/SortSettings';
+export * from './utils/main';
+export * from './HeaderThElement';

package/dist/npm/header/main.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../interfaces/CellProps"), exports);
+__exportStar(require("../interfaces/ColumnProps"), exports);
+__exportStar(require("./FilterRow"), exports);
+__exportStar(require("./Header"), exports);
+__exportStar(require("./HeaderCell"), exports);
+__exportStar(require("./HeaderRow"), exports);
+__exportStar(require("./HeaderSelectionCell"), exports);
+__exportStar(require("../interfaces/SortSettings"), exports);
+__exportStar(require("./utils/main"), exports);
+__exportStar(require("./HeaderThElement"), exports);

package/dist/npm/header/utils/main.d.ts

@@ -0,0 +1,34 @@
+import { ExtendedColumnProps, TreeColumnBaseProps } from '../../interfaces/ColumnProps';
+/**
+ * @hidden
+ */
+export declare function mapColumns(columns: Array<{
+    parentIndex: number;
+    colSpan: number;
+    rowSpan: number;
+    depth: number;
+    kFirst?: boolean;
+    children: any[];
+    width?: string | number;
+    locked?: boolean;
+    index: number;
+    left: number;
+    right: number;
+    rightBorder: boolean;
+    ariaColumnIndex: number;
+}>): number[][];
+/**
+ * @hidden
+ */
+export declare function readColumns(elements: TreeColumnBaseProps[], idInfo: {
+    prevId: number;
+    idPrefix: string;
+}, depth?: number): ExtendedColumnProps[];
+/**
+ * @hidden
+ */
+export declare function isRtl(element: HTMLElement | null): boolean;
+/**
+ * @hidden
+ */
+export declare function getIndex(event: any, parent: HTMLTableRowElement | HTMLDivElement | null): number;

package/dist/npm/header/utils/main.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndex = exports.isRtl = exports.readColumns = exports.mapColumns = void 0;
+var utils_1 = require("../../navigation/utils");
+var ColumnProps_1 = require("../../interfaces/ColumnProps");
+function nextColumn(columns, current) {
+    var currentDepth = columns[current].depth;
+    var next = null;
+    for (var index = current + 1; index < columns.length; index++) {
+        if (columns[index].depth === currentDepth) {
+            next = columns[index];
+            break;
+        }
+    }
+    return next;
+}
+var getColumnWidth = function (column) {
+    var width = column.width ? parseFloat(column.width.toString()) : 0;
+    if (!width && column.children && column.children.length) {
+        width = column.children.reduce(function (currentSum, child) { return getColumnWidth(child) + currentSum; }, 0);
+    }
+    return width;
+};
+/**
+ * @hidden
+ */
+function mapColumns(columns) {
+    var columnsMap = [[]];
+    var maxDepth = 0;
+    // set colspans, get maxdepth
+    for (var q = columns.length - 1; q >= 0; q--) {
+        maxDepth = Math.max(maxDepth, columns[q].depth);
+        columns[q].colSpan = columns[q].colSpan || 1;
+        if (columns[q].parentIndex !== -1) {
+            columns[columns[q].parentIndex].colSpan =
+                (columns[columns[q].parentIndex].colSpan || 0) + columns[q].colSpan;
+        }
+    }
+    var colIndexByLevel = [];
+    var rowSpan = 1;
+    // set rowspan, kFirst, index AND create columnsMap
+    columns.forEach(function (column, i) {
+        columnsMap[column.depth] = columnsMap[column.depth] || [];
+        var needKFirst = false;
+        if (columnsMap[column.depth].length === 0) {
+            if (rowSpan <= 1) {
+                rowSpan = 1 + (column.children.length > 0 ? 0 : maxDepth - column.depth);
+            }
+            else {
+                rowSpan--;
+                needKFirst = true;
+            }
+        }
+        column.rowSpan = 1 + (column.children.length > 0 ? 0 : maxDepth - column.depth);
+        column.kFirst = needKFirst;
+        column.index = columnsMap[column.depth].length;
+        columnsMap[column.depth].push(i);
+        column.ariaColumnIndex = colIndexByLevel[column.depth] ? colIndexByLevel[column.depth] + 1 : 1;
+        for (var ci = column.depth; ci < column.depth + column.rowSpan; ci++) {
+            colIndexByLevel[ci] = (colIndexByLevel[ci] || 0) + column.colSpan;
+        }
+    });
+    var stickyLeftWidth = new Array(columnsMap.length).fill(0);
+    var width = 0;
+    // set left AND create stickyLeftWidth
+    columns.forEach(function (column) {
+        if (column.locked) {
+            column.left = stickyLeftWidth[column.depth];
+            width = getColumnWidth(column);
+            if (column.children.length === 0) {
+                for (var i = column.depth; i < stickyLeftWidth.length; i++) {
+                    stickyLeftWidth[i] += width;
+                }
+            }
+            else {
+                stickyLeftWidth[column.depth] += width;
+            }
+        }
+    });
+    var stickyRightWidth = new Array(columnsMap.length).fill(0);
+    // set right, rightBorder AND create stickyRightWidth
+    for (var i = columns.length - 1; i >= 0; i--) {
+        var column = columns[i];
+        if (column.locked) {
+            column.right = stickyRightWidth[column.depth];
+            width = getColumnWidth(column);
+            if (column.children.length === 0) {
+                for (var j = column.depth; j < stickyRightWidth.length; j++) {
+                    stickyRightWidth[j] += width;
+                }
+            }
+            else {
+                stickyRightWidth[column.depth] += width;
+            }
+            var next = nextColumn(columns, i);
+            column.rightBorder = !(next && next.locked);
+        }
+    }
+    return columnsMap;
+}
+exports.mapColumns = mapColumns;
+/**
+ * @hidden
+ */
+function readColumns(elements, idInfo, depth) {
+    if (depth === void 0) { depth = 0; }
+    var columns = [];
+    if (!elements || !elements.length) {
+        return [];
+    }
+    elements.forEach(function (columnProps) {
+        var children = readColumns(columnProps.children || [], idInfo, depth + 1);
+        columns.push(Object.assign({}, { depth: depth }, ColumnProps_1.ColumnDefaultProps, columnProps, {
+            id: columnProps.id ? columnProps.id : (0, utils_1.generateNavigatableId)("".concat(idInfo.prevId++), idInfo.idPrefix, 'column'),
+            declarationIndex: columns.length,
+            children: children,
+            rowSpan: 0,
+            colSpan: 0,
+            isAccessible: true
+        }));
+    });
+    var comparator = function (a, b) {
+        return a.orderIndex === b.orderIndex ?
+            a.declarationIndex - b.declarationIndex :
+            ((a.orderIndex || 0) - (b.orderIndex || 0));
+    };
+    columns.sort(comparator);
+    if (depth === 0) {
+        var ret_1 = [];
+        var flat_1 = function (cols, pIndex) {
+            return cols.forEach(function (c) {
+                c.parentIndex = pIndex;
+                flat_1(c.children, ret_1.push(c) - 1);
+            });
+        };
+        flat_1(columns, -1);
+        return ret_1;
+    }
+    return columns;
+}
+exports.readColumns = readColumns;
+/**
+ * @hidden
+ */
+function isRtl(element) {
+    return Boolean(element && getComputedStyle(element).direction === 'rtl');
+}
+exports.isRtl = isRtl;
+/**
+ * @hidden
+ */
+function getIndex(event, parent) {
+    if (!parent || !event || !event.originalEvent) {
+        return -1;
+    }
+    var target = parent.ownerDocument
+        ? parent.ownerDocument.elementFromPoint(event.clientX, event.originalEvent.clientY)
+        : null;
+    while (target && target.parentElement !== parent) {
+        target = target.parentElement;
+    }
+    var children = parent.children;
+    for (var i = 0; i < children.length; i++) {
+        if (children[i] === target) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.getIndex = getIndex;

package/dist/npm/interfaces/CellProps.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @hidden
+ */
+export interface CellProps {
+    /**
+     * @hidden
+     */
+    id: string;
+    /**
+     * The index to be applied to the `aria-colindex` attribute.
+     */
+    ariaColumnIndex: number;
+    /**
+     * Indicates if the cell is selected.
+     */
+    isSelected: boolean;
+    /**
+     * The expanded value of the cell.
+     */
+    expanded?: boolean;
+    /**
+     * The custom CSS classes of the cells.
+     */
+    class?: string;
+    /**
+     * The field to which the cell is bound.
+     */
+    field?: string;
+    /**
+     * The data item which corresponds to the current row.
+     */
+    dataItem: any;
+    /**
+     * The format that is applied to the value before the value is displayed.
+     * Takes the `{0:format}` form where `format` is a standard number format, a custom number format,
+     * a standard date format, or a custom date format. For more information on the supported date and number formats,
+     * refer to the [kendo-intl](https://github.com/telerik/kendo-intl/blob/develop/docs/index.md) documentation.
+     */
+    format?: string;
+    /**
+     * The column span of the cell.
+     */
+    colSpan?: number;
+    /**
+     * The event that is fired when the cell is selected.
+     */
+    selectionChange?: (event: {
+        event: any;
+    }) => void;
+    /**
+     * The event that is fired when the cell value is changed.
+     */
+    onChange?: (event: {
+        dataItem: any;
+        event: any;
+        field?: string;
+        value?: any;
+    }) => void;
+    /**
+     * A function for overriding the default rendering of the cell.
+     */
+    render?: any;
+}

package/dist/npm/interfaces/ColumnMenuColumnProps.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The column props passed by the ColumnMenu.
+ */
+export interface ColumnMenuColumnProps {
+    /**
+     * The field to which the column is bound.
+     */
+    field?: string;
+    /**
+     * Defines the filter type that is displayed inside the filter row. Defaults to `text`.
+     */
+    filter?: 'text' | 'numeric' | 'boolean' | 'date';
+}

package/dist/npm/interfaces/ColumnMenuExtendedFilterProps.d.ts

@@ -0,0 +1,42 @@
+import { ColumnMenuFilterProps } from './ColumnMenuFilterProps';
+/**
+ * @hidden
+ */
+export interface ColumnMenuExtendedFilterProps extends ColumnMenuFilterProps {
+    /**
+     * Allows you to control the expand state of the filter component.
+     */
+    expanded?: boolean;
+    /**
+     * Triggered on each subsequent expand state of the filter component.
+     */
+    onExpandchange?: (nextExpandState: boolean) => void;
+    /**
+     * If set to `false`, the second filter operator and the input will be hidden.
+     */
+    hideSecondFilter?: boolean;
+    /**
+     * Specifies a Vue element that will be cloned and rendered inside the UI of the column-menu filter component.
+     */
+    filterUI?: any;
+}
+/**
+ * @hidden
+ */
+export interface ColumnMenuBooleanFilterProps extends ColumnMenuExtendedFilterProps {
+}
+/**
+ * @hidden
+ */
+export interface ColumnMenuDateFilterProps extends ColumnMenuExtendedFilterProps {
+}
+/**
+ * @hidden
+ */
+export interface ColumnMenuNumericFilterProps extends ColumnMenuExtendedFilterProps {
+}
+/**
+ * @hidden
+ */
+export interface ColumnMenuTextFilterProps extends ColumnMenuExtendedFilterProps {
+}

package/dist/npm/interfaces/ColumnMenuFilterBaseProps.d.ts

@@ -0,0 +1,49 @@
+import { CompositeFilterDescriptor } from '@progress/kendo-data-query';
+import { PopupAnimation } from '@progress/kendo-vue-popup';
+import { ColumnMenuColumnProps } from './ColumnMenuColumnProps';
+import { FilterOperators } from './FilterOperators';
+/**
+ * The props passed to the ColumnMenu filter component.
+ */
+export interface ColumnMenuFilterBaseProps {
+    /**
+     * Controls the ColumnMenu animation. By default, the opening and closing animations are enabled.
+     */
+    animate?: boolean | PopupAnimation;
+    /**
+     * The current column options.
+     */
+    column: ColumnMenuColumnProps;
+    /**
+     * The method that will be called to close the column menu.
+     */
+    onClosemenu?: Function;
+    /**
+     * The current filter state of the .
+     */
+    filter?: CompositeFilterDescriptor;
+    /**
+     * The filterable option of the column.
+     */
+    filterable?: boolean | undefined;
+    /**
+     * The filter operators for the  filters.
+     */
+    filterOperators: FilterOperators;
+    /**
+     * The template that can customize the check all checkbox item.
+     */
+    checkAllItem?: string | object | Function | boolean;
+    /**
+     * The template that can customize the checkbox item.
+     */
+    item?: string | object | Function | boolean;
+    /**
+     * The trigger focus event.
+     */
+    onFocus?: (e: any) => void;
+    /**
+     * The method that will be called to notify the parent  about a filter change.
+     */
+    onFilterchange?: (filter: CompositeFilterDescriptor | null, syntheticEvent: any) => any;
+}

package/dist/npm/interfaces/ColumnMenuFilterBaseProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/interfaces/ColumnMenuFilterProps.d.ts

@@ -0,0 +1,27 @@
+import { CompositeFilterDescriptor } from '@progress/kendo-data-query';
+import { ColumnBaseProps } from './ColumnProps';
+/**
+ * @hidden
+ */
+export interface ColumnMenuFilterProps {
+    /**
+     * The current column options.
+     */
+    column: ColumnBaseProps;
+    /**
+     * The method that will be called to close the column menu.
+     */
+    onCloseMenu?: Function;
+    /**
+     * The current filter state of the .
+     */
+    filter?: CompositeFilterDescriptor;
+    /**
+     * The filterable option of the column.
+     */
+    filterable?: boolean | undefined;
+    /**
+     * The method that will be called to notify the parent  about a filter change.
+     */
+    onFilterchange?: (filter: CompositeFilterDescriptor | null, event: any) => any;
+}

package/dist/npm/interfaces/ColumnMenuFilterProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/interfaces/ColumnMenuFilterUIProps.d.ts

@@ -0,0 +1,55 @@
+import { FilterCellProps } from './FilterCellProps';
+/**
+ * The props that will be passed to the UI of the ColumnMenu filter component.
+ */
+export interface ColumnMenuFilterUIProps {
+    /**
+     * The options of the first filter.
+     */
+    firstFilterProps: FilterCellProps;
+    /**
+     * The options of the second filter.
+     */
+    secondFilterProps: FilterCellProps;
+    /**
+     * The current value of the filter logic.
+     */
+    logicValue?: {
+        text: string;
+        operator: any;
+    };
+    /**
+     * The list of the filter logic options.
+     */
+    logicData: {
+        text: string;
+        operator: any;
+    }[];
+    /**
+     * The method that will be called to notify the parent about a change in the filter logic.
+     */
+    onLogicchange?: (e: any) => void;
+    /**
+     * The method that will be called to notify the parent about a change in the filter.
+     */
+    onChange?: (e: any, filterIndex: number) => void;
+    /**
+     * The trigger focus event.
+     */
+    onFocus?: (e: any) => void;
+    /**
+     * Indicates if the second filter will be hidden.
+     */
+    hideSecondFilter?: boolean;
+    /**
+     * The list of the default operators for the current filter type.
+     */
+    operators: Array<{
+        text: string;
+        operator: any;
+    }>;
+    /**
+     * The method for rendering the cell.
+     */
+    render?: any;
+}

package/dist/npm/interfaces/ColumnMenuFilterUIProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/interfaces/ColumnMenuProps.d.ts

@@ -0,0 +1,19 @@
+import { ColumnMenuFilterBaseProps } from './ColumnMenuFilterBaseProps';
+import { ColumnMenuSortBaseProps } from './ColumnMenuSortBaseProps';
+/**
+ * The props which the ColumnMenu passes to its children.
+ */
+export interface ColumnMenuProps extends ColumnMenuFilterBaseProps, ColumnMenuSortBaseProps {
+    /**
+     * The key of the column menu.
+     */
+    key?: any;
+    /**
+     * The method for rendering the column menu.
+     */
+    render?: any;
+    /**
+     * The opened column menu.
+     */
+    opened?: boolean;
+}