@sme.up/ketchup 9.1.0 → 9.3.0

package/dist/esm/f-paginator-utils-6903534b.js

@@ -0,0 +1,1564 @@
+import { B as Filters, E as FilterInterval, C as getValueForDisplay, A as getValueForDisplay2, ac as getCellValueForDisplay, u as getColumnByName, w as KupObjects, ae as KupData, af as compareCell, I as TotalMode, $ as SortMode, ag as KupLanguagePage, q as KupLanguageRow, l as KupLanguageGeneric } from './kup-manager-bfea4e6f.js';
+import { K as KupDatesFormats } from './kup-dates-15f89ea2.js';
+import { h } from './index-59f83f91.js';
+import { F as FButton } from './f-button-5ccc2e50.js';
+import { F as FButtonStyling } from './f-button-declarations-9bdc6f26.js';
+
+/**
+ * Filtering algorithms related to column menus.
+ * @module FiltersColumnMenu
+ * @todo Should contain EVERY column-specific filtering method.
+ */
+class FiltersColumnMenu extends Filters {
+    /**
+     * Gets the value of the filter prop.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     * @returns {string} Value of the filter.
+     */
+    getTextFilterValue(filters = {}, column) {
+        return this._getTextFilterValue(filters, column, false);
+    }
+    /**
+     * Gets the value of the filter prop, set temporarly.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     * @returns {string} Value of the filter.
+     */
+    getTextFilterValueTmp(filters = {}, column) {
+        return this._getTextFilterValue(filters, column, true);
+    }
+    _getTextFilterValue(filters = {}, column, tmp) {
+        let value = '';
+        if (filters == null) {
+            return value;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            return value;
+        }
+        value = tmp ? filter.textFieldTmp : filter.textField;
+        return value;
+    }
+    /**
+     * Returns whether a column has filters or not.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {KupDataColumn} column - Name of the column.
+     * @returns {boolean} True when a given column has filters.
+     */
+    hasFiltersForColumn(filters = {}, column) {
+        return this._hasFiltersForColumn(filters, column, false);
+    }
+    /**
+     * Returns whether a column has filters or not.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {KupDataColumn} column - Name of the column.
+     * @returns {boolean} True when a given column has filters.
+     */
+    hasFiltersForColumnTmp(filters = {}, column) {
+        return this._hasFiltersForColumn(filters, column, true);
+    }
+    /**
+     * Returns whether a column has filters or not.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {KupDataColumn} column - Name of the column.
+     * @returns {boolean} True when a given column has filters.
+     */
+    _hasFiltersForColumn(filters = {}, column, tmp) {
+        if (!column) {
+            return false;
+        }
+        let textfield = this._getTextFilterValue(filters, column.name, tmp);
+        if (textfield != null && textfield.trim() != '') {
+            return true;
+        }
+        if (this._hasIntervalTextFieldFilterValues(filters, column, tmp)) {
+            return true;
+        }
+        let checkboxes = this.getCheckBoxFilterValues(filters, column.name);
+        if (checkboxes == null || checkboxes.length < 1) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Returns the values of column menu's checkboxes.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     * @returns {Array<string>} Array of checkboxes values.
+     */
+    getCheckBoxFilterValues(filters = {}, column) {
+        let values = [];
+        if (filters == null) {
+            return values;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            return values;
+        }
+        if (filter.checkBoxes == null) {
+            return values;
+        }
+        values = filter.checkBoxes;
+        return values;
+    }
+    /**
+     * Returns whether a text field should be a date or time picker.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {KupDataColumn} column - Name of the column.
+     * @returns {boolean} True when the text field is a date or time picker.
+     */
+    hasIntervalTextFieldFilterValues(filters = {}, column) {
+        return this._hasIntervalTextFieldFilterValues(filters, column, false);
+    }
+    hasIntervalTextFieldFilterValuesTmp(filters = {}, column) {
+        return this._hasIntervalTextFieldFilterValues(filters, column, true);
+    }
+    _hasIntervalTextFieldFilterValues(filters = {}, column, tmp) {
+        if (column == null) {
+            return false;
+        }
+        if (!this.isColumnFiltrableByInterval(column)) {
+            return false;
+        }
+        let intervalFrom = this._getIntervalTextFieldFilterValue(filters, column.name, FilterInterval.FROM, tmp);
+        if (intervalFrom != null && intervalFrom.trim() != '') {
+            return true;
+        }
+        let intervalTo = this._getIntervalTextFieldFilterValue(filters, column.name, FilterInterval.TO, tmp);
+        if (intervalTo != null && intervalTo.trim() != '') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Triggers when a new filter checkbox becomes checked.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     * @param {ValueDisplayedValue} newFilter - Added filter.
+     */
+    addCheckboxFilter(filters = {}, column, newFilterItem) {
+        if (filters == null) {
+            return;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            filter = {
+                textField: '',
+                textFieldTmp: '',
+                checkBoxes: [],
+                interval: null,
+                intervalTmp: null,
+            };
+            filters[column] = filter;
+        }
+        if (filter.checkBoxes == null) {
+            filter.checkBoxes = [];
+        }
+        if (newFilterItem == null || newFilterItem.value == null) {
+            filter.checkBoxes = [];
+        }
+        else {
+            if (!Filters.valuesArrayContainsValue(filter.checkBoxes, newFilterItem.value)) {
+                filter.checkBoxes[filter.checkBoxes.length] = newFilterItem;
+            }
+        }
+    }
+    /**
+     * Triggers when a filter checkbox becomes unchecked.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     * @param {string} remFilter - Removed filter.
+     */
+    removeCheckboxFilter(filters = {}, column, remFilter) {
+        if (filters == null || remFilter == null) {
+            return;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            return;
+        }
+        if (filter.checkBoxes == null) {
+            filter.checkBoxes = [];
+        }
+        let index = Filters.indexOfValueInValuesArray(filter.checkBoxes, remFilter);
+        if (index >= 0) {
+            let chs = [];
+            for (let i = 0; i < filter.checkBoxes.length; i++) {
+                if (i != index) {
+                    chs[chs.length] = filter.checkBoxes[i];
+                }
+            }
+            filter.checkBoxes = [...chs];
+        }
+    }
+    isColumnFiltrableByInterval(column) {
+        return this.isObjFiltrableByInterval(column.obj);
+    }
+    getIntervalTextFieldFilterValues(filters = {}, column) {
+        return this._getIntervalTextFieldFilterValues(filters, column, false);
+    }
+    getIntervalTextFieldFilterValuesTmp(filters = {}, column) {
+        return this._getIntervalTextFieldFilterValues(filters, column, true);
+    }
+    _getIntervalTextFieldFilterValues(filters = {}, column, tmp) {
+        if (!this._hasIntervalTextFieldFilterValues(filters, column, tmp)) {
+            return ['', ''];
+        }
+        let values = [
+            this._getIntervalTextFieldFilterValue(filters, column.name, FilterInterval.FROM, tmp),
+            this._getIntervalTextFieldFilterValue(filters, column.name, FilterInterval.TO, tmp),
+        ];
+        return values;
+    }
+    getIntervalTextFieldFilterValue(filters = {}, column, index) {
+        return this._getIntervalTextFieldFilterValue(filters, column, index, false);
+    }
+    getIntervalTextFieldFilterValueTmp(filters = {}, column, index) {
+        return this._getIntervalTextFieldFilterValue(filters, column, index, true);
+    }
+    _getIntervalTextFieldFilterValue(filters = {}, column, index, tmp) {
+        let value = '';
+        if (filters == null) {
+            return value;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            return value;
+        }
+        if (tmp && filter.intervalTmp == null) {
+            return value;
+        }
+        if (!tmp && filter.interval == null) {
+            return value;
+        }
+        value = tmp ? filter.intervalTmp[index] : filter.interval[index];
+        return value;
+    }
+    setTextFieldFilterValue(filters = {}, column, newFilter) {
+        this._setTextFieldFilterValue(filters, column, newFilter, true);
+    }
+    _setTextFieldFilterValue(filters = {}, column, newFilter, tmp) {
+        if (filters == null) {
+            return;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            filter = {
+                textField: '',
+                textFieldTmp: '',
+                checkBoxes: [],
+                interval: null,
+                intervalTmp: null,
+            };
+            filters[column] = filter;
+        }
+        if (tmp) {
+            filter.textFieldTmp =
+                newFilter != null ? newFilter.trim() : newFilter;
+        }
+        else {
+            filter.textField = newFilter != null ? newFilter.trim() : newFilter;
+        }
+    }
+    setIntervalTextFieldFilterValue(filters = {}, column, newFilter, index) {
+        this._setIntervalTextFieldFilterValue(filters, column, newFilter, index, true);
+    }
+    _setIntervalTextFieldFilterValue(filters = {}, column, newFilter, index, tmp) {
+        if (filters == null) {
+            return;
+        }
+        let filter = filters[column];
+        if (filter == null) {
+            filter = {
+                textField: '',
+                textFieldTmp: '',
+                checkBoxes: [],
+                interval: null,
+                intervalTmp: null,
+            };
+            filters[column] = filter;
+        }
+        if (filter.interval == null) {
+            filter.interval = [];
+            filter.interval.push('', '');
+        }
+        if (filter.intervalTmp == null) {
+            filter.intervalTmp = [];
+            filter.intervalTmp.push('', '');
+        }
+        if (tmp) {
+            filter.intervalTmp[index] =
+                newFilter != null ? newFilter.trim() : newFilter;
+        }
+        else {
+            filter.interval[index] =
+                newFilter != null ? newFilter.trim() : newFilter;
+        }
+    }
+    saveTextualFilters(filters = {}, column) {
+        this._setTextFieldFilterValue(filters, column, this.getTextFilterValueTmp(filters, column), false);
+        this._setIntervalTextFieldFilterValue(filters, column, this.getIntervalTextFieldFilterValueTmp(filters, column, FilterInterval.FROM), FilterInterval.FROM, false);
+        this._setIntervalTextFieldFilterValue(filters, column, this.getIntervalTextFieldFilterValueTmp(filters, column, FilterInterval.TO), FilterInterval.TO, false);
+    }
+    resetTextualFilters(filters = {}, column) {
+        this._setTextFieldFilterValue(filters, column, this.getTextFilterValue(filters, column), true);
+        this._setIntervalTextFieldFilterValue(filters, column, this.getIntervalTextFieldFilterValue(filters, column, FilterInterval.FROM), FilterInterval.FROM, true);
+        this._setIntervalTextFieldFilterValue(filters, column, this.getIntervalTextFieldFilterValue(filters, column, FilterInterval.TO), FilterInterval.TO, true);
+    }
+    getFilterValueForTooltip(filters = {}, column) {
+        let txtFilter = this.getTextFilterValue(filters, column.name);
+        let interval = this.getIntervalTextFieldFilterValues(filters, column);
+        let chkFilters = this.getCheckBoxFilterValues(filters, column.name);
+        let separator = '';
+        let txtFiterRis = getValueForDisplay(txtFilter, column.obj, column.decimals);
+        if (txtFilter != '') {
+            separator = ' AND ';
+        }
+        if (interval[FilterInterval.FROM] != '') {
+            txtFiterRis +=
+                separator +
+                    '(>= ' +
+                    getValueForDisplay(interval[FilterInterval.FROM], column.obj, column.decimals) +
+                    ')';
+            separator = ' AND ';
+        }
+        if (interval[FilterInterval.TO] != '') {
+            txtFiterRis +=
+                separator +
+                    '(<= ' +
+                    getValueForDisplay(interval[FilterInterval.TO], column.obj, column.decimals) +
+                    ')';
+            separator = ' AND ';
+        }
+        separator = '';
+        let ris = '';
+        chkFilters.forEach((f) => {
+            ris += separator + getValueForDisplay2(f, column);
+            separator = ' OR ';
+        });
+        if (ris != '') {
+            ris = '(' + ris + ')';
+            if (txtFiterRis != '') {
+                ris = ' AND ' + ris;
+            }
+        }
+        ris = txtFiterRis + ris;
+        return ris;
+    }
+    /**
+     * Triggers when a filter must be removed, for column.
+     * @param {GenericFilter} filters - Filters of the component.
+     * @param {string} column - Name of the column.
+     */
+    removeFilter(filters = {}, column) {
+        filters[column] = {
+            textField: '',
+            textFieldTmp: '',
+            checkBoxes: [],
+            interval: null,
+            intervalTmp: null,
+        };
+    }
+}
+
+/**
+ * Props of the kup-tree component.
+ * Used to export every prop in an object.
+ */
+var KupTreeProps;
+(function (KupTreeProps) {
+    KupTreeProps["asAccordion"] = "When enabled, the first level of depth will give an accordion look to nodes.";
+    KupTreeProps["columns"] = "The columns of the tree when tree visualization is active.";
+    KupTreeProps["customStyle"] = "Custom style of the component.";
+    KupTreeProps["data"] = "The json data used to populate the tree view: the basic, always visible tree nodes.";
+    KupTreeProps["density"] = "The density of the rows, defaults at 'medium' and can also be set to 'dense' or 'wide'.";
+    KupTreeProps["dynamicExpansionCallback"] = "Function that gets invoked when a new set of nodes must be loaded as children of a node. When useDynamicExpansion is set, the tree component will have two different behaviors depending on the value of this prop. If this prop is set to null, no callback to download data is available: the component will emit an event requiring the parent to load the children of the given node. If this prop is set to have a callback, then the component will automatically make requests to load children of a given node. After the load has been completed, a different event will be fired to alert the parent of the change.";
+    KupTreeProps["enableExtraColumns"] = "Enables adding extra columns.";
+    KupTreeProps["expanded"] = "Flag: the nodes of the whole tree must be already expanded upon loading. Disabled nodes do NOT get expanded.";
+    KupTreeProps["expansionMode"] = "Behavior of nodes' expansion: it can be chosen between expanding a node by clicking on the dropdown icon, or by clicking on the whole node.";
+    KupTreeProps["filters"] = "List of filters set by the user.";
+    KupTreeProps["globalFilter"] = "When set to true it activates the global filter.";
+    KupTreeProps["globalFilterValue"] = "The value of the global filter.";
+    KupTreeProps["globalFilterMode"] = "The mode of the global filter.";
+    KupTreeProps["removableColumns"] = "Sets the possibility to remove the selected column.";
+    KupTreeProps["preventXScroll"] = "Experimental feature: when active, the tree will try to prevent horizontal overflowing elements by setting a width on the content of the table cells. It works only on cells of the main column.";
+    KupTreeProps["ripple"] = "When enabled displays Material's ripple effect on nodes (only when no columns are displayed).";
+    KupTreeProps["scrollOnHover"] = "Activates the scroll on hover function.";
+    KupTreeProps["showColumns"] = "Shows the tree data as a table.";
+    KupTreeProps["showFilters"] = "When set to true enables the column filters.";
+    KupTreeProps["showFooter"] = "When set to true shows the footer.";
+    KupTreeProps["showHeader"] = "Flag: shows the header of the tree when the tree is displayed as a table.";
+    KupTreeProps["showIcons"] = "Shows the icons of the nodes.";
+    KupTreeProps["stateId"] = "";
+    KupTreeProps["store"] = "";
+    KupTreeProps["totals"] = "Defines the current totals options.";
+    KupTreeProps["useDynamicExpansion"] = "When the component must use the dynamic expansion feature to open its nodes, it means that not all the nodes of the tree have been passed inside the data property. Therefore, when expanding a node, the tree must emit an event (or run a given callback) and wait for the child nodes to be downloaded from the server.";
+})(KupTreeProps || (KupTreeProps = {}));
+/**
+ * The name of the constant used by the tree component to identify the main tree in column menu
+ * @constant
+ */
+const treeMainColumnName = 'TREE_COLUMN';
+var KupTreeExpansionMode;
+(function (KupTreeExpansionMode) {
+    KupTreeExpansionMode["DROPDOWN"] = "dropdown";
+    KupTreeExpansionMode["NODE"] = "node";
+})(KupTreeExpansionMode || (KupTreeExpansionMode = {}));
+
+const dom$3 = document.documentElement;
+const kupObjects = dom$3.ketchup
+    ? dom$3.ketchup.objects
+    : new KupObjects();
+const kupData = dom$3.ketchup ? dom$3.ketchup.data : new KupData();
+/**
+ * Filtering algorithms related to data-table rows.
+ * @module FiltersRows
+ * @todo Should contain EVERY row-specific filtering method.
+ */
+class FiltersRows extends Filters {
+    isFilterCompliantForCell(cellValue, filterValue, interval) {
+        if (!cellValue) {
+            return false;
+        }
+        return this.isFilterCompliantForSimpleValue(cellValue.value, cellValue.obj, filterValue, interval);
+    }
+    isFilterCompliantForCellObj(cellValue, filterValue, interval) {
+        if (!cellValue) {
+            return false;
+        }
+        if (!cellValue.obj) {
+            return false;
+        }
+        return this.isFilterCompliantForSimpleValue(cellValue.obj.k, cellValue.obj, filterValue, interval);
+    }
+    isRowCompliant(r, filters = {}, globalFilter = '', isUsingGlobalFilter = false, columns = [], columnFilters) {
+        return this.areCellsCompliant(r.cells, filters, globalFilter, isUsingGlobalFilter, columns, columnFilters);
+    }
+    areCellsCompliant(cells, filters = {}, globalFilter = '', isUsingGlobalFilter = false, columns = [], columnFilters) {
+        if (isUsingGlobalFilter) {
+            let retValue = true;
+            // There are no columns -> display element
+            if (columns && columns != null && columns.length > 0) {
+                retValue = false;
+                let _filterIsNegative = this.filterIsNegative(globalFilter);
+                // Search among all visible columns for the global filter
+                for (let i = 0; i < columns.length; i++) {
+                    if (columns[i].visible == false) {
+                        continue;
+                    }
+                    const cell = cells[columns[i].name];
+                    if (cell == null) {
+                        continue;
+                    }
+                    retValue = this.isFilterCompliantForValue(cell.value, globalFilter);
+                    let displayedValue = getCellValueForDisplay(columns[i], cell);
+                    if (displayedValue != cell.value) {
+                        retValue =
+                            retValue ||
+                                this.isFilterCompliantForValue(displayedValue, globalFilter);
+                    }
+                    if (retValue == true && !_filterIsNegative) {
+                        break;
+                    }
+                    if (retValue == false && _filterIsNegative) {
+                        break;
+                    }
+                }
+            }
+            if (!retValue) {
+                return false;
+            }
+        }
+        if (columnFilters == null) {
+            columnFilters = new FiltersColumnMenu();
+        }
+        // There are no filters to check -> the element is valid
+        if (!this.hasFilters(filters, columns, columnFilters)) {
+            return true;
+        }
+        let keys = Object.keys(filters);
+        // Filters
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            const cell = cells[key];
+            if (!cell) {
+                return false;
+            }
+            let filterValue = columnFilters.getTextFilterValue(filters, key);
+            let interval = columnFilters.getIntervalTextFieldFilterValues(filters, getColumnByName(columns, key));
+            const _filterIsNegative = this.filterIsNegative(filterValue);
+            let b1 = this.isFilterCompliantForCell(cell, filterValue, interval);
+            let b2 = _filterIsNegative;
+            if (!kupObjects.isNumber(cell.obj) &&
+                !kupObjects.isDate(cell.obj) &&
+                !kupObjects.isTime(cell.obj) &&
+                !kupObjects.isTimestamp(cell.obj)) {
+                b2 = this.isFilterCompliantForCellObj(cell, filterValue, interval);
+            }
+            if (_filterIsNegative) {
+                if (!b1 || !b2) {
+                    return false;
+                }
+            }
+            else {
+                if (!b1 && !b2) {
+                    return false;
+                }
+            }
+            let filterValues = columnFilters.getCheckBoxFilterValues(filters, key);
+            if (filterValues.length == 0) {
+                continue;
+            }
+            let retValue = false;
+            for (let i = 0; i < filterValues.length; i++) {
+                let fv = filterValues[i];
+                if (fv == null || fv.value == null) {
+                    continue;
+                }
+                if (cell.value != null) {
+                    if (cell.value.toLowerCase().trim() ==
+                        fv.value.toLowerCase().trim()) {
+                        retValue = true;
+                        break;
+                    }
+                }
+                if (cell.obj != null) {
+                    if (cell.obj.k.toLowerCase().trim() ==
+                        fv.value.toLowerCase().trim()) {
+                        retValue = true;
+                        break;
+                    }
+                }
+            }
+            if (!retValue) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasFilters(filters = {}, columns, columnFilters) {
+        if (filters == null) {
+            return false;
+        }
+        let keys = Object.keys(filters);
+        if (keys == null || keys.length < 1) {
+            return false;
+        }
+        if (columnFilters == null) {
+            columnFilters = new FiltersColumnMenu();
+        }
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            let col = null;
+            if (key === treeMainColumnName) {
+                col = {
+                    name: treeMainColumnName,
+                    title: '',
+                };
+            }
+            else {
+                col = getColumnByName(columns, key);
+            }
+            if (columnFilters.hasFiltersForColumn(filters, col)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Filters the rows data of a data-table component according to the parameters
+     *
+     * @param rows - The data of the rows to filter.
+     * @param filters - The the filters for each column.
+     * @param globalFilter - A global filter applied to all columns.
+     * @param columns - The colmns on which the filter will take effect.
+     * @todo This function can be improved in its speed by a refactor in which from two different cycles of execution for
+     *    single filters and global filter, all controls on a single column are done in a single cycle.
+     */
+    filterRows(rows = [], filters = {}, globalFilter = '', columns = [], columnFilters) {
+        if (!rows || rows == null) {
+            return [];
+        }
+        // There are rows to filter
+        let filteredRows = [];
+        const isUsingGlobalFilter = !!(globalFilter && columns);
+        if (this.hasFilters(filters, columns, columnFilters) ||
+            isUsingGlobalFilter) {
+            for (let i = 0; i < rows.length; i++) {
+                let r = rows[i];
+                if ((r.id && r.id.indexOf('insert_') > -1) ||
+                    this.isRowCompliant(r, filters, globalFilter, isUsingGlobalFilter, columns, columnFilters)) {
+                    filteredRows[filteredRows.length] = r;
+                }
+            }
+        }
+        else {
+            filteredRows = [...rows];
+        }
+        return filteredRows;
+    }
+    getColumnValues(comp, column, globalFilterValue, columnFilters) {
+        let values = new Array();
+        if (columnFilters == null) {
+            columnFilters = new FiltersColumnMenu();
+        }
+        let value = columnFilters.getTextFilterValueTmp(comp.filters, column.name);
+        let interval = columnFilters.getIntervalTextFieldFilterValuesTmp(comp.filters, column);
+        let checkboxes = columnFilters.getCheckBoxFilterValues(comp.filters, column.name);
+        if (column.valuesForFilter != null &&
+            column.valuesForFilter.length > 0) {
+            column.valuesForFilter.forEach((element) => {
+                let v = element;
+                if (Filters.valuesArrayContainsValue(checkboxes, v) ||
+                    value == '' ||
+                    columnFilters.isFilterCompliantForSimpleValue(v, column.obj, value, interval)) {
+                    values.push({
+                        value: v,
+                        displayedValue: getValueForDisplay(v, column.obj, column.decimals),
+                    });
+                }
+            });
+            return values;
+        }
+        /** è necessario estrarre i valori della colonna di tutte le righe
+         * filtrate SENZA il filtro della colonna stessa corrente */
+        let tmpFilters = Object.assign({}, comp.filters);
+        tmpFilters[column.name] = {
+            textField: value,
+            textFieldTmp: value,
+            checkBoxes: [],
+            interval: interval,
+            intervalTmp: interval,
+        };
+        let tmpRows = this.filterRows(comp.getRows(), tmpFilters, globalFilterValue, comp.getVisibleColumns(), columnFilters);
+        for (let i = 0; i < checkboxes.length; i++) {
+            values.push(checkboxes[i]);
+        }
+        return kupData.cell.getUnivocalValue({ rows: tmpRows }, column, true);
+    }
+}
+
+const dom$2 = document.documentElement;
+function sortRows(rows = [], sort = []) {
+    if (!rows || rows.length === 0) {
+        return [];
+    }
+    // check if row is group
+    if (rows[0].group) {
+        return sortGroupRows(rows, sort);
+    }
+    // sorting rows
+    if (!sort || sort.length === 0) {
+        // no sort -> return rows as they are
+        return rows;
+    }
+    // check multiple sort
+    const isMultiSort = sort.length > 1;
+    // sorting rows
+    return rows.slice(0).sort((r1, r2) => {
+        if (isMultiSort) {
+            for (let i = 0; i < sort.length; i++) {
+                const compare = compareRows(r1, r2, sort[i]);
+                if (compare !== 0) {
+                    // not same row
+                    return compare;
+                }
+            }
+            // same row
+            return 0;
+        }
+        else {
+            return compareRows(r1, r2, sort[0]);
+        }
+    });
+}
+function sortGroupRows(rows = [], sort = []) {
+    if (!rows || rows.length === 0) {
+        return [];
+    }
+    // getting columm group
+    const groupColumn = rows[0].group.column;
+    // check if column is in sort
+    let sortObject = getSortOnColumn(groupColumn, sort);
+    if (!sortObject) {
+        sortObject = {
+            column: groupColumn,
+            sortMode: SortMode.A,
+        };
+    }
+    // sorting rows
+    rows.sort((r1, r2) => {
+        // creating fake cells
+        const cell1 = {
+            obj: r1.group.obj,
+            value: r1.group.id,
+        };
+        const cell2 = {
+            obj: r2.group.obj,
+            value: r2.group.id,
+        };
+        return compareCell(cell1, cell2, sortObject.sortMode);
+    });
+    // sorting children
+    rows.forEach((row) => {
+        row.group.children = sortRows(row.group.children, sort);
+    });
+    return rows;
+}
+function getSortOnColumn(column = '', sort = []) {
+    if (!column || !sort || sort.length === 0) {
+        return null;
+    }
+    for (let sortObject of sort) {
+        if (sortObject.column === column) {
+            return sortObject;
+        }
+    }
+    return null;
+}
+function compareRows(r1, r2, sortObj) {
+    const cell1 = r1.cells[sortObj.column];
+    const cell2 = r2.cells[sortObj.column];
+    if (!cell1 && !cell2) {
+        return 0;
+    }
+    if (!cell1) {
+        return 1;
+    }
+    if (!cell2) {
+        return -1;
+    }
+    return compareCell(cell1, cell2, sortObj.sortMode);
+}
+//-------- FILTER FUNCTIONS --------
+/**
+ * Filters the rows data of a data-table component according to the parameters
+ *
+ * @param rows - The data of the rows to filter.
+ * @param filters - The the filters for each column.
+ * @param globalFilter - A global filter applied to all columns.
+ * @param columns - The colmns on which the filter will take effect.
+ * @todo This function can be improved in its speed by a refactor in which from two different cycles of execution for
+ *    single filters and global filter, all controls on a single column are done in a single cycle.
+ */
+function filterRows(rows = [], filters = {}, globalFilter = '', columns = [], columnFilters, filtersRows) {
+    if (filtersRows == null) {
+        filtersRows = new FiltersRows();
+    }
+    return filtersRows.filterRows(rows, filters, globalFilter, columns, columnFilters);
+}
+function groupRows(columns = [], rows = [], groups = [], totals = {}) {
+    if (!rows) {
+        return [];
+    }
+    if (!groups || groups.length === 0 || !columns || columns.length === 0) {
+        return rows;
+    }
+    // Keeps label of the valid columns
+    const columnLabels = {};
+    // remove invalid groups and store column labels
+    const validGroups = groups.filter(({ column }) => {
+        for (let { name, title } of columns) {
+            if (name === column) {
+                // Store label of the columns
+                columnLabels[name] = title;
+                return true;
+            }
+        }
+        return false;
+    });
+    if (validGroups.length === 0) {
+        // no valid groups
+        return rows;
+    }
+    // creating root
+    const groupRows = [];
+    // obj used to calculate the group distinct value
+    let distinctObj = {};
+    rows.forEach((row) => {
+        // getting column name from first group
+        const columnName = validGroups[0].column;
+        // getting row value
+        const cell = row.cells[columnName];
+        if (cell) {
+            const column = getColumnByName(columns, columnName);
+            const cellValueForDisplay = getCellValueForDisplay(column, cell);
+            const cellValue = cell.value;
+            let groupRow = null;
+            // check in already in groupedRow
+            for (let currentGroupRow of groupRows) {
+                if (currentGroupRow.group.label === cellValueForDisplay) {
+                    groupRow = currentGroupRow;
+                    break;
+                }
+            }
+            if (groupRow === null) {
+                // create group row
+                groupRow = {
+                    group: {
+                        id: cellValue,
+                        parent: null,
+                        column: columnName,
+                        columnLabel: columnLabels[columnName],
+                        expanded: false,
+                        label: cellValueForDisplay,
+                        children: [],
+                        obj: cell.obj,
+                        totals: {},
+                    },
+                    cells: {},
+                };
+                // add group to list
+                groupRows.push(groupRow);
+            }
+            for (let i = 1; i < validGroups.length; i++) {
+                const group = validGroups[i];
+                // getting cell value
+                const tempCell = row.cells[group.column];
+                if (tempCell) {
+                    const column = getColumnByName(columns, group.column);
+                    const tempCellValueForDisplay = getCellValueForDisplay(column, tempCell);
+                    const tempCellValue = tempCell.value;
+                    // check if group already exists
+                    let tempGroupingRow = null;
+                    for (let j = 0; j < groupRow.group.children.length; j++) {
+                        const childGroup = groupRow.group.children[j];
+                        const groupLabel = childGroup.group.label;
+                        if (groupLabel === tempCellValueForDisplay) {
+                            tempGroupingRow = childGroup;
+                            break;
+                        }
+                    }
+                    if (!tempGroupingRow) {
+                        tempGroupingRow = {
+                            cells: {},
+                            group: {
+                                id: tempCellValue,
+                                parent: groupRow,
+                                column: group.column,
+                                columnLabel: columnLabels[group.column],
+                                children: [],
+                                expanded: false,
+                                label: tempCellValueForDisplay,
+                                totals: {},
+                                obj: tempCell.obj,
+                            },
+                        };
+                        adjustGroupId(tempGroupingRow);
+                        groupRow.group.children.push(tempGroupingRow);
+                    }
+                    groupRow = tempGroupingRow;
+                }
+            }
+            // adding row
+            groupRow.group.children.push(row);
+            updateGroupTotal(groupRow, totals, row, distinctObj);
+        }
+    });
+    adjustGroupsDistinct(groupRows, totals, distinctObj);
+    adjustGroupsAverageOrFormula(groupRows, TotalMode.AVERAGE, totals);
+    adjustGroupsAverageOrFormula(groupRows, TotalMode.MATH, totals);
+    return groupRows;
+}
+function updateGroupTotal(groupRow, totals, addedRow, distinctObj) {
+    if (!groupRow || !totals) {
+        return;
+    }
+    const keys = Object.keys(totals);
+    if (keys.length === 0) {
+        return;
+    }
+    keys.forEach((key) => {
+        const cell = addedRow.cells[key];
+        if (cell) {
+            const _isNumber = dom$2.ketchup.objects.isNumber(cell.obj);
+            const totalMode = totals[key];
+            switch (totalMode) {
+                case TotalMode.COUNT:
+                    let currentTotalValue = groupRow.group.totals[key] || 0;
+                    groupRow.group.totals[key] = ++currentTotalValue;
+                    // updating parents
+                    let parent = groupRow.group.parent;
+                    while (parent != null) {
+                        let currentParentCount = parent.group.totals[key] || 0;
+                        parent.group.totals[key] = ++currentParentCount;
+                        parent = parent.group.parent;
+                    }
+                    break;
+                case TotalMode.DISTINCT:
+                    let cellValue;
+                    if (_isNumber) {
+                        cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                    }
+                    else {
+                        cellValue = cell.value;
+                    }
+                    let distinctGroup = distinctObj[groupRow.group.id];
+                    if (!distinctGroup) {
+                        distinctObj[groupRow.group.id] = {};
+                        distinctObj[groupRow.group.id][key] = [];
+                        distinctObj[groupRow.group.id][key].push(cellValue);
+                    }
+                    else {
+                        let distinctList = distinctObj[groupRow.group.id][key];
+                        if (!distinctList) {
+                            // first round
+                            distinctObj[groupRow.group.id][key] = [];
+                            distinctObj[groupRow.group.id][key].push(cellValue);
+                        }
+                        else {
+                            // update the list
+                            distinctList.push(cellValue);
+                        }
+                    }
+                    // updating parents
+                    let distinctParent = groupRow.group.parent;
+                    while (distinctParent != null) {
+                        // get parent value
+                        let distinctGroupParent = distinctObj[distinctParent.group.id];
+                        if (!distinctGroupParent) {
+                            distinctObj[distinctParent.group.id] = {};
+                            distinctObj[distinctParent.group.id][key] = [];
+                            distinctObj[distinctParent.group.id][key].push(cellValue);
+                        }
+                        else {
+                            let distinctParentList = distinctObj[distinctParent.group.id][key];
+                            if (!distinctParentList) {
+                                // first round
+                                distinctObj[distinctParent.group.id][key] = [];
+                                distinctObj[distinctParent.group.id][key].push(cellValue);
+                            }
+                            else {
+                                // update the list
+                                distinctParentList.push(cellValue);
+                            }
+                        }
+                        // continue
+                        distinctParent = distinctParent.group.parent;
+                    }
+                    break;
+                case TotalMode.SUM:
+                case TotalMode.AVERAGE:
+                    if (_isNumber && cell.value) {
+                        const cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                        const currentTotalValue = groupRow.group.totals[key] || 0;
+                        groupRow.group.totals[key] =
+                            cellValue + currentTotalValue;
+                        // updating parents
+                        let parent = groupRow.group.parent;
+                        while (parent != null) {
+                            const currentParentSum = dom$2.ketchup.math.numberify(parent.group.totals[key] || 0);
+                            parent.group.totals[key] =
+                                cellValue + currentParentSum;
+                            parent = parent.group.parent;
+                        }
+                    }
+                    break;
+                // TODO DRY the MIN and MAX functions
+                case TotalMode.MIN:
+                    if (_isNumber && cell.value) {
+                        const currentMinValue = groupRow.group.totals[key];
+                        const cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                        if (currentMinValue) {
+                            groupRow.group.totals[key] = Math.min(currentMinValue, cellValue);
+                        }
+                        else {
+                            // first round
+                            groupRow.group.totals[key] = cellValue;
+                        }
+                        // updating parents
+                        let parent = groupRow.group.parent;
+                        while (parent != null) {
+                            const currentParentMin = parent.group.totals[key];
+                            if (currentParentMin) {
+                                parent.group.totals[key] = Math.min(currentParentMin, cellValue);
+                            }
+                            else {
+                                // first round
+                                parent.group.totals[key] = cellValue;
+                            }
+                            parent = parent.group.parent;
+                        }
+                    }
+                    else if (cell.value &&
+                        dom$2.ketchup.objects.isDate(cell.obj)) {
+                        const cellValue = dom$2.ketchup.dates.toDayjs(cell.value);
+                        if (dom$2.ketchup.dates.isValid(cellValue)) {
+                            const currentMinValue = groupRow.group.totals[key];
+                            if (currentMinValue) {
+                                let moments = [];
+                                moments.push(cellValue);
+                                moments.push(dom$2.ketchup.dates.toDayjs(currentMinValue));
+                                groupRow.group.totals[key] =
+                                    dom$2.ketchup.dates.format(dom$2.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                            }
+                            else {
+                                groupRow.group.totals[key] =
+                                    dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                            }
+                            // updating parents
+                            let parent = groupRow.group.parent;
+                            while (parent != null) {
+                                const currentParentMin = parent.group.totals[key];
+                                if (currentParentMin) {
+                                    let moments = [];
+                                    moments.push(cellValue);
+                                    moments.push(dom$2.ketchup.dates.toDayjs(currentParentMin));
+                                    parent.group.totals[key] =
+                                        dom$2.ketchup.dates.format(dom$2.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                                }
+                                else {
+                                    // first round
+                                    parent.group.totals[key] =
+                                        dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                                }
+                                parent = parent.group.parent;
+                            }
+                        }
+                    }
+                    break;
+                // TODO DRY the MIN and MAX functions
+                case TotalMode.MAX:
+                    if (_isNumber && cell.value) {
+                        const currentMaxValue = groupRow.group.totals[key];
+                        const cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                        if (currentMaxValue) {
+                            groupRow.group.totals[key] = Math.max(currentMaxValue, cellValue);
+                        }
+                        else {
+                            // first round
+                            groupRow.group.totals[key] = cellValue;
+                        }
+                        // updating parents
+                        let parent = groupRow.group.parent;
+                        while (parent != null) {
+                            const currentParentMax = parent.group.totals[key];
+                            if (currentParentMax) {
+                                parent.group.totals[key] = Math.max(currentParentMax, cellValue);
+                            }
+                            else {
+                                // first round
+                                parent.group.totals[key] = cellValue;
+                            }
+                            parent = parent.group.parent;
+                        }
+                    }
+                    else if (cell.value &&
+                        dom$2.ketchup.objects.isDate(cell.obj)) {
+                        const cellValue = dom$2.ketchup.dates.toDayjs(cell.value);
+                        if (dom$2.ketchup.dates.isValid(cellValue)) {
+                            const currentMaxValue = groupRow.group.totals[key];
+                            if (currentMaxValue) {
+                                let moments = [];
+                                moments.push(cellValue);
+                                moments.push(dom$2.ketchup.dates.toDayjs(currentMaxValue));
+                                groupRow.group.totals[key] =
+                                    dom$2.ketchup.dates.format(dom$2.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                            }
+                            else {
+                                groupRow.group.totals[key] =
+                                    dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                            }
+                            // updating parents
+                            let parent = groupRow.group.parent;
+                            while (parent != null) {
+                                const currentParentMax = parent.group.totals[key];
+                                if (currentParentMax) {
+                                    let moments = [];
+                                    moments.push(cellValue);
+                                    moments.push(dom$2.ketchup.dates.toDayjs(currentParentMax));
+                                    parent.group.totals[key] =
+                                        dom$2.ketchup.dates.format(dom$2.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                                }
+                                else {
+                                    // first round
+                                    parent.group.totals[key] =
+                                        dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                                }
+                                parent = parent.group.parent;
+                            }
+                        }
+                    }
+                    break;
+                default: {
+                    if (totalMode.indexOf(TotalMode.MATH) != 0) {
+                        console.warn(`invalid total mode: ${totalMode}`);
+                    }
+                    break;
+                }
+            }
+        }
+    });
+}
+function adjustGroupsDistinct(groupRows, totals, distinctObj) {
+    if (!groupRows || !totals) {
+        return;
+    }
+    const keys = Object.keys(totals);
+    if (groupRows.length === 0 || !groupRows[0].group || keys.length === 0) {
+        return;
+    }
+    let toAdjustKeys = keys.filter((key) => TotalMode.DISTINCT === totals[key]);
+    if (toAdjustKeys.length > 0) {
+        groupRows
+            .filter((groupRow) => groupRow.group.children.length > 0)
+            .forEach((groupRow) => adjustGroupDistinct(groupRow, toAdjustKeys, distinctObj));
+    }
+}
+function adjustGroupsAverageOrFormula(groupRows, type, totals) {
+    if (!groupRows || !totals) {
+        return;
+    }
+    const keys = Object.keys(totals);
+    if (groupRows.length === 0 || !groupRows[0].group || keys.length === 0) {
+        return;
+    }
+    let toAdjustKeys;
+    if (type == TotalMode.AVERAGE) {
+        toAdjustKeys = keys.filter((key) => TotalMode.AVERAGE === totals[key]);
+    }
+    if (type == TotalMode.MATH) {
+        toAdjustKeys = keys.filter((key) => totals[key].indexOf(TotalMode.MATH) == 0);
+    }
+    if (toAdjustKeys.length > 0) {
+        groupRows
+            .filter((groupRow) => groupRow.group.children.length > 0)
+            .forEach((groupRow) => adjustGroupAverageOrFormula(groupRow, type, toAdjustKeys, totals));
+    }
+}
+function adjustGroupDistinct(groupRow, toAdjustKeys, distinctObj) {
+    const children = groupRow.group.children;
+    if (children.length === 0) {
+        return;
+    }
+    if (children[0].group) {
+        children.forEach((child) => {
+            adjustGroupDistinct(child, toAdjustKeys, distinctObj);
+        });
+    }
+    toAdjustKeys.forEach((key) => {
+        const distinctList = distinctObj[groupRow.group.id][key];
+        groupRow.group.totals[key] = new Set(distinctList).size;
+    });
+}
+/**
+ * @returns number of 'leaf' of group
+ */
+function adjustGroupAverageOrFormula(row, type, toAdjustKeys, totals) {
+    const children = row.group.children;
+    if (children.length === 0) {
+        return 0;
+    }
+    let numberOfLeaf = 0;
+    // check if child is a grouping row
+    if (children[0].group) {
+        children.forEach((child) => {
+            numberOfLeaf += adjustGroupAverageOrFormula(child, type, toAdjustKeys, totals);
+        });
+    }
+    else {
+        numberOfLeaf = children.length;
+    }
+    // adjust average/formulas
+    toAdjustKeys.forEach((key) => {
+        if (type == TotalMode.AVERAGE) {
+            row.group.totals[key] = row.group.totals[key] / numberOfLeaf;
+        }
+        if (type == TotalMode.MATH) {
+            let formula = totals[key].substring(TotalMode.MATH.length);
+            row.group.totals[key] = dom$2.ketchup.math.formulas.custom(formula, row.group.totals);
+        }
+    });
+    return numberOfLeaf;
+}
+function normalizeRows(columns, rows) {
+    if (rows) {
+        const normalizedrows = Object.assign(rows);
+        rows.forEach((row) => {
+            columns.forEach((column) => {
+                if (row.cells) {
+                    const cell = row.cells[column.name];
+                    if (cell && column.obj && !cell.obj) {
+                        // cell.obj = Object.assign(column.obj);
+                        cell.obj = {
+                            t: column.obj.t,
+                            p: column.obj.p,
+                            k: cell.value,
+                        };
+                    }
+                }
+            });
+        });
+        return normalizedrows;
+    }
+    else {
+        return undefined;
+    }
+}
+function calcTotals(rows = [], totals = {}) {
+    if (dom$2.ketchup.objects.isEmptyJsObject(rows) ||
+        dom$2.ketchup.objects.isEmptyJsObject(totals)) {
+        return {};
+    }
+    const keys = Object.keys(totals);
+    const footerRow = {};
+    const dateColumns = new Array();
+    // if there are only COUNT, no need to loop on rows
+    let onlyCount = keys.length === 0 ||
+        keys.every((key) => totals[key] === TotalMode.COUNT);
+    if (onlyCount) {
+        keys.forEach((columnName) => (footerRow[columnName] = rows.length));
+    }
+    else {
+        let distinctObj = {};
+        rows.forEach((r, index, array) => {
+            keys.filter((key) => TotalMode.COUNT !== totals[key] &&
+                totals[key].indexOf(TotalMode.MATH) != 0).forEach((key) => {
+                // getting cell
+                const cell = r.cells[key];
+                if (cell) {
+                    if (totals[key] === TotalMode.DISTINCT) {
+                        let cellValue;
+                        if (dom$2.ketchup.objects.isNumber(cell.obj)) {
+                            cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                        }
+                        else {
+                            cellValue = cell.value;
+                        }
+                        let distinctList = distinctObj[key];
+                        if (!distinctList) {
+                            // first round
+                            distinctObj[key] = [];
+                            distinctObj[key].push(cellValue);
+                        }
+                        else {
+                            // update the list
+                            distinctList.push(cellValue);
+                        }
+                    }
+                    else if (dom$2.ketchup.objects.isNumber(cell.obj)) {
+                        const cellValue = dom$2.ketchup.math.numberify(dom$2.ketchup.math.numberifySafe(cell.value));
+                        let currentFooterValue = footerRow[key];
+                        switch (true) {
+                            // TODO DRY the MIN and MAX functions
+                            case totals[key] === TotalMode.MIN:
+                                if (currentFooterValue) {
+                                    footerRow[key] = Math.min(currentFooterValue, cellValue);
+                                }
+                                else {
+                                    footerRow[key] = cellValue;
+                                }
+                                break;
+                            case totals[key] === TotalMode.MAX:
+                                if (currentFooterValue) {
+                                    footerRow[key] = Math.max(currentFooterValue, cellValue);
+                                }
+                                else {
+                                    footerRow[key] = cellValue;
+                                }
+                                break;
+                            default:
+                                // SUM
+                                currentFooterValue = footerRow[key] || 0;
+                                footerRow[key] =
+                                    cellValue +
+                                        dom$2.ketchup.math.numberify(currentFooterValue);
+                        }
+                        // TODO DRY the MIN and MAX functions
+                    }
+                    else if (dom$2.ketchup.objects.isDate(cell.obj)) {
+                        if (dateColumns.indexOf(key) == -1) {
+                            dateColumns.push(key);
+                        }
+                        const momentValue = dom$2.ketchup.dates.toDayjs(cell.value);
+                        if (dom$2.ketchup.dates.isValid(momentValue)) {
+                            const cellValue = dom$2.ketchup.dates.toDate(momentValue);
+                            const currentFooterValue = footerRow[key]
+                                ? dom$2.ketchup.dates.toDate(dom$2.ketchup.dates.toDayjs(footerRow[key]))
+                                : null;
+                            switch (true) {
+                                case totals[key] === TotalMode.MIN:
+                                    if (currentFooterValue) {
+                                        let moments = [];
+                                        moments.push(cellValue);
+                                        moments.push(currentFooterValue);
+                                        footerRow[key] =
+                                            dom$2.ketchup.dates.format(dom$2.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                                    }
+                                    else {
+                                        footerRow[key] =
+                                            dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                                    }
+                                    break;
+                                case totals[key] === TotalMode.MAX:
+                                    if (currentFooterValue) {
+                                        let moments = [];
+                                        moments.push(cellValue);
+                                        moments.push(currentFooterValue);
+                                        footerRow[key] =
+                                            dom$2.ketchup.dates.format(dom$2.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                                    }
+                                    else {
+                                        footerRow[key] =
+                                            dom$2.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                }
+                if (index === array.length - 1 &&
+                    totals[key] === TotalMode.DISTINCT) {
+                    // last round
+                    footerRow[key] = new Set(distinctObj[key]).size;
+                    distinctObj[key] = [];
+                }
+            });
+        });
+    }
+    // fixing MATH, AVERAGE and COUNT
+    for (let key of keys) {
+        switch (true) {
+            case totals[key] === TotalMode.AVERAGE:
+                const sum = footerRow[key];
+                if (sum && rows.length > 0) {
+                    footerRow[key] = sum / rows.length;
+                }
+                break;
+            case totals[key] === TotalMode.COUNT:
+                footerRow[key] = rows.length;
+                break;
+            case totals[key].indexOf(TotalMode.MATH) == 0:
+                footerRow[key] = dom$2.ketchup.math.formulas.custom(totals[key].substring(TotalMode.MATH.length), footerRow);
+                break;
+        }
+        if (footerRow[key]) {
+            if (dateColumns.indexOf(key) != -1) {
+                footerRow[key] = dom$2.ketchup.dates.format(footerRow[key]);
+            }
+            else if (dom$2.ketchup.math.isNumber(footerRow[key])) {
+                footerRow[key] = +footerRow[key].toFixed(2);
+            }
+        }
+    }
+    return footerRow;
+}
+function adjustGroupId(row) {
+    if (!row.group) {
+        return;
+    }
+    let groupID = row.group.id;
+    let parentRow = row.group.parent;
+    while (parentRow !== null) {
+        groupID = `${parentRow.group.id};${groupID}`;
+        parentRow = parentRow.group.parent;
+    }
+    row.group.id = groupID;
+}
+function paginateRows(rows, currentPage, rowsPerPage, areGrouped) {
+    const start = currentPage * rowsPerPage - rowsPerPage;
+    const end = start + Number(rowsPerPage);
+    if (areGrouped == false) {
+        return rows.slice(start, end);
+    }
+    let pagRows = [];
+    _paginateRows(rows, pagRows, start, Number(rowsPerPage), 0);
+    return pagRows;
+}
+function _paginateRows(rows, pagRows, start, rowsPerPage, ci) {
+    let added = false;
+    for (let i = 0; i < rows.length; i++) {
+        let originalRow = rows[i];
+        let row = cloneRow(rows[i]);
+        if (originalRow.group != null &&
+            originalRow.group.children != null &&
+            originalRow.group.children.length > 0) {
+            row.group.children = [];
+            let retValue = _paginateRows(originalRow.group.children, row.group.children, start, rowsPerPage, ci);
+            ci = retValue.ci;
+            added = retValue.added;
+            if (added == true) {
+                pagRows[pagRows.length] = row;
+            }
+        }
+        else {
+            if (ci >= start) {
+                pagRows[pagRows.length] = row;
+                added = true;
+            }
+            ci++;
+        }
+        if (ci >= start + rowsPerPage) {
+            break;
+        }
+    }
+    return { ci: ci, added: added };
+}
+function cloneRow(row) {
+    if (row == null) {
+        return null;
+    }
+    else {
+        return {
+            id: row.id,
+            cells: Object.assign({}, row.cells),
+            actions: row.actions ? [...row.actions] : null,
+            group: cloneRowGroup(row.group),
+            clonedFrom: row,
+            readOnly: row.readOnly,
+            cssClass: row.cssClass,
+        };
+    }
+}
+function cloneRows(rows) {
+    if (rows == null) {
+        return null;
+    }
+    let cloned = [];
+    for (let i = 0; i < rows.length; i++) {
+        cloned[cloned.length] = cloneRow(rows[i]);
+    }
+    return cloned;
+}
+function cloneRowGroup(group) {
+    if (group == null) {
+        return null;
+    }
+    let cloned = {
+        id: group.id,
+        parent: Object.assign({}, group.parent),
+        column: group.column,
+        columnLabel: group.columnLabel,
+        expanded: group.expanded,
+        label: group.label,
+        children: cloneRows(group.children),
+        obj: Object.assign({}, group.obj),
+        totals: Object.assign({}, group.totals),
+    };
+    return cloned;
+}
+
+var FPaginatorMode;
+(function (FPaginatorMode) {
+    FPaginatorMode["SIMPLE"] = "simple";
+    FPaginatorMode["FULL"] = "full";
+})(FPaginatorMode || (FPaginatorMode = {}));
+
+const dom$1 = document.documentElement;
+/*-------------------------------------------------*/
+/*                C o m p o n e n t                */
+/*-------------------------------------------------*/
+const FPaginator = (props) => {
+    const maxNumberOfPage = Math.ceil(props.max / props.perPage);
+    const pageItems = getPageItems(props, maxNumberOfPage);
+    const rowsPerPageItems = getRowsItems(props);
+    const dataPageSelector = {
+        'kup-list': {
+            data: pageItems,
+        },
+        'kup-text-field': {
+            label: dom$1.ketchup.language.translate(KupLanguagePage.PAGE),
+            helper: dom$1.ketchup.language.translate(KupLanguagePage.TOTAL) +
+                `: ${maxNumberOfPage}`,
+            helperWhenFocused: true,
+            inputType: 'number',
+            max: maxNumberOfPage,
+            min: 1,
+        },
+    };
+    const dataRowsSelector = {
+        'kup-list': {
+            data: rowsPerPageItems,
+        },
+        'kup-text-field': {
+            label: dom$1.ketchup.language.translate(KupLanguageRow.ROWS) +
+                ' / ' +
+                dom$1.ketchup.language.translate(KupLanguagePage.PAGE),
+            helper: dom$1.ketchup.language.translate(KupLanguageRow.TOTAL) +
+                `: ${props.max}`,
+            helperWhenFocused: true,
+            inputType: 'number',
+            max: props.max,
+            min: 1,
+        },
+    };
+    return (h("div", Object.assign({ class: `f-paginator ${props.mode ? props.mode : ''} ${props.wrapperClass ? props.wrapperClass : ''}` }, props.dataSet, { id: props.id, title: props.title }),
+        props.mode !== FPaginatorMode.SIMPLE ? (h(FButton, { icon: "chevron_left", disabled: isPrevPageDisabled(props), onClick: props.onPrevPage, wrapperClass: "prev-page" })) : null,
+        h("kup-combobox", { class: "page-selector", data: dataPageSelector, initialValue: props.currentPage.toString(), "onkup-combobox-change": props.onPageChange }),
+        props.mode !== FPaginatorMode.SIMPLE ? (h(FButton, { icon: "chevron_right", disabled: isNextPageDisabled(props), onClick: props.onNextPage, wrapperClass: "next-page" })) : null,
+        h("kup-combobox", { class: "rows-selector", data: dataRowsSelector, initialValue: props.perPage.toString(), "onkup-combobox-change": props.onRowsChange }),
+        props.onLoadMore ? (h(FButton, { icon: "plus", onClick: props.onLoadMore, label: dom$1.ketchup.language.translate(KupLanguageGeneric.LOAD_MORE), styling: FButtonStyling.FLAT, wrapperClass: "load-more-button" })) : null));
+};
+function getPageItems(props, maxNumberOfPage) {
+    const pageItems = [];
+    for (let i = 1; i <= maxNumberOfPage; i++) {
+        const selected = i == props.currentPage;
+        pageItems.push({
+            id: i.toString(),
+            selected: selected,
+            value: i.toString(),
+        });
+    }
+    return pageItems;
+}
+function getRowsItems(props) {
+    const rowsPerPageItems = [];
+    let i = props.perPage;
+    if (i === 0) {
+        return rowsPerPageItems;
+    }
+    while (i < props.max) {
+        const selected = i == props.perPage;
+        rowsPerPageItems.push({
+            id: i.toString(),
+            selected: selected,
+            value: i.toString(),
+        });
+        i = i * 2;
+    }
+    const selected = props.max == props.perPage;
+    rowsPerPageItems.push({
+        id: props.max.toString(),
+        selected: selected,
+        value: props.max.toString(),
+    });
+    return rowsPerPageItems;
+}
+function isNextPageDisabled(props) {
+    return props.currentPage * props.perPage >= props.max;
+}
+function isPrevPageDisabled(props) {
+    return props.currentPage == 1;
+}
+
+const dom = document.documentElement;
+function pageChange(pageNumber, max, perPage) {
+    if (dom.ketchup.math.isNumber(pageNumber)) {
+        const numberOfPages = Math.ceil(max / perPage);
+        let tmpNewPage = pageNumber;
+        if (tmpNewPage > numberOfPages) {
+            tmpNewPage = numberOfPages;
+        }
+        if (tmpNewPage < 1) {
+            tmpNewPage = 1;
+        }
+        return tmpNewPage;
+    }
+    return null;
+}
+function rowsPerPageChange(rowsNumber, max) {
+    if (dom.ketchup.math.isNumber(rowsNumber)) {
+        let tmpRowsPerPage = rowsNumber;
+        if (tmpRowsPerPage > max) {
+            tmpRowsPerPage = max;
+        }
+        if (tmpRowsPerPage < 1) {
+            tmpRowsPerPage = 1;
+        }
+        return tmpRowsPerPage;
+    }
+    return null;
+}
+
+export { FiltersColumnMenu as F, KupTreeExpansionMode as K, FiltersRows as a, FPaginator as b, calcTotals as c, pageChange as d, KupTreeProps as e, filterRows as f, groupRows as g, FPaginatorMode as h, normalizeRows as n, paginateRows as p, rowsPerPageChange as r, sortRows as s, treeMainColumnName as t };