@sme.up/ketchup 9.2.0 → 9.4.0

package/dist/collection/components/kup-data-table/kup-data-table-helper.js

@@ -4,95 +4,95 @@ import { FiltersRows } from "../../utils/filters/filters-rows";
 import { KupDatesFormats, } from "../../managers/kup-dates/kup-dates-declarations";
 const dom = document.documentElement;
 export 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;
+    if (!rows || rows.length === 0) {
+        return [];
     }
-    else {
-      return compareRows(r1, r2, sort[0]);
+    // 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;
+    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;
+    if (!column || !sort || sort.length === 0) {
+        return null;
     }
-  }
-  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);
+    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 --------
 /**
@@ -106,702 +106,702 @@ function compareRows(r1, r2, sortObj) {
  *    single filters and global filter, all controls on a single column are done in a single cycle.
  */
 export function filterRows(rows = [], filters = {}, globalFilter = '', columns = [], columnFilters, filtersRows) {
-  if (filtersRows == null) {
-    filtersRows = new FiltersRows();
-  }
-  return filtersRows.filterRows(rows, filters, globalFilter, columns, columnFilters);
+    if (filtersRows == null) {
+        filtersRows = new FiltersRows();
+    }
+    return filtersRows.filterRows(rows, filters, globalFilter, columns, columnFilters);
 }
 export 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 (!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;
             }
-          }
-          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.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.ketchup.math.numberify(dom.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.ketchup.math.numberify(dom.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.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.ketchup.math.numberify(dom.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.ketchup.objects.isDate(cell.obj)) {
-            const cellValue = dom.ketchup.dates.toDayjs(cell.value);
-            if (dom.ketchup.dates.isValid(cellValue)) {
-              const currentMinValue = groupRow.group.totals[key];
-              if (currentMinValue) {
-                let moments = [];
-                moments.push(cellValue);
-                moments.push(dom.ketchup.dates.toDayjs(currentMinValue));
-                groupRow.group.totals[key] =
-                  dom.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
-              }
-              else {
-                groupRow.group.totals[key] =
-                  dom.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.ketchup.dates.toDayjs(currentParentMin));
-                  parent.group.totals[key] =
-                    dom.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
-                }
-                else {
-                  // first round
-                  parent.group.totals[key] =
-                    dom.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+        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;
                 }
-                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.ketchup.math.numberify(dom.ketchup.math.numberifySafe(cell.value));
-            if (currentMaxValue) {
-              groupRow.group.totals[key] = Math.max(currentMaxValue, cellValue);
+            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);
             }
-            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.ketchup.objects.isDate(cell.obj)) {
-            const cellValue = dom.ketchup.dates.toDayjs(cell.value);
-            if (dom.ketchup.dates.isValid(cellValue)) {
-              const currentMaxValue = groupRow.group.totals[key];
-              if (currentMaxValue) {
-                let moments = [];
-                moments.push(cellValue);
-                moments.push(dom.ketchup.dates.toDayjs(currentMaxValue));
-                groupRow.group.totals[key] =
-                  dom.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
-              }
-              else {
-                groupRow.group.totals[key] =
-                  dom.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.ketchup.dates.toDayjs(currentParentMax));
-                  parent.group.totals[key] =
-                    dom.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+            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;
                 }
-                else {
-                  // first round
-                  parent.group.totals[key] =
-                    dom.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;
+            // 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.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.ketchup.math.numberify(dom.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.ketchup.math.numberify(dom.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.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.ketchup.math.numberify(dom.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.ketchup.objects.isDate(cell.obj)) {
+                        const cellValue = dom.ketchup.dates.toDayjs(cell.value);
+                        if (dom.ketchup.dates.isValid(cellValue)) {
+                            const currentMinValue = groupRow.group.totals[key];
+                            if (currentMinValue) {
+                                let moments = [];
+                                moments.push(cellValue);
+                                moments.push(dom.ketchup.dates.toDayjs(currentMinValue));
+                                groupRow.group.totals[key] =
+                                    dom.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                            }
+                            else {
+                                groupRow.group.totals[key] =
+                                    dom.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.ketchup.dates.toDayjs(currentParentMin));
+                                    parent.group.totals[key] =
+                                        dom.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                                }
+                                else {
+                                    // first round
+                                    parent.group.totals[key] =
+                                        dom.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.ketchup.math.numberify(dom.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.ketchup.objects.isDate(cell.obj)) {
+                        const cellValue = dom.ketchup.dates.toDayjs(cell.value);
+                        if (dom.ketchup.dates.isValid(cellValue)) {
+                            const currentMaxValue = groupRow.group.totals[key];
+                            if (currentMaxValue) {
+                                let moments = [];
+                                moments.push(cellValue);
+                                moments.push(dom.ketchup.dates.toDayjs(currentMaxValue));
+                                groupRow.group.totals[key] =
+                                    dom.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                            }
+                            else {
+                                groupRow.group.totals[key] =
+                                    dom.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.ketchup.dates.toDayjs(currentParentMax));
+                                    parent.group.totals[key] =
+                                        dom.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                                }
+                                else {
+                                    // first round
+                                    parent.group.totals[key] =
+                                        dom.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));
-  }
+    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));
-  }
+    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);
+    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;
     });
-  }
-  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;
+    const children = row.group.children;
+    if (children.length === 0) {
+        return 0;
     }
