dtable-utils 0.0.3 → 0.0.4-beta.1

package/es/sort/sort-row.js

@@ -0,0 +1,110 @@
+import { deleteInvalidSort } from './core.js';
+import { sortCheckbox } from './sort-column/checkbox.js';
+import { sortCollaborator } from './sort-column/collaborator.js';
+import { sortDate } from './sort-column/date.js';
+import { getCollaboratorsNames } from '../cell-value-get/collaborator.js';
+import '../cell-value-get/cell-value.js';
+import { sortNumber } from './sort-column/number.js';
+import { sortText } from './sort-column/text.js';
+import { CellType } from '../constants/cell-type.js';
+import { DATE_COLUMN_OPTIONS } from '../constants/column.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+import { sortFormula } from './sort-column/formula.js';
+import { sortLink } from './sort-column/link.js';
+import { sortMultipleSelect } from './sort-column/multiple-select.js';
+import { sortSingleSelect } from './sort-column/single-select.js';
+import { NUMBER_SORTER_COLUMN_TYPES } from '../constants/sort.js';
+
+/**
+ * Sort rows with multiple sorts
+ * @param {array} tableRows e.g. [{ _id, [column.key]: '', ...}, ...]
+ * @param {array} sorts e.g. [{ column_key, sort_type, column, ... }, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ */
+var sortRowsWithMultiSorts = function sortRowsWithMultiSorts(tableRows, sorts, _ref) {
+  var _ref$formulaRows = _ref.formulaRows,
+    formulaRows = _ref$formulaRows === void 0 ? {} : _ref$formulaRows,
+    value = _ref.value;
+  tableRows.sort(function (currentRow, nextRow) {
+    var initValue = 0;
+    sorts.forEach(function (sort) {
+      var column_key = sort.column_key,
+        sort_type = sort.sort_type,
+        column = sort.column;
+      var columnType = column.type,
+        columnData = column.data;
+      var currCellVal = currentRow[column_key];
+      var nextCellVal = nextRow[column_key];
+      if (DATE_COLUMN_OPTIONS.includes(columnType)) {
+        initValue = initValue || sortDate(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === CellType.SINGLE_SELECT) {
+        initValue = initValue || sortSingleSelect(currCellVal, nextCellVal, sort);
+      } else if (NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        initValue = initValue || sortNumber(currCellVal, nextCellVal, sort_type);
+      } else if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currentFormulaRow = formulaRows[currentRow._id] || {};
+        var nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = currentFormulaRow[column_key];
+        nextCellVal = nextFormulaRow[column_key];
+        initValue = initValue || sortFormula(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === CellType.COLLABORATOR) {
+        var collaborators = value.collaborators;
+        var currValidCollaborators = currCellVal;
+        var nextValidCollaborators = nextCellVal;
+        if (collaborators) {
+          currValidCollaborators = getCollaboratorsNames(currCellVal, collaborators);
+          nextValidCollaborators = getCollaboratorsNames(nextCellVal, collaborators);
+        }
+        initValue = initValue || sortCollaborator(currValidCollaborators, nextValidCollaborators, sort_type);
+      } else if (columnType === CellType.CHECKBOX) {
+        initValue = initValue || sortCheckbox(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === CellType.MULTIPLE_SELECT) {
+        initValue = initValue || sortMultipleSelect(currCellVal, nextCellVal, sort);
+      } else if (columnType === CellType.LINK) {
+        var _currentFormulaRow = formulaRows[currentRow._id] || {};
+        var _nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = _currentFormulaRow[column_key];
+        nextCellVal = _nextFormulaRow[column_key];
+        initValue = initValue || sortLink(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else {
+        initValue = initValue || sortText(currCellVal, nextCellVal, sort_type);
+      }
+    });
+    return initValue;
+  });
+};
+
+/**
+ * Get sorted rows ids from table rows with multiple sorts
+ * @param {array} sorts e.g. [{ column_key, sort_type, column, ... }, ...]
+ * @param {array} rows e.g. [{ _id, [column.key]: '', ...}, ...]
+ * @param {array} columns e.g. [{ key, type, ... }, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns sorted rows ids, array
+ */
+var sortTableRows = function sortTableRows(sorts, rows, columns) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    formulaRows = _ref2.formulaRows,
+    value = _ref2.value;
+  if (!Array.isArray(rows) || rows.length === 0) return [];
+  var sortRows = rows.slice(0);
+  var validSorts = deleteInvalidSort(sorts, columns);
+  var normalizedFormulaRows = formulaRows || {};
+  sortRowsWithMultiSorts(sortRows, validSorts, {
+    formulaRows: normalizedFormulaRows,
+    value: value
+  });
+  return sortRows.map(function (row) {
+    return row._id;
+  });
+};
+
+export { sortRowsWithMultiSorts, sortTableRows };

package/es/table/column.js

@@ -0,0 +1,27 @@
+/**
+ * Get column by key from table
+ * @param {object} table
+ * @param {string} columnKey
+ * @returns column, object
+ */
+var getTableColumnByKey = function getTableColumnByKey(table, columnKey) {
+  if (!table || !Array.isArray(table.columns) || !columnKey) return null;
+  return table.columns.find(function (column) {
+    return column.key === columnKey;
+  });
+};
+
+/**
+ * Get table column by name
+ * @param {object} table
+ * @param {string} columnName
+ * @returns column, object
+ */
+var getTableColumnByName = function getTableColumnByName(table, columnName) {
+  if (!table || !Array.isArray(table.columns) || !columnName) return null;
+  return table.columns.find(function (column) {
+    return column.name === columnName;
+  });
+};
+
+export { getTableColumnByKey, getTableColumnByName };

package/es/table/core.js

@@ -0,0 +1,14 @@
+/**
+ * Get table by id
+ * @param {array} tables
+ * @param {string} tableId
+ * @returns table, object
+ */
+var getTableById = function getTableById(tables, tableId) {
+  if (!Array.isArray(tables) || !tableId) return null;
+  return tables.find(function (table) {
+    return table._id === tableId;
+  });
+};
+
+export { getTableById };

package/es/table/row.js

@@ -0,0 +1,25 @@
+/**
+ * Get table row by id
+ * @param {object} table
+ * @param {string} rowId the id of row
+ * @returns row, object
+ */
+var getRowById = function getRowById(table, rowId) {
+  if (!table || !table.id_row_map || !rowId) return null;
+  return table.id_row_map[rowId];
+};
+
+/**
+ * Get table rows by ids
+ * @param {object} table { id_row_map, ... }
+ * @param {array} rowsIds [ row._id, ... ]
+ * @returns rows, array
+ */
+var getRowsByIds = function getRowsByIds(table, rowsIds) {
+  if (!table || !table.id_row_map || !Array.isArray(rowsIds)) return [];
+  return rowsIds.map(function (rowId) {
+    return table.id_row_map[rowId];
+  }).filter(Boolean);
+};
+
+export { getRowById, getRowsByIds };

package/es/validate/filter.js

@@ -5,7 +5,7 @@ import { CellType } from '../constants/cell-type.js';
 import { COLLABORATOR_COLUMN_TYPES } from '../constants/column.js';
 import { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from '../constants/formula.js';
 import { FILTER_ERR_MSG } from '../constants/filter/index.js';
-import { getColumnOptions } from '../column/common.js';
+import { getColumnOptions } from '../column/option.js';
 import { isDateColumn } from '../column/date.js';
 import { FILTER_PREDICATE_TYPE } from '../constants/filter/filter-predicate.js';
 import { FILTER_TERM_MODIFIER_TYPE } from '../constants/filter/filter-modifier.js';

package/es/validate/geolocation.js

@@ -0,0 +1,5 @@
+var isValidPosition = function isValidPosition(lng, lat) {
+  return (lng || lng === 0) && (lat || lat === 0);
+};
+
+export { isValidPosition };

package/es/view/core.js

@@ -0,0 +1,134 @@
+import { getValidFilters, getValidFiltersWithoutError } from '../filter/core.js';
+import { getValidGroupbys } from '../group/core.js';
+import { getValidSorts } from '../sort/core.js';
+import { CellType } from '../constants/cell-type.js';
+
+/**
+ * Get view by id
+ * @param {array} views e.g. [{ _id, ... }, ...]
+ * @param {string} viewId
+ * @returns view, object
+ */
+var getViewById = function getViewById(views, viewId) {
+  if (!Array.isArray(views) || !viewId) return null;
+  return views.find(function (view) {
+    return view._id === viewId;
+  });
+};
+
+/**
+ * Check whether the view contains filters
+ * @param {object} view e.g. { filters, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isFilterView = function isFilterView(view, columns) {
+  var validFilters = getValidFilters(view.filters, columns);
+  return validFilters.length > 0;
+};
+
+/**
+ * Check whether the view contains groupbys
+ * @param {object} view e.g. { groupbys, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isGroupView = function isGroupView(view, columns) {
+  var validGroupbys = getValidGroupbys(view.groupbys, columns);
+  return validGroupbys.length > 0;
+};
+
+/**
+ * Check whether the view contains sorts
+ * @param {object} view e.g. { sorts, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isSortView = function isSortView(view, columns) {
+  var validSorts = getValidSorts(view.sorts, columns);
+  return validSorts.length > 0;
+};
+
+/**
+ * Check is default view which no contains filters, sorts, groupbys etc.
+ * @param {object} view e.g. { filters, groupbys, sorts, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isDefaultView = function isDefaultView(view, columns) {
+  return !isFilterView(view, columns) && !isSortView(view, columns) && !isGroupView(view, columns);
+};
+
+/**
+ * Get link columns which used either in filters, groupbys, sorts etc.
+ * @param {object} view e.g. { filters, groupbys, sorts, ... }
+ * @param {object} table e.g. { columns, ... }
+ * @returns link columns, array
+ */
+var getLinkColumnsUsedInFilters = function getLinkColumnsUsedInFilters(view, table) {
+  var filters = view.filters,
+    sorts = view.sorts,
+    groupbys = view.groupbys;
+  var columns = table.columns;
+  if (!Array.isArray(columns)) return [];
+  var validFilters = getValidFiltersWithoutError(filters, columns);
+  var validSorts = getValidSorts(sorts, columns);
+  var validGroupbys = getValidGroupbys(groupbys, columns);
+  var hasFilters = validFilters && validFilters.length > 0;
+  var hasSorts = validSorts && validSorts.length > 0;
+  var hasGroupbys = validGroupbys && validGroupbys.length > 0;
+  if (!hasFilters && !hasSorts && !hasGroupbys) return [];
+  var keyLinkColumnMap = {};
+  var keyExistLinkColumnMap = {};
+  var linkColumns = [];
+  columns.forEach(function (column) {
+    var key = column.key,
+      name = column.name,
+      type = column.type,
+      data = column.data,
+      width = column.width;
+    if (type === CellType.LINK) {
+      keyLinkColumnMap[column.key] = {
+        key: key,
+        name: name,
+        type: type,
+        data: data,
+        width: width
+      };
+    }
+  });
+  if (Object.keys(keyLinkColumnMap).length === 0) return [];
+  if (hasFilters) {
+    validFilters.forEach(function (filter) {
+      var filterColumnKey = filter.column_key;
+      var filterLinkColumn = keyLinkColumnMap[filterColumnKey];
+      if (filterLinkColumn && !keyExistLinkColumnMap[filterColumnKey]) {
+        linkColumns.push(filterLinkColumn);
+        keyExistLinkColumnMap[filterColumnKey] = true;
+      }
+    });
+  }
+  if (hasSorts) {
+    validSorts.forEach(function (sort) {
+      var sortColumnKey = sort.column_key;
+      var sortLinkColumn = keyLinkColumnMap[sortColumnKey];
+      if (sortLinkColumn && !keyExistLinkColumnMap[sortColumnKey]) {
+        linkColumns.push(sortLinkColumn);
+        keyExistLinkColumnMap[sortColumnKey] = true;
+      }
+    });
+  }
+  if (hasGroupbys) {
+    validGroupbys.forEach(function (groupby) {
+      var groupbyColumnKey = groupby.column_key;
+      var groupbyLinkColumn = keyLinkColumnMap[groupbyColumnKey];
+      if (groupbyLinkColumn && !keyExistLinkColumnMap[groupbyColumnKey]) {
+        linkColumns.push(groupbyLinkColumn);
+        keyExistLinkColumnMap[groupbyColumnKey] = true;
+      }
+    });
+  }
+  return linkColumns;
+};
+
+export { getLinkColumnsUsedInFilters, getViewById, isDefaultView, isFilterView, isGroupView, isSortView };

package/es/view/formula.js

@@ -0,0 +1,147 @@
+import { CellType } from '../constants/cell-type.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+
+/**
+ * Transform the formats of link column to link-formula's
+ * @param {object} linkColumn e.g. { key, data: { display_column_key, ... }, ... }
+ * @returns converted link column, object
+ */
+var transLink2LinkFormula = function transLink2LinkFormula(linkColumn) {
+  var key = linkColumn.key,
+    name = linkColumn.name,
+    data = linkColumn.data;
+  var display_column_key = data.display_column_key;
+  return {
+    key: key,
+    name: name,
+    type: CellType.LINK_FORMULA,
+    data: {
+      formula: 'lookup',
+      link_column_key: key,
+      level1_linked_table_column_key: display_column_key,
+      level2_linked_table_column_key: null,
+      operated_columns: []
+    }
+  };
+};
+
+/**
+ * Get sorted formula columns
+ * @param {array} formulaColumns the formula columns waiting to sort
+ * @param {object} table e.g. { columns, ... }
+ * @returns sorted formula columns, array
+ */
+var getSortedFormulaColumns = function getSortedFormulaColumns(formulaColumns, table) {
+  if (!Array.isArray(formulaColumns) || !table || !Array.isArray(table.columns)) return [];
+  var keyColumnMap = {};
+  table.columns.forEach(function (column) {
+    var key = column.key,
+      type = column.type;
+    if (FORMULA_COLUMN_TYPES_MAP[type]) {
+      keyColumnMap[key] = column;
+    } else if (type === CellType.LINK && column.data) {
+      keyColumnMap[key] = transLink2LinkFormula(column);
+    }
+  });
+
+  // get none-repeating formulas
+  var key_sorting_formula_column = {};
+  var sorting_formula_column_keys = [];
+  formulaColumns.forEach(function (column) {
+    var columnKey = column.key;
+    if (!key_sorting_formula_column[columnKey]) {
+      key_sorting_formula_column[columnKey] = column;
+      sorting_formula_column_keys.push(columnKey);
+    }
+  });
+
+  /**
+   * e.g. formula1 = formula2 + formula3
+   * e.g. formula2 = 1 + 2
+   * e.g. formula3 = formula2 + 3
+   * edges: formula2 --> formula1, formula2 --> formula3; formula3 --> formula1
+   * keyInDegreeMap, the total number of formula columns that depend on: { formula1_key: 2, formula2_key: 0, formula3_key: 1 }
+   * keyEdgesMap: { formula2_key: [formula1_key, formula3_key],  formula3_kye: [formula1_key]}
+   */
+  var keyInDegreeMap = {};
+  var keyEdgesMap = {};
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    var formulaColumn = key_sorting_formula_column[formulaColumnKey];
+    var data = formulaColumn.data;
+    var operated_columns = data.operated_columns;
+    keyInDegreeMap[formulaColumnKey] = 0;
+    if (Array.isArray(operated_columns)) {
+      operated_columns.forEach(function (dependColumnKey) {
+        var dependColumn = keyColumnMap[dependColumnKey];
+        if (!dependColumn) {
+          return;
+        }
+        keyInDegreeMap[formulaColumnKey] += 1;
+        if (keyEdgesMap[dependColumnKey]) {
+          keyEdgesMap[dependColumnKey].push(formulaColumnKey);
+        } else {
+          keyEdgesMap[dependColumnKey] = [formulaColumnKey];
+        }
+      });
+    }
+  });
+  var sortedList = [];
+  var waitingQueue = [];
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    if (keyInDegreeMap[formulaColumnKey] === 0) {
+      waitingQueue.push(formulaColumnKey);
+    }
+  });
+  while (waitingQueue.length) {
+    var columnKey = waitingQueue.shift();
+    var edges = keyEdgesMap[columnKey];
+    sortedList.push(columnKey);
+    if (Array.isArray(edges)) {
+      edges.forEach(function (edge) {
+        keyInDegreeMap[edge] -= 1;
+        if (keyInDegreeMap[edge] === 0) {
+          waitingQueue.push(edge);
+        }
+      });
+    }
+  }
+  return sortedList.map(function (columnKey) {
+    return keyColumnMap[columnKey];
+  });
+};
+
+/**
+ * Get table formula columns and link columns
+ * @param {object} table e.g. { columns, ... }
+ * @returns formula and link columns, array
+ */
+var getFormulaColumnsContainLinks = function getFormulaColumnsContainLinks(table) {
+  var columns = table.columns;
+  var formulaColumns = columns.filter(function (column) {
+    var type = column.type,
+      data = column.data;
+    if (type === CellType.LINK) {
+      return !!data;
+    }
+    return FORMULA_COLUMN_TYPES_MAP[type] && data;
+  });
+  return formulaColumns.map(function (column) {
+    if (column.type === CellType.LINK) {
+      return transLink2LinkFormula(column);
+    }
+    return column;
+  });
+};
+
+/**
+ * Get sorted formula and link columns from table
+ * @param {object} table e.g. { columns, ... }
+ * @returns sorted formula and link columns, array
+ */
+var getSortedFormulaColumnsContainLinks = function getSortedFormulaColumnsContainLinks(table) {
+  var formulaColumns = getFormulaColumnsContainLinks(table);
+  if (formulaColumns.length === 0) return [];
+  return getSortedFormulaColumns(formulaColumns, table);
+};
+
+export { getFormulaColumnsContainLinks, getSortedFormulaColumns, getSortedFormulaColumnsContainLinks, transLink2LinkFormula };

