jsl-ui 9.18.2 → 9.18.3

package/lib/grid/slick.creator.js

@@ -1,723 +0,0 @@
-import { Slick } from "./slick.core";
-import { SlickGrid } from "./slick.grid";
-import { RowSelectionModel } from "./plugins/slick.rowselectionmodel";
-import { DataView } from "./slick.dataview";
-import { GroupItemMetadataProvider } from "./slick.groupitemmetadataprovider";
-import { jQueryReplacement } from "../core/jq";
-import { HeaderMenu } from "./plugins/slick.headermenu";
-import { HeaderButtons } from "./plugins/slick.headerbuttons";
-import { TextFormatter } from "./slick.formatters";
-import { ExcelFilter } from "./filterDialogs/excelFilter";
-import { UILang } from "../core/lang";
-import { RowMoveManager } from "./plugins/slick.rowmovemanager";
-import { Overlays } from "./plugins/ext.overlay";
-var $ = jQueryReplacement;
-export function createJSLGrid(selector, data, columns, option) {
-    var formulaObjects = [];
-    var headerMenu;
-    var headerButtons;
-    var formulas = {};
-    var container;
-    var filters = [];
-    var customCommandHandler;
-    var grid;
-    var dataView;
-    var rowMoveManager;
-    //let options: ISlickCreatorOptions;
-    function createMe() {
-        sanitizeColumns(columns);
-        var options = $.shallowExtend({ explicitInitialization: true, mode: "client" }, option);
-        container = typeof (selector) === "string" ?
-            document.querySelector(selector) :
-            selector;
-        if (!container) {
-            throw new Error("error: selector for SlickCreator is invalid");
-        }
-        if (options.showColumnGroups) {
-            options.createPreHeaderPanel = true;
-            options.showPreHeaderPanel = true;
-        }
-        customCommandHandler = option.editCommandHandler;
-        options.editCommandHandler = function (a, b, c) { handleEditCommand(a, b, c); };
-        var groupItemMetadataProvider = options.groupItemMetadataProvider || GroupItemMetadataProvider(options.groupItemOptions);
-        if (options.dataView != null) {
-            dataView = options.dataView;
-        }
-        else {
-            dataView = new DataView({ inlineFilters: true, groupItemMetadataProvider: groupItemMetadataProvider });
-            dataView.setItems(data, options.primaryKey);
-        }
-        grid = new SlickGrid(container, dataView, columns, options);
-        grid.registerPlugin(groupItemMetadataProvider);
-        grid.setSelectionModel(new RowSelectionModel());
-        grid.onHeaderCellRendered.subscribe(function (e, args) {
-            if (columnHasFilter(args.column.id)) {
-                //this column is filtered
-                args.node.classList.add("slick-filtered-header");
-            }
-        });
-        addCustomEvents();
-        setupDefaultSort();
-        setupChangeEvents();
-        if (options.showHeaderMenu) {
-            setupHeaderMenu();
-        }
-        setupHeaderButtons();
-        if (options.allowRowMove) {
-            rowMoveManager = new RowMoveManager({
-                cancelEditOnDrag: true,
-                singleRowMove: true,
-                disableRowSelection: true,
-                hideRowMoveShadow: false,
-                rowMoveShadowScale: 0.7,
-                rowMoveShadowOpacity: 0.9 // defaults to 0.95
-            });
-            grid.registerPlugin(rowMoveManager);
-            rowMoveManager.onBeforeMoveRows.subscribe(function (e, args) {
-                // debugger;
-            });
-            rowMoveManager.onMoveRows.subscribe(function (e, args) {
-                var extractedRows = [], left, right;
-                var rows = args.rows;
-                var insertBefore = args.insertBefore;
-                left = data.slice(0, insertBefore);
-                right = data.slice(insertBefore, data.length);
-                rows.sort(function (a, b) { return a - b; });
-                for (var i = 0; i < rows.length; i++) {
-                    extractedRows.push(data[rows[i]]);
-                }
-                rows.reverse();
-                for (var i = 0; i < rows.length; i++) {
-                    var row = rows[i];
-                    if (row < insertBefore) {
-                        left.splice(row, 1);
-                    }
-                    else {
-                        right.splice(row - insertBefore, 1);
-                    }
-                }
-                data = left.concat(extractedRows.concat(right));
-                var selectedRows = [];
-                for (var i = 0; i < rows.length; i++)
-                    selectedRows.push(left.length + i);
-                // grid.resetActiveCell();
-                dataView.beginUpdate();
-                dataView.setItems(data);
-                dataView.endUpdate();
-                grid.render();
-            });
-        }
-        if (option.enableFillDown) {
-            var overlayPlugin = new Overlays({});
-            // Event fires when a range is selected
-            overlayPlugin.onFillUpDown.subscribe(function (e, args) {
-                var column = grid.getColumns()[args.range.fromCell];
-                // Ensure the column is editable
-                if (column.editor == null || column.readonly || !grid.getOptions().editable) {
-                    return;
-                }
-                // Find the initial value
-                dataView.beginUpdate();
-                var value;
-                var items = [];
-                if (args.direction === "down") {
-                    var item = dataView.getItem(args.range.fromRow);
-                    value = grid.getDataItemValueForColumn(item, column); // item[column.field];
-                    // Copy the value down
-                    for (var i = args.range.fromRow + 1; i <= args.range.toRow; i++) {
-                        if (grid.onBeforeEditCell.notify({ row: i, cell: args.range.fromCell, item: dataView.getItem(i), column: column }, e) !== false) {
-                            var currentItem = dataView.getItem(i);
-                            items.push(currentItem);
-                            // if (options.setDataItemValueForColumn != null) {
-                            //     options.setDataItemValueForColumn(currentItem, column, value);
-                            // } else {
-                            //     dataView.getItem(i)[column.field] = value;
-                            // }
-                            // grid.invalidateRow(i);
-                            // grid.onAfterEdit.notify({ grid, oldValue, newValue: value, column, item: dataView.getItem(i) }, e);
-                        }
-                    }
-                }
-                else {
-                    var item = dataView.getItem(args.range.toRow);
-                    items.push(item);
-                    value = grid.getDataItemValueForColumn(item, column); // item[column.field];
-                    // Copy the value up
-                    for (var i = args.range.fromRow; i <= args.range.toRow - 1; i++) {
-                        if (grid.onBeforeEditCell.notify({ row: i, cell: args.range.fromCell, item: dataView.getItem(i), column: column }, e) !== false) {
-                            var currentItem = dataView.getItem(i);
-                            items.push(currentItem);
-                            // if (options.setDataItemValueForColumn != null) {
-                            //     options.setDataItemValueForColumn(currentItem, column, value);
-                            // } else {
-                            //     dataView.getItem(i)[column.field] = value;
-                            // }
-                            // grid.invalidateRow(i);
-                            // grid.onAfterEdit.notify({ grid, oldValue, newValue: value, column, item: dataView.getItem(i) }, e);
-                        }
-                    }
-                }
-                grid.onAfterFillDown.notify({ grid: grid, value: value, column: column, direction: args.direction, range: args.range, items: items }, e);
-                dataView.endUpdate();
-                grid.render();
-            });
-            grid.registerPlugin(overlayPlugin);
-        }
-        if (!option.explicitInitialization) {
-            grid.init();
-        }
-        if (options.showColumnGroups) {
-            setTimeout(function () {
-                // TODO -> find better solution then timeout
-                grid.onColumnsResized.subscribe(function () {
-                    CreateColumnGroups();
-                });
-                CreateColumnGroups();
-            }, 1);
-        }
-        if (options.saveColumnsKey) {
-            grid.onColumnsResized.subscribe(function () {
-                storeColumnSettings();
-            });
-            grid.onColumnsReordered.subscribe(function () {
-                storeColumnSettings();
-            });
-            loadColumnSettings();
-        }
-    }
-    function CreateColumnGroups() {
-        var options = grid.getOptions();
-        var columns = grid.getColumns();
-        if (options.frozenColumn >= 0) {
-            // Add column groups to left panel
-            var $preHeaderPanel = $(grid.getPreHeaderPanel());
-            renderHeaderGroups($preHeaderPanel, 0, options.frozenColumn + 1);
-            // Add column groups to right panel
-            $preHeaderPanel = $(grid.getPreHeaderPanelRight());
-            renderHeaderGroups($preHeaderPanel, options.frozenColumn + 1, columns.length);
-        }
-        else {
-            var $preHeaderPanel = $(grid.getPreHeaderPanel());
-            renderHeaderGroups($preHeaderPanel, 0, columns.length);
-        }
-        function renderHeaderGroups(preHeaderPanel, start, end) {
-            preHeaderPanel.empty()
-                .addClass("slick-header-columns")
-                .css("left", "-1000px")
-                .width(grid.getHeadersWidth());
-            preHeaderPanel[0].parentElement.classList.add("slick-header");
-            var headerColumnWidthDiff = grid.getHeaderColumnWidthDiff();
-            var header;
-            var lastColumnGroup = "";
-            var widthTotal = 0;
-            for (var i = start; i < end; i++) {
-                var m = columns[i];
-                if (lastColumnGroup === m.columnGroup && i > start) {
-                    widthTotal += m.width;
-                    header.width(widthTotal - headerColumnWidthDiff);
-                }
-                else {
-                    widthTotal = m.width;
-                    header = $("<div class='ui-state-default slick-header-column' />")
-                        .html("<span class='slick-column-name'>" + (m.columnGroup || '') + "</span>")
-                        .width(m.width - headerColumnWidthDiff)
-                        .appendTo(preHeaderPanel);
-                }
-                lastColumnGroup = m.columnGroup;
-            }
-        }
-    }
-    function storeColumnSettings() {
-        var cols = grid.getColumns();
-        var options = grid.getOptions();
-        var colSettings = cols.map(function (c) { return ({ id: c.id, width: c.width }); });
-        if (window.localStorage) {
-            localStorage.setItem("_grid_col_settings_" + options.saveColumnsKey, JSON.stringify(colSettings));
-        }
-    }
-    function loadColumnSettings() {
-        if (!window.localStorage) {
-            return;
-        }
-        var options = grid.getOptions();
-        var key = options.saveColumnsKey;
-        if (key) {
-            var cols = grid.getColumns();
-            var colSettings = JSON.parse(localStorage.getItem("_grid_col_settings_" + key));
-            if (!colSettings) {
-                return;
-            }
-            for (var i = 0; i < colSettings.length; i++) {
-                for (var j = 0; j < cols.length; j++) {
-                    if (cols[j].id === colSettings[i].id) {
-                        var c = cols[j];
-                        c.width = colSettings[i].width;
-                        if (i !== j) {
-                            cols.splice(j, 1);
-                            cols.splice(i, 0, c);
-                        }
-                        break;
-                    }
-                }
-            }
-            grid.setColumns(cols);
-        }
-    }
-    function sanitizeColumns(cols) {
-        for (var i = 0; i < cols.length; i++) {
-            var c = cols[i];
-            if (c.field === undefined && c.id) {
-                c.field = c.id;
-            }
-        }
-    }
-    function addCustomEvents() {
-        grid.onAfterEdit = new Slick.Event();
-        grid.onFiltersChanged = new Slick.Event();
-        grid.onAfterFillDown = new Slick.Event();
-    }
-    function setupChangeEvents() {
-        dataView.onRowsChanged.subscribe(function (e, args) {
-            grid.invalidateRows(args.rows);
-            grid.render();
-            // for (let idx = 0; idx < args.rows.length; idx++) {
-            //     grid.updateRow(args.rows[idx]);
-            // }
-            // grid.invalidate();
-        });
-        dataView.onRowCountChanged.subscribe(function (e, args) {
-            grid.updateRowCount();
-            grid.render();
-        });
-        grid.onAddNewRow.subscribe(function (e, args) {
-            var options = grid.getOptions();
-            if (options.provideDefaultValues != null) {
-                var result = options.provideDefaultValues(args.item);
-                if (result === false) {
-                    return;
-                }
-            }
-            dataView.addItem(args.item);
-            grid.onAfterEdit.notify({
-                grid: grid,
-                oldValue: undefined,
-                newValue: grid.getDataItemValueForColumn(args.item, args.column),
-                column: args.column,
-                item: args.item
-            });
-        });
-    }
-    function setupDefaultSort() {
-        var options = grid.getOptions();
-        if (options.mode === "client") {
-            grid.onSort.subscribe(function (e, args) {
-                sort(args.sortCol, args.sortAsc);
-            });
-        }
-        // TODO: multi column sort
-    }
-    function setupHeaderButtons() {
-        headerButtons = new HeaderButtons({});
-        grid.registerPlugin(headerButtons);
-    }
-    function setupHeaderMenu() {
-        headerMenu = new HeaderMenu({});
-        grid.registerPlugin(headerMenu);
-        headerMenu.onBeforeMenuShow.subscribe(function (e, args) {
-            var column = args.column;
-            var menu = args.menu;
-            if (column.sortable) {
-                menu.items.push({
-                    title: UILang.grid.Sort + " " + UILang.grid.Asc,
-                    command: "sort-asc"
-                });
-                menu.items.push({
-                    title: UILang.grid.Sort + " " + UILang.grid.Desc,
-                    command: "sort-desc"
-                });
-            }
-            if (column.filterable) {
-                menu.items.push({
-                    title: UILang.grid.Filter,
-                    command: "filter"
-                });
-                if (filters.filter(function (f) { return f.columnId === column.id; }).length > 0) {
-                    menu.items.push({
-                        title: UILang.grid.ClearFilter,
-                        command: "clear-filter"
-                    });
-                }
-            }
-        });
-        headerMenu.onCommand.subscribe(function (e, args) {
-            if (args.command === "sort-asc" || args.command === "sort-desc") {
-                grid.onSort.notify({
-                    sortAsc: args.command === "sort-asc",
-                    sortCol: args.column,
-                    columnId: args.column.id,
-                    sortCols: [{ columnId: args.column.id, sortCol: args.column, sortAsc: args.command === "sort-asc" }],
-                    multiColumnSort: false
-                }, e);
-                // sort(args.column, args.command === "sort-asc");
-            }
-            else if (args.command === "filter") {
-                var options = grid.getOptions();
-                if (options.showFilterDialog != null) {
-                    options.showFilterDialog(args.column, grid);
-                }
-                else {
-                    new ExcelFilter(grid).show(args.column);
-                }
-            }
-            else if (args.command === "clear-filter") {
-                clearFilter(args.column.id);
-            }
-        });
-    }
-    // refresh formulas depending on the given column
-    function triggerFormula(column, item) {
-        var options = grid.getOptions();
-        var f = formulas[column];
-        if (f) {
-            for (var i = 0, l = f.length; i < l; i++) {
-                if (options.setDataItemValueForColumn != null) {
-                    options.setDataItemValueForColumn(item, f[i].column, f[i].fnc(item, column));
-                }
-                else {
-                    item[f[i].column] = f[i].fnc(item, column);
-                }
-            }
-        }
-    }
-    function handleEditCommand(item, column, editCommand) {
-        var options = grid.getOptions();
-        var oldVal = grid.getDataItemValueForColumn(item, column);
-        if (customCommandHandler) {
-            customCommandHandler(item, column, editCommand);
-        }
-        else {
-            editCommand.execute();
-        }
-        triggerFormula(column.field, item);
-        dataView.updateItem(item[options.primaryKey], item);
-        var afterEditResult = grid.onAfterEdit.notify({
-            grid: grid,
-            oldValue: oldVal,
-            newValue: grid.getDataItemValueForColumn(item, column),
-            column: column,
-            item: item
-        });
-        if (afterEditResult === false) {
-            if (options.setDataItemValueForColumn != null) {
-                options.setDataItemValueForColumn(item, column, oldVal);
-            }
-            else {
-                item[column.field] = oldVal;
-            }
-            triggerFormula(column.field, item);
-            dataView.updateItem(item[options.primaryKey], item);
-        }
-    }
-    function setHeight(height) {
-        $(container).height(height);
-        grid.resizeCanvas();
-    }
-    function getHeight() {
-        return $(container).height();
-    }
-    function sort(column, sortAsc) {
-        function _comparer(a, b) {
-            var x = grid.getDataItemValueForColumn(a, column);
-            var y = grid.getDataItemValueForColumn(b, column);
-            if (typeof x === "string" && typeof y === "string") {
-                x = x.toLocaleLowerCase();
-                y = y.toLocaleLowerCase();
-            }
-            if (x == null && y != null) {
-                return -1;
-            }
-            else if (x != null && y == null) {
-                return 1;
-            }
-            else {
-                return (x === y ? 0 : (x > y ? 1 : -1));
-            }
-        }
-        function _visibleComparer(a, b) {
-            var x = column.formatter(0, 0, grid.getDataItemValueForColumn(a, column), column, a);
-            var y = column.formatter(0, 0, grid.getDataItemValueForColumn(b, column), column, b);
-            var xStr = (Object.prototype.toString.call(x) !== "[object Object]" ? x : x.text);
-            var yStr = (Object.prototype.toString.call(y) !== "[object Object]" ? y : y.text);
-            if (typeof x === "string" && typeof y === "string") {
-                xStr = x.toLocaleLowerCase();
-                yStr = y.toLocaleLowerCase();
-            }
-            return (xStr === yStr ? 0 : (xStr > yStr ? 1 : -1));
-        }
-        var comparer = column.comparer || (column.sortByVisibleValue ? _visibleComparer : _comparer);
-        dataView.sort(comparer, sortAsc ? true : false);
-    }
-    function setData(newData) {
-        data = newData;
-        dataView.setItems(data);
-        refresh();
-    }
-    function getData() {
-        return data;
-    }
-    function refreshData() {
-        // var selrows = self.getSelectedRows();
-        dataView.setItems(data);
-        // self.setSelectedRows(selrows);
-        refresh();
-    }
-    function refresh() {
-        grid.invalidate();
-    }
-    function addFormula(field, fnc, usedColumns) {
-        formulaObjects.push({ fnc: fnc, column: field });
-        for (var i = 0; i < usedColumns.length; i++) {
-            if (!formulas[usedColumns[i]]) {
-                formulas[usedColumns[i]] = [];
-            }
-            formulas[usedColumns[i]].push({ fnc: fnc, column: field });
-        }
-    }
-    /**
-     * returns the string representation of a value based on column settings
-     */
-    function getFormattedValue(column, value, item) {
-        var formatter = column.formatter || TextFormatter;
-        var formatterResult = formatter(0, 0, value, column, item, grid);
-        return (Object.prototype.toString.call(formatterResult) !== "[object Object]" ?
-            formatterResult :
-            (formatterResult.text));
-    }
-    function getContentWidth(column, row) {
-        var item = dataView.getItem(row);
-        var html = getFormattedValue(column, grid.getDataItemValueForColumn(item, column), item);
-        if (html.indexOf("<") >= 0) {
-            return calcLengthInternal(html, true) + 12;
-        }
-        else {
-            if (convertElement == null) {
-                convertElement = document.createElement("span");
-            }
-            convertElement.innerHTML = html;
-            return calcTextLength(convertElement.textContent) + 12;
-        }
-    }
-    var measureElement;
-    var convertElement;
-    var charWidth = {};
-    function calcTextLength(text) {
-        var result = 0;
-        for (var i = 0; i < text.length; i++) {
-            var c = text[i];
-            var w = charWidth[c];
-            if (w == null) {
-                charWidth[c] = w = calcLengthInternal(c, false);
-            }
-            result += w;
-        }
-        return result;
-    }
-    function calcLengthInternal(c, isHTML) {
-        if (measureElement == null) {
-            measureElement = document.createElement("span");
-            measureElement.style.top = "-100000px";
-            measureElement.style.position = "absolute";
-            measureElement.style.whiteSpace = "pre";
-            document.body.appendChild(measureElement);
-            grid.onBeforeDestroy.subscribe(function () {
-                if (measureElement.parentElement != null) {
-                    measureElement.parentElement.removeChild(measureElement);
-                }
-            });
-        }
-        if (isHTML) {
-            measureElement.innerHTML = c;
-        }
-        else {
-            measureElement.textContent = c;
-        }
-        return measureElement.getBoundingClientRect().width;
-    }
-    function fitToContent(column) {
-        var width = 10;
-        for (var idx = 0, len = grid.getDataLength(); idx < len; idx++) {
-            //const d = grid.getDataItem(idx);
-            width = Math.max(width, getContentWidth(column, idx));
-        }
-        column.width = width;
-        grid.setColumns(grid.getColumns());
-        // TODO: raise column resize event
-        // TODO (2): find more performant way to refresh columns
-    }
-    function triggerAllFormulas() {
-        if (formulaObjects.length === 0) {
-            return;
-        }
-        for (var j = 0; j < formulaObjects.length; j++) {
-            for (var i = 0; i < data.length; i++) {
-                var val = formulaObjects[j].fnc(data[i], grid, formulaObjects[j].column);
-                data[i][formulaObjects[j].column] = val;
-            }
-        }
-        refreshData();
-    }
-    function columnHasFilter(columnId) {
-        for (var i = 0, l = (filters ? filters.length : 0); i < l; i++) {
-            if (filters[i].columnId === columnId) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function refreshDataItem(item) {
-        var options = grid.getOptions();
-        dataView.updateItem(item[options.primaryKey], item);
-        // formula refresh
-        for (var f in formulas) {
-            if (formulas.hasOwnProperty(f)) {
-                triggerFormula(f, item);
-            }
-        }
-        grid.updateRow(dataView.getRowByItem(item));
-    }
-    function addFilter(filter, dontrefresh) {
-        var filterArray;
-        if (Array.isArray(filter)) {
-            filterArray = filter;
-        }
-        else {
-            filterArray = [filter];
-        }
-        for (var idx = 0; idx < filterArray.length; idx++) {
-            // add filter
-            filters.push(filterArray[idx]);
-        }
-        if (!dontrefresh) {
-            refreshFilters();
-        }
-    }
-    function setFilters(f, dontrefresh) {
-        filters = f;
-        if (!dontrefresh) {
-            refreshFilters();
-        }
-    }
-    function getFilters() {
-        return filters;
-    }
-    function clearFilter(columnId, dontrefresh) {
-        if (columnId === undefined) { // clear all filters
-            filters.length = 0;
-        }
-        else {
-            for (var i = 0; i < filters.length; i++) {
-                if (filters[i].columnId === columnId) {
-                    filters.splice(i, 1);
-                    i--;
-                }
-            }
-        }
-        if (!dontrefresh) {
-            refreshFilters();
-        }
-    }
-    function refreshFilters(noColumnHeaderRefresh) {
-        var options = grid.getOptions();
-        function client_filter(item, args) {
-            var filterArray = args;
-            // no filter present -> show all rows
-            if (filterArray.length === 0) {
-                return true;
-            }
-            if (filterArray.length === 1) {
-                return filterArray[0].match.call(null, item, filterArray[0].field);
-            }
-            else {
-                var result = true;
-                var i = 0;
-                while (i < filterArray.length) {
-                    var orResult = false;
-                    while (i < filterArray.length) { // combine or(s)
-                        if (orResult || filterArray[i].match.call(null, item, filterArray[i].field)) {
-                            orResult = true;
-                        }
-                        if (filterArray[i].combine !== "or") {
-                            break;
-                        }
-                        else {
-                            i++;
-                        }
-                    }
-                    if (!orResult) {
-                        result = false;
-                        break;
-                    }
-                    i++;
-                }
-                return result;
-            }
-        }
-        if (options.mode === "client") {
-            dataView.setFilterArgs(filters);
-            dataView.setFilter(client_filter);
-        }
-        // redraw columns
-        if (!noColumnHeaderRefresh) {
-            grid.setColumns(grid.getColumns());
-        }
-        grid.onFiltersChanged.notify();
-    }
-    function getSelectedItems() {
-        var selRows = grid.getSelectedRows();
-        var rows = [];
-        for (var i = 0; i < selRows.length; i++) {
-            var rowIdx = selRows[i];
-            var toPush = dataView.getItem(rowIdx);
-            if (toPush !== undefined && !toPush.__group && !toPush.__groupTotals) {
-                rows.push(toPush);
-            }
-        }
-        return rows;
-    }
-    function getRowMoveManager() {
-        return rowMoveManager;
-    }
-    function getHeaderMenu() {
-        return headerMenu;
-    }
-    // function setHierachy(o: IGridTreeOptions): GridTree {
-    //     return new GridTree(this, o);
-    // }
-    createMe();
-    return $.shallowExtend(grid, {
-        dataView: dataView,
-        setHeight: setHeight,
-        getHeight: getHeight,
-        sort: sort,
-        refreshData: refreshData,
-        setData: setData,
-        getData: getData,
-        refresh: refresh,
-        addFormula: addFormula,
-        getFormattedValue: getFormattedValue,
-        getContentWidth: getContentWidth,
-        fitToContent: fitToContent,
-        triggerAllFormulas: triggerAllFormulas,
-        columnHasFilter: columnHasFilter,
-        refreshDataItem: refreshDataItem,
-        addFilter: addFilter,
-        setFilters: setFilters,
-        getFilters: getFilters,
-        clearFilter: clearFilter,
-        refreshFilters: refreshFilters,
-        getSelectedItems: getSelectedItems,
-        getRowMoveManager: getRowMoveManager,
-        getHeaderMenu: getHeaderMenu // ,
-        // setHierachy
-    });
-}