-    if (type == TotalMode.MATH) {
-      let formula = totals[key].substring(TotalMode.MATH.length);
-      row.group.totals[key] = dom.ketchup.math.formulas.custom(formula, row.group.totals);
+    let numberOfLeaf = 0;
+    // check if child is a grouping row
+    if (children[0].group) {
+        children.forEach((child) => {
+            numberOfLeaf += adjustGroupAverageOrFormula(child, type, toAdjustKeys, totals);
+        });
     }
-  });
-  return numberOfLeaf;
-}
-export 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,
-            };
-          }
+    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.ketchup.math.formulas.custom(formula, row.group.totals);
         }
-      });
     });
-    return normalizedrows;
-  }
-  else {
-    return undefined;
-  }
+    return numberOfLeaf;
 }
-export function calcTotals(rows = [], totals = {}) {
-  if (dom.ketchup.objects.isEmptyJsObject(rows) ||
-    dom.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.ketchup.objects.isNumber(cell.obj)) {
-              cellValue = dom.ketchup.math.numberify(dom.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.ketchup.objects.isNumber(cell.obj)) {
-            const cellValue = dom.ketchup.math.numberify(dom.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);
+export 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,
+                        };
+                    }
                 }
-                else {
-                  footerRow[key] = cellValue;
+            });
+        });
+        return normalizedrows;
+    }
+    else {
+        return undefined;
+    }
+}
+export function calcTotals(rows = [], totals = {}) {
+    if (dom.ketchup.objects.isEmptyJsObject(rows) ||
+        dom.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.ketchup.objects.isNumber(cell.obj)) {
+                            cellValue = dom.ketchup.math.numberify(dom.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.ketchup.objects.isNumber(cell.obj)) {
+                        const cellValue = dom.ketchup.math.numberify(dom.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.ketchup.math.numberify(currentFooterValue);
+                        }
+                        // TODO DRY the MIN and MAX functions
+                    }
+                    else if (dom.ketchup.objects.isDate(cell.obj)) {
+                        if (dateColumns.indexOf(key) == -1) {
+                            dateColumns.push(key);
+                        }
+                        const momentValue = dom.ketchup.dates.toDayjs(cell.value);
+                        if (dom.ketchup.dates.isValid(momentValue)) {
+                            const cellValue = dom.ketchup.dates.toDate(momentValue);
+                            const currentFooterValue = footerRow[key]
+                                ? dom.ketchup.dates.toDate(dom.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.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
+                                    }
+                                    else {
+                                        footerRow[key] =
+                                            dom.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.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
+                                    }
+                                    else {
+                                        footerRow[key] =
+                                            dom.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
+                                    }
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
                 }
-                break;
-              case totals[key] === TotalMode.MAX:
-                if (currentFooterValue) {
-                  footerRow[key] = Math.max(currentFooterValue, cellValue);
+                if (index === array.length - 1 &&
+                    totals[key] === TotalMode.DISTINCT) {
+                    // last round
+                    footerRow[key] = new Set(distinctObj[key]).size;
+                    distinctObj[key] = [];
                 }
-                else {
-                  footerRow[key] = cellValue;
+            });
+        });
+    }
+    // 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;
-              default:
-                // SUM
-                currentFooterValue = footerRow[key] || 0;
-                footerRow[key] =
-                  cellValue +
-                    dom.ketchup.math.numberify(currentFooterValue);
-            }
-            // TODO DRY the MIN and MAX functions
-          }
-          else if (dom.ketchup.objects.isDate(cell.obj)) {
-            if (dateColumns.indexOf(key) == -1) {
-              dateColumns.push(key);
+            case totals[key] === TotalMode.COUNT:
+                footerRow[key] = rows.length;
+                break;
+            case totals[key].indexOf(TotalMode.MATH) == 0:
+                footerRow[key] = dom.ketchup.math.formulas.custom(totals[key].substring(TotalMode.MATH.length), footerRow);
+                break;
+            default:
+                break;
+        }
+        if (footerRow[key]) {
+            if (dateColumns.indexOf(key) != -1) {
+                footerRow[key] = dom.ketchup.dates.format(footerRow[key]);
             }
-            const momentValue = dom.ketchup.dates.toDayjs(cell.value);
-            if (dom.ketchup.dates.isValid(momentValue)) {
-              const cellValue = dom.ketchup.dates.toDate(momentValue);
-              const currentFooterValue = footerRow[key]
-                ? dom.ketchup.dates.toDate(dom.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.ketchup.dates.format(dom.ketchup.dates.min(moments), KupDatesFormats.ISO_DATE);
-                  }
-                  else {
-                    footerRow[key] =
-                      dom.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.ketchup.dates.format(dom.ketchup.dates.max(moments), KupDatesFormats.ISO_DATE);
-                  }
-                  else {
-                    footerRow[key] =
-                      dom.ketchup.dates.format(cellValue, KupDatesFormats.ISO_DATE);
-                  }
-                  break;
-                default:
-                  break;
-              }
+            else if (dom.ketchup.math.isNumber(footerRow[key])) {
+                footerRow[key] = +footerRow[key].toFixed(2);
             }
-          }
-        }
-        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.ketchup.math.formulas.custom(totals[key].substring(TotalMode.MATH.length), footerRow);
-        break;
-      default:
-        break;
-    }
-    if (footerRow[key]) {
-      if (dateColumns.indexOf(key) != -1) {
-        footerRow[key] = dom.ketchup.dates.format(footerRow[key]);
-      }
-      else if (dom.ketchup.math.isNumber(footerRow[key])) {
-        footerRow[key] = +footerRow[key].toFixed(2);
-      }
-    }
-  }
-  return footerRow;
+    }
+    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;
+    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;
 }
 export 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;
+    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;
+    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 };
+    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,
-    };
-  }
+    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;
+    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;
+    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;
 }