@sme.up/ketchup 5.2.1-SNAPSHOT → 6.1.0-SNAPSHOT

package/dist/esm/f-paginator-utils-7dff8ff0.js

@@ -0,0 +1,1884 @@
+import { V as KupTagNames, d as KupDatesFormats, r as KupDatesNormalize, s as KupObjects, J as SortMode, T as TotalMode, W as KupLanguagePage, n as KupLanguageRow, h as KupLanguageGeneric } from './kup-manager-58b075b4.js';
+import { b as isValidFormattedStringTime, f as formattedStringToCustomUnformattedStringTime, j as formattedStringToDefaultUnformattedStringTimestamp, k as isValidFormattedStringNumber, l as formattedStringToUnformattedStringNumber, m as unformattedStringNumberToNumber, h as stringToNumber, o as isNumber } from './utils-d7e4b3c2.js';
+import { b as getValueForDisplay, a as getValueForDisplay2, c as getCellValueForDisplay, g as getColumnByName, d as compareValues, e as compareCell } from './cell-utils-964da6b5.js';
+import { h } from './index-baeab1ac.js';
+import { F as FButton } from './f-button-871a544b.js';
+import { F as FButtonStyling } from './f-button-declarations-b1b4cac4.js';
+
+/**
+ * Interface for ranged filters.
+ */
+var FilterInterval;
+(function (FilterInterval) {
+  FilterInterval[FilterInterval["FROM"] = 0] = "FROM";
+  FilterInterval[FilterInterval["TO"] = 1] = "TO";
+})(FilterInterval || (FilterInterval = {}));
+/**
+ * This regular expressions returns a match like this one:
+ * if the string does not match is null, otherwise the indexes are equal to the object below:
+ *
+ * @property {string} 0 - The entire match of the regexp; is equal to the cellValue.
+ * @property {string} 1 - Either !' or ' it's the start of the regexp.
+ * @property {string} 2 - Either % or null: means the string must start with the given string.
+ * @property {string} 3 - Either "" or a string with a length.
+ * @property {string} 4 - Either % or null: means the string must finish with the given string.
+ * @property {string} 5 - Always equal to ': it's the end of the filter.
+ */
+const FILTER_ANALIZER = /^('|!')(%){0,1}(.*?)(%){0,1}(')$/;
+var KupGlobalFilterMode;
+(function (KupGlobalFilterMode) {
+  KupGlobalFilterMode["SIMPLE"] = "simple";
+  KupGlobalFilterMode["HIGHLIGHT"] = "highlight";
+})(KupGlobalFilterMode || (KupGlobalFilterMode = {}));
+
+const dom$3 = document.documentElement;
+/**
+ * Filtering algorithms.
+ * @module Filters
+ * @todo Should contain EVERY filtering method in common between filtering types (i.e.: global filters and column menu filters).
+ */
+class Filters {
+  /**
+   * Function used to check whether the component is a KupTree or KupDataTable.
+   * @param {KupDataTable | KupTree} comp - Component using the column menu.
+   * @returns {comp is KupTree} Returns true when the component is KupTree.
+   */
+  static isTree(comp) {
+    return comp.rootElement.tagName === KupTagNames.TREE;
+  }
+  isObjFiltrableByInterval(obj) {
+    if (dom$3.ketchup.objects.isDate(obj)) {
+      return true;
+    }
+    if (dom$3.ketchup.objects.isTime(obj)) {
+      return true;
+    }
+    if (dom$3.ketchup.objects.isTimestamp(obj)) {
+      return true;
+    }
+    if (dom$3.ketchup.objects.isNumber(obj)) {
+      return true;
+    }
+    return false;
+  }
+  normalizeValue(value, smeupObj) {
+    let newValue = value != null ? value.trim() : value;
+    if (newValue == null || newValue == '' || smeupObj == null) {
+      return newValue;
+    }
+    if (dom$3.ketchup.objects.isDate(smeupObj)) {
+      if (dom$3.ketchup.dates.isValid(value, KupDatesFormats.ISO_DATE)) {
+        return newValue;
+      }
+      if (dom$3.ketchup.dates.isValid(value)) {
+        return dom$3.ketchup.dates.format(dom$3.ketchup.dates.normalize(value, KupDatesNormalize.DATE), KupDatesFormats.ISO_DATE);
+      }
+    }
+    else if (dom$3.ketchup.objects.isTime(smeupObj)) {
+      let manageSeconds = dom$3.ketchup.objects.isTimeWithSeconds(smeupObj);
+      if (dom$3.ketchup.dates.isValid(value, manageSeconds
+        ? KupDatesFormats.ISO_TIME
+        : KupDatesFormats.ISO_TIME_WITHOUT_SECONDS)) {
+        return newValue;
+      }
+      if (isValidFormattedStringTime(value, manageSeconds)) {
+        return formattedStringToCustomUnformattedStringTime(value, manageSeconds
+          ? KupDatesFormats.ISO_TIME
+          : KupDatesFormats.ISO_TIME_WITHOUT_SECONDS, manageSeconds);
+      }
+    }
+    else if (dom$3.ketchup.objects.isTimestamp(smeupObj)) {
+      if (dom$3.ketchup.dates.isValid(value, KupDatesFormats.ISO_DATE_TIME)) {
+        return newValue;
+      }
+      if (isValidFormattedStringTime(value, true)) {
+        return formattedStringToDefaultUnformattedStringTimestamp(value);
+      }
+    }
+    else if (dom$3.ketchup.objects.isNumber(smeupObj)) {
+      if (isValidFormattedStringNumber(value, smeupObj ? smeupObj.p : '')) {
+        return formattedStringToUnformattedStringNumber(value, smeupObj ? smeupObj.p : '');
+      }
+    }
+    return newValue;
+  }
+  /**
+   * Given a filter value, check if is a negative filter
+   * @param filterValue the filter value to use for check
+   */
+  filterIsNegative(filterValue) {
+    const analyzedFilter = filterValue.match(FILTER_ANALIZER);
+    const filterIsNegative = analyzedFilter
+      ? analyzedFilter[1].indexOf('!') >= 0
+      : false;
+    return filterIsNegative;
+  }
+  /**
+   * Given a value and a filter value, returns if that value matches the filter.
+   *
+   * Web filters can also be expressions: by putting strings between single quotes (') it's possible to activate filter expressions.
+   * Valid syntax:
+   * 'filter' = search for exact phrase;
+   * '' = match when value is empty;
+   * 'filter%' = match when a string starts with "filter";
+   * '%filter' = match when a string ends with "filter";
+   * '%filter%' = match when a string contains "filter".
+   *
+   * It is also possible to negate the expression by prepending "!" in front of the expression.
+   * For example: !'' = value in the cell must not be empty.
+   *
+   * With no expression set, the filter is by default set to '%filter%'.
+   *
+   * @param value - The current value to check.
+   * @param filterValue - The value of the current filter.
+   * @returns false if value or filterValue are empty;
+              true if value contains filterValue;
+              true if value matches special filter created on filterValue;
+              false otherwise.
+   */
+  isFilterCompliantForValue(value, filterValue) {
+    if (value == null) {
+      return false;
+    }
+    if (filterValue == null) {
+      return false;
+    }
+    const _filterIsNegative = this.filterIsNegative(filterValue);
+    // checks if the value of the filter is contained inside value of the object
+    // Or is if the filter is a special filter to be matched.
+    if (value.toLowerCase().includes(filterValue.toLowerCase()) ||
+      this.matchSpecialFilter(value.toLowerCase(), filterValue.toLowerCase().match(FILTER_ANALIZER), true)) {
+      // the element matches the field filter
+      if (_filterIsNegative) {
+        return false;
+      }
+      return true;
+    }
+    if (_filterIsNegative) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Given a value and a filter value, returns if that value matches the filter.
+   *
+   * Web filters can also be expressions: by putting strings between single quotes (') it's possible to activate filter expressions.
+   * Valid syntax:
+   * 'filter' = search for exact phrase;
+   * '' = match when value is empty;
+   * 'filter%' = match when a string starts with "filter";
+   * '%filter' = match when a string ends with "filter";
+   * '%filter%' = match when a string contains "filter".
+   *
+   * It is also possible to negate the expression by prepending "!" in front of the expression.
+   * For example: !'' = value in the cell must not be empty.
+   *
+   * With no expression set, the filter is by default set to '%filter%'.
+   *
+   * @param value - The current value to check.
+   * @param parsedFilter - The value of the current filter.
+   * @param ignoreNegativeFlag = false - When set to true, the matcher will ignore the (!) operator; useful for global filter.
+   * @returns True if the filter is empty and the value of the cell is empty, false otherwise.
+   */
+  matchSpecialFilter(value, parsedFilter, ignoreNegativeFlag = false) {
+    if (parsedFilter != null) {
+      // endsWith and startWith are not supported by IE 11
+      // Check here https://www.w3schools.com/jsref/jsref_endswith.asp
+      const toRet = (parsedFilter[3] === '' && !value.trim()) ||
+        (!parsedFilter[2] &&
+          parsedFilter[4] &&
+          value.startsWith(parsedFilter[3])) ||
+        (parsedFilter[2] &&
+          !parsedFilter[4] &&
+          value.endsWith(parsedFilter[3])) ||
+        (!parsedFilter[2] &&
+          !parsedFilter[4] &&
+          value === parsedFilter[3]) ||
+        (parsedFilter[2] &&
+          parsedFilter[4] &&
+          value.indexOf(parsedFilter[3]) >= 0);
+      return !ignoreNegativeFlag
+        ? parsedFilter[1].indexOf('!') < 0
+          ? toRet
+          : !toRet
+        : toRet;
+    }
+    return false;
+  }
+  isFilterCompliantForSimpleValue(valueToCheck, obj, filterValue, interval) {
+    if (valueToCheck == null) {
+      return false;
+    }
+    filterValue = this.normalizeValue(filterValue, obj);
+    let value = valueToCheck;
+    let from = '';
+    let to = '';
+    if (interval != null) {
+      from = interval[FilterInterval.FROM];
+      to = interval[FilterInterval.TO];
+    }
+    let checkByRegularExpression = true;
+    if (dom$3.ketchup.objects.isNumber(obj)) {
+      value = unformattedStringNumberToNumber(value, obj ? obj.p : '');
+      let valueNumber = stringToNumber(value);
+      if (from != '') {
+        if (isNumber(from)) {
+          checkByRegularExpression = false;
+          let fromNumber = stringToNumber(from);
+          if (valueNumber < fromNumber) {
+            return false;
+          }
+        }
+        else {
+          filterValue = from;
+        }
+      }
+      if (to != '') {
+        if (isNumber(to)) {
+          checkByRegularExpression = false;
+          let toNumber = stringToNumber(to);
+          if (valueNumber > toNumber) {
+            return false;
+          }
+        }
+        else {
+          filterValue = to;
+        }
+      }
+    }
+    if (dom$3.ketchup.objects.isDate(obj) ||
+      dom$3.ketchup.objects.isTime(obj) ||
+      dom$3.ketchup.objects.isTimestamp(obj)) {
+      let valueDate = null;
+      let defaultFormat = KupDatesFormats.ISO_DATE;
+      if (dom$3.ketchup.objects.isDate(obj)) {
+        defaultFormat = KupDatesFormats.ISO_DATE;
+      }
+      else if (dom$3.ketchup.objects.isTime(obj)) {
+        defaultFormat = dom$3.ketchup.objects.isTimeWithSeconds(obj)
+          ? KupDatesFormats.ISO_TIME
+          : KupDatesFormats.ISO_TIME_WITHOUT_SECONDS;
+      }
+      else if (dom$3.ketchup.objects.isTimestamp(obj)) {
+        defaultFormat = KupDatesFormats.ISO_DATE_TIME;
+      }
+      if (dom$3.ketchup.dates.isValid(value, defaultFormat, true)) {
+        valueDate = dom$3.ketchup.dates.toDate(value, defaultFormat);
+      }
+      if (from != '') {
+        if (valueDate != null &&
+          dom$3.ketchup.dates.isValid(from, defaultFormat, true)) {
+          checkByRegularExpression = false;
+          let fromDate = dom$3.ketchup.dates.toDate(from, defaultFormat);
+          if (valueDate < fromDate) {
+            return false;
+          }
+        }
+        else {
+          filterValue = from;
+        }
+      }
+      if (to != '') {
+        if (valueDate != null &&
+          dom$3.ketchup.dates.isValid(to, defaultFormat, true)) {
+          checkByRegularExpression = false;
+          let toDate = dom$3.ketchup.dates.toDate(to, defaultFormat);
+          if (valueDate > toDate) {
+            return false;
+          }
+        }
+        else {
+          filterValue = to;
+        }
+      }
+      if (!dom$3.ketchup.dates.isValid(filterValue, defaultFormat) &&
+        !dom$3.ketchup.dates.isValid(filterValue)) {
+        value = dom$3.ketchup.dates.format(value);
+      }
+    }
+    if (checkByRegularExpression) {
+      return this.isFilterCompliantForValue(value, filterValue);
+    }
+    return true;
+  }
+  static valuesArrayContainsValue(values, value) {
+    return Filters.indexOfValueInValuesArray(values, value) >= 0;
+  }
+  static indexOfValueInValuesArray(values, value) {
+    if (values == null || values.length < 1) {
+      return -1;
+    }
+    for (let i = 0; i < values.length; i++) {
+      if (values[i].value == value) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}
+
+/**
+ * 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["autoSelectionNodeMode"] = "Auto select programmatic selectic node";
+  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["selectedNode"] = "An array of integers containing the path to a selected child. Groups up the properties SelFirst, SelItem, SelName.";
+  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$2 = document.documentElement;
+const kupObjects = dom$2.ketchup
+  ? dom$2.ketchup.objects
+  : new KupObjects();
+/**
+ * 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 (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]);
+    }
+    this.extractColumnValues(tmpRows, column, values);
+    values.sort((n1, n2) => {
+      return compareValues(null, getValueForDisplay2(n1, column), null, getValueForDisplay2(n2, column), SortMode.A);
+    });
+    return values;
+  }
+  extractColumnValues(rows, column, values) {
+    /** il valore delle righe attualmente filtrate, formattato */
+    rows.forEach((row) => this.addColumnValueFromRow(values, column, row.cells[column.name]));
+    return values;
+  }
+  addColumnValueFromRow(values, column, cell) {
+    if (cell) {
+      let item = {
+        value: cell.value,
+        displayedValue: getCellValueForDisplay(column, cell),
+      };
+      if (!Filters.valuesArrayContainsValue(values, cell.value)) {
+        values.push(item);
+      }
+    }
+  }
+}
+
+const dom$1 = 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 currentTotalValue = dom$1.ketchup.math.numberify(groupRow.group.totals[key] || 0);
+    const cell = addedRow.cells[key];
+    if (cell) {
+      let _isNumber = dom$1.ketchup.objects.isNumber(cell.obj);
+      const totalMode = totals[key];
+      switch (totalMode) {
+        case TotalMode.COUNT:
+          groupRow.group.totals[key] = currentTotalValue + 1;
+          // updating parents
+          let parent = groupRow.group.parent;
+          while (parent != null) {
+            const currentParentCount = parent.group.totals[key] || 0;
+            parent.group.totals[key] = currentParentCount + 1;
+            parent = parent.group.parent;
+          }
+          break;
+        case TotalMode.DISTINCT:
+          let cellValue;
+          if (_isNumber) {
+            cellValue = dom$1.ketchup.math.numberify(stringToNumber(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) {
+            const cellValue = dom$1.ketchup.math.numberify(stringToNumber(cell.value));
+            groupRow.group.totals[key] =
+              cellValue + currentTotalValue;
+            // updating parents
+            let parent = groupRow.group.parent;
+            while (parent != null) {
+              const currentParentSum = dom$1.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) {
+            const currentTotalValue = groupRow.group.totals[key];
+            const cellValue = dom$1.ketchup.math.numberify(stringToNumber(cell.value));
+            if (currentTotalValue) {
+              groupRow.group.totals[key] = Math.min(currentTotalValue, 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 (dom$1.ketchup.objects.isDate(cell.obj)) {
+            const momentValue = cell.obj
+              ? dom$1.ketchup.objects.parseDate(cell.obj)
+              : dom$1.ketchup.dates.toDayjs(cell.value);
+            if (dom$1.ketchup.dates.isValid(momentValue)) {
+              const cellValue = dom$1.ketchup.dates.toDate(momentValue);
+              const currentTotalValue = groupRow.group.totals[key];
+              if (currentTotalValue) {
+                let moments = [];
+                moments.push(cellValue);
+                moments.push(dom$1.ketchup.dates.format(currentTotalValue));
+                groupRow.group.totals[key] =
+                  dom$1.ketchup.dates.format(dom$1.ketchup.dates.min(moments));
+              }
+              else {
+                groupRow.group.totals[key] = cellValue;
+              }
+              // 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$1.ketchup.dates.format(currentParentMin));
+                  parent.group.totals[key] =
+                    dom$1.ketchup.dates.format(dom$1.ketchup.dates.min(moments));
+                }
+                else {
+                  // first round
+                  parent.group.totals[key] = cellValue;
+                }
+                parent = parent.group.parent;
+              }
+            }
+          }
+          break;
+        // TODO DRY the MIN and MAX functions
+        case TotalMode.MAX:
+          if (_isNumber) {
+            const currentTotalValue = groupRow.group.totals[key];
+            const cellValue = dom$1.ketchup.math.numberify(stringToNumber(cell.value));
+            if (currentTotalValue) {
+              groupRow.group.totals[key] = Math.max(currentTotalValue, 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 (dom$1.ketchup.objects.isDate(cell.obj)) {
+            const momentValue = cell.obj
+              ? dom$1.ketchup.objects.parseDate(cell.obj)
+              : dom$1.ketchup.dates.toDayjs(cell.value);
+            if (dom$1.ketchup.dates.isValid(momentValue)) {
+              const cellValue = dom$1.ketchup.dates.toDate(momentValue);
+              const currentTotalValue = groupRow.group.totals[key];
+              if (currentTotalValue) {
+                let moments = [];
+                moments.push(cellValue);
+                moments.push(dom$1.ketchup.dates.format(currentTotalValue));
+                groupRow.group.totals[key] =
+                  dom$1.ketchup.dates.format(dom$1.ketchup.dates.max(moments));
+              }
+              else {
+                groupRow.group.totals[key] = cellValue;
+              }
+              // 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$1.ketchup.dates.format(currentParentMin));
+                  parent.group.totals[key] =
+                    dom$1.ketchup.dates.format(dom$1.ketchup.dates.max(moments));
+                }
+                else {
+                  // first round
+                  parent.group.totals[key] = cellValue;
+                }
+                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] =
+        dom$1.ketchup.math.numberify(row.group.totals[key]) /
+          numberOfLeaf;
+    }
+    if (type == TotalMode.MATH) {
+      let formula = totals[key].substring(TotalMode.MATH.length);
+      row.group.totals[key] = dom$1.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$1.ketchup.objects.isEmptyJsObject(rows) ||
+    dom$1.ketchup.objects.isEmptyJsObject(totals)) {
+    return {};
+  }
+  const keys = Object.keys(totals);
+  const footerRow = {};
+  // 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$1.ketchup.objects.isNumber(cell.obj)) {
+              cellValue = dom$1.ketchup.math.numberify(stringToNumber(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$1.ketchup.objects.isNumber(cell.obj)) {
+            const cellValue = dom$1.ketchup.math.numberify(stringToNumber(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$1.ketchup.math.numberify(currentFooterValue);
+            }
+            // TODO DRY the MIN and MAX functions
+          }
+          else if (dom$1.ketchup.objects.isDate(cell.obj)) {
+            const momentValue = cell.obj
+              ? dom$1.ketchup.objects.parseDate(cell.obj)
+              : dom$1.ketchup.dates.toDayjs(cell.value);
+            if (dom$1.ketchup.dates.isValid(momentValue)) {
+              const cellValue = dom$1.ketchup.dates.toDate(momentValue);
+              const currentFooterValue = footerRow[key];
+              switch (true) {
+                case totals[key] === TotalMode.MIN:
+                  if (currentFooterValue) {
+                    let moments = [];
+                    moments.push(cellValue);
+                    moments.push(dom$1.ketchup.dates.format(currentFooterValue));
+                    footerRow[key] =
+                      dom$1.ketchup.dates.format(dom$1.ketchup.dates.min(moments));
+                  }
+                  else {
+                    footerRow[key] = cellValue;
+                  }
+                  break;
+                case totals[key] === TotalMode.MAX:
+                  if (currentFooterValue) {
+                    let moments = [];
+                    moments.push(cellValue);
+                    moments.push(dom$1.ketchup.dates.format(currentFooterValue));
+                    footerRow[key] =
+                      dom$1.ketchup.dates.format(dom$1.ketchup.dates.max(moments));
+                  }
+                  else {
+                    footerRow[key] = cellValue;
+                  }
+                  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$1.ketchup.math.formulas.custom(totals[key].substring(TotalMode.MATH.length), footerRow);
+          break;
+      }
+      if (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;
+  }
+  let cloned = {
+    id: row.id,
+    cells: Object.assign({}, row.cells),
+    actions: row.actions ? [...row.actions] : null,
+    group: cloneRowGroup(row.group),
+    readOnly: row.readOnly,
+    cssClass: row.cssClass,
+  };
+  return cloned;
+}
+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 = 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.ketchup.language.translate(KupLanguagePage.PAGE),
+      helper: dom.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.ketchup.language.translate(KupLanguageRow.ROWS) +
+        ' / ' +
+        dom.ketchup.language.translate(KupLanguagePage.PAGE),
+      helper: dom.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.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;
+}
+
+function pageChange(pageNumber, max, perPage) {
+  if (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 (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, Filters as b, FilterInterval as c, calcTotals as d, FPaginator as e, filterRows as f, groupRows as g, pageChange as h, KupGlobalFilterMode as i, KupTreeProps as j, FPaginatorMode as k, normalizeRows as n, paginateRows as p, rowsPerPageChange as r, sortRows as s, treeMainColumnName as t };