package/es/view/group.js

@@ -0,0 +1,32 @@
+/**
+ * Get group by paths
+ * @param {array} paths e.g. [ 0, 1, 2 ]
+ * @param {array} groups grouped rows
+ * @returns group, object
+ */
+var getGroupByPath = function getGroupByPath(paths, groups) {
+  if (!Array.isArray(paths) || !Array.isArray(groups)) {
+    return null;
+  }
+  var level0GroupIndex = paths[0];
+  if (level0GroupIndex < 0 || level0GroupIndex >= groups.length) {
+    return null;
+  }
+  var level = 1;
+  var foundGroup = groups[level0GroupIndex];
+  while (level < paths.length) {
+    if (!foundGroup) {
+      break;
+    }
+    var subGroups = foundGroup.subgroups;
+    var currentLevelGroupIndex = paths[level];
+    if (!Array.isArray(subGroups) || currentLevelGroupIndex < 0 || currentLevelGroupIndex >= subGroups.length) {
+      break;
+    }
+    foundGroup = subGroups[currentLevelGroupIndex];
+    level += 1;
+  }
+  return foundGroup;
+};
+
+export { getGroupByPath };

package/es/view/summaries.js

@@ -0,0 +1,167 @@
+import { getRowsByIds } from '../table/row.js';
+import { isTableRows } from '../row/core.js';
+import { isNumericColumn } from '../column/number.js';
+import { isNumber } from '../number.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+
+/**
+ * Calculate summaries of table numeric columns
+ * @param {object} table e.g. { columns, ... }
+ * @param {array} rows e.g. table rows: [{ _id, ...}, ...] | view rows: [ row._id, ... ]
+ * @param {object} formulaRows for numeric formula columns
+ * @returns summaries: { [column.key]: { sum, average, median, max, min, ... }, ... }, object
+ */
+var getSummaries = function getSummaries(table, rows, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return isNumericColumn(column);
+  });
+  if (numericColumns.length === 0) {
+    return {};
+  }
+  var summaryRows = isTableRows(rows) ? rows : getRowsByIds(table, rows);
+  var summaries = {};
+  numericColumns.forEach(function (column) {
+    var type = column.type,
+      key = column.key;
+    var validNumbersCount = 0;
+    var medianArr = [];
+    var sum = 0;
+    var min;
+    var max;
+    var median;
+    summaryRows.forEach(function (row) {
+      var cellValue = row[key];
+      if (FORMULA_COLUMN_TYPES_MAP[type]) {
+        var formulaRow = formulaRows && formulaRows[row._id];
+        cellValue = formulaRow && formulaRow[key];
+        if (Array.isArray(cellValue) && cellValue.length === 1) {
+          cellValue = cellValue[0];
+        }
+      }
+      if (isNumber(cellValue)) {
+        medianArr.push(cellValue);
+        validNumbersCount += 1;
+        sum += cellValue;
+        if (min === undefined) {
+          min = cellValue;
+        } else {
+          min = cellValue < min ? cellValue : min;
+        }
+        if (max === undefined) {
+          max = cellValue;
+        } else {
+          max = cellValue > max ? cellValue : max;
+        }
+      }
+    });
+    if (validNumbersCount > 0) {
+      medianArr.sort();
+      if (medianArr.length % 2 === 0) {
+        median = (medianArr[medianArr.length / 2 - 1] + medianArr[medianArr.length / 2]) / 2;
+      } else {
+        median = medianArr[parseInt(medianArr.length / 2)];
+      }
+    }
+    var average = validNumbersCount === 0 ? 0 : sum / validNumbersCount;
+    summaries[key] = {
+      sum: sum,
+      average: average,
+      median: median,
+      max: max,
+      min: min
+    };
+  });
+  return summaries;
+};
+
+/**
+ * Calculate group summaries by subgroup
+ * @param {array} subgroups e.g. [{ summaries, ... }, ...]
+ * @param {array} numericColumns
+ * @returns summaries: { [column.key]: { sum, average, median, max, min, ... }, ... }, object
+ */
+var getSummariesWithSubgroups = function getSummariesWithSubgroups(subgroups, numericColumns) {
+  var subgroupsLen = subgroups.length;
+  var summaries = {};
+  numericColumns.forEach(function (column) {
+    var medianArr = [];
+    var sum = 0;
+    var average = 0;
+    var median;
+    var max;
+    var min;
+    subgroups.forEach(function (subgroup) {
+      var subSummaries = subgroup.summaries;
+      var summary = subSummaries[column.key];
+      var subgroupSum = summary.sum,
+        subgroupAverage = summary.average,
+        subgroupMedian = summary.median,
+        subgroupMax = summary.max,
+        subgroupMin = summary.min;
+      sum += subgroupSum || 0;
+      average += subgroupAverage || 0;
+      if (isNumber(subgroupMedian)) {
+        medianArr.push(subgroupMedian);
+      }
+      if (isNumber(subgroupMax)) {
+        if (max === undefined) {
+          max = subgroupMax;
+        } else {
+          max = subgroupMax > max ? subgroupMax : max;
+        }
+      }
+      if (isNumber(subgroupMin)) {
+        if (min === undefined) {
+          min = subgroupMin;
+        } else {
+          min = subgroupMin < min ? subgroupMin : min;
+        }
+      }
+    });
+    if (medianArr.length > 0) {
+      medianArr.sort();
+      if (medianArr.length % 2 === 0) {
+        median = (medianArr[medianArr.length / 2 - 1] + medianArr[medianArr.length / 2]) / 2;
+      } else {
+        median = medianArr[parseInt(medianArr.length / 2)];
+      }
+    }
+    average /= subgroupsLen;
+    summaries[column.key] = {
+      sum: sum,
+      average: average,
+      median: median,
+      max: max,
+      min: min
+    };
+  });
+  return summaries;
+};
+
+/**
+ * Calculate group summaries
+ * @param {array} groups e.g. [{ subgroups, row_ids, ... }, ...]
+ * @param {object} table e.g. { columns, ... }
+ * @param {object} formulaRows for numeric formula columns
+ * @returns void
+ */
+var updateGroupSummaries = function updateGroupSummaries(groups, table, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return isNumericColumn(column);
+  });
+  if (!Array.isArray(groups) || numericColumns.length === 0) {
+    return;
+  }
+  groups.forEach(function (group) {
+    var subgroups = group.subgroups,
+      row_ids = group.row_ids;
+    if (Array.isArray(subgroups) && subgroups.length > 0) {
+      updateGroupSummaries(subgroups, table, formulaRows);
+      group.summaries = getSummariesWithSubgroups(subgroups, numericColumns);
+    } else if (row_ids) {
+      group.summaries = getSummaries(table, row_ids, formulaRows);
+    }
+  });
+};
+
+export { getSummaries, getSummariesWithSubgroups, updateGroupSummaries };