dtable-utils 0.0.1 → 0.0.3-beta.1

package/es/filter/filter-row.js

@@ -0,0 +1,198 @@
+import { getFormattedFilters, deleteInvalidFilter } from './core.js';
+import { checkboxFilter } from './filter-column/checkbox.js';
+import { collaboratorFilter } from './filter-column/collaborator.js';
+import { creatorFilter } from './filter-column/creator.js';
+import { dateFilter } from './filter-column/date.js';
+import { digitalSignFilter } from './filter-column/digital-sign.js';
+import { fileFilter } from './filter-column/file.js';
+import { formulaFilter } from './filter-column/formula.js';
+import { geolocationFilter } from './filter-column/geolocation.js';
+import { textFilter } from './filter-column/text.js';
+import { longTextFilter } from './filter-column/long-text.js';
+import { multipleSelectFilter } from './filter-column/multiple-select.js';
+import { numberFilter } from './filter-column/number.js';
+import { singleSelectFilter } from './filter-column/single-select.js';
+import { linkFilter } from './filter-column/link.js';
+import { FILTER_CONJUNCTION_TYPE } from '../constants/filter/index.js';
+import { DateUtils } from '../date.js';
+import { CellType } from '../constants/cell-type.js';
+import { DATE_FORMAT_MAP } from '../constants/column.js';
+
+var getFilterResult = function getFilterResult(row, filter, _ref) {
+  var formulaRow = _ref.formulaRow,
+    username = _ref.username,
+    userId = _ref.userId;
+  var column_key = filter.column_key,
+    column = filter.column;
+  var cellValue = row[column_key];
+  switch (column.type) {
+    case CellType.CHECKBOX:
+      {
+        return checkboxFilter(cellValue, filter);
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        return singleSelectFilter(cellValue, filter);
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        return multipleSelectFilter(cellValue, filter);
+      }
+    case CellType.DURATION:
+    case CellType.NUMBER:
+    case CellType.RATE:
+      {
+        return numberFilter(cellValue, filter);
+      }
+    case CellType.DATE:
+      {
+        return dateFilter(cellValue, filter);
+      }
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        cellValue = DateUtils.format(cellValue, DATE_FORMAT_MAP.YYYY_MM_DD_HH_MM_SS);
+        return dateFilter(cellValue, filter);
+      }
+    case CellType.COLLABORATOR:
+      {
+        return collaboratorFilter(cellValue, filter, username);
+      }
+    case CellType.LONG_TEXT:
+      {
+        return longTextFilter(cellValue, filter);
+      }
+    case CellType.TEXT:
+    case CellType.AUTO_NUMBER:
+    case CellType.EMAIL:
+    case CellType.URL:
+      {
+        return textFilter(cellValue, filter, userId);
+      }
+    case CellType.IMAGE:
+    case CellType.FILE:
+      {
+        return fileFilter(cellValue, filter);
+      }
+    case CellType.LAST_MODIFIER:
+    case CellType.CREATOR:
+      {
+        return creatorFilter(cellValue, filter, username);
+      }
+    case CellType.GEOLOCATION:
+      {
+        return geolocationFilter(cellValue, filter);
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        cellValue = formulaRow[column_key];
+        return formulaFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case CellType.LINK:
+      {
+        cellValue = formulaRow[column_key];
+        cellValue = Array.isArray(cellValue) ? cellValue.map(function (linked) {
+          return linked.display_value;
+        }) : null;
+        return linkFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case CellType.DIGITAL_SIGN:
+      {
+        return digitalSignFilter(cellValue, filter);
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+var filterRow = function filterRow(row, filterConjunction, filters) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    _ref2$formulaRow = _ref2.formulaRow,
+    formulaRow = _ref2$formulaRow === void 0 ? {} : _ref2$formulaRow,
+    _ref2$username = _ref2.username,
+    username = _ref2$username === void 0 ? '' : _ref2$username,
+    userId = _ref2.userId;
+  if (filterConjunction === FILTER_CONJUNCTION_TYPE.AND) {
+    return filters.every(function (filter) {
+      return getFilterResult(row, filter, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      });
+    });
+  }
+  if (filterConjunction === FILTER_CONJUNCTION_TYPE.OR) {
+    return filters.some(function (filter) {
+      return getFilterResult(row, filter, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      });
+    });
+  }
+  return false;
+};
+var filterRows = function filterRows(filterConjunction, filters, rows, _ref3) {
+  var formulaRows = _ref3.formulaRows,
+    username = _ref3.username,
+    userId = _ref3.userId;
+  var filteredRows = [];
+  var formattedFilters = getFormattedFilters(filters);
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var formulaRow = formulaRows && formulaRows[rowId] ? formulaRows[rowId] : {};
+    if (filterRow(row, filterConjunction, formattedFilters, {
+      formulaRow: formulaRow,
+      username: username,
+      userId: userId
+    })) {
+      filteredRows.push(rowId);
+    }
+  });
+  return filteredRows;
+};
+var getFilteredRowsWithoutFormulaCalculation = function getFilteredRowsWithoutFormulaCalculation(filterConjunction, filters, rows, table) {
+  var _ref4 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref4$formulaRows = _ref4.formulaRows,
+    formulaRows = _ref4$formulaRows === void 0 ? null : _ref4$formulaRows,
+    _ref4$username = _ref4.username,
+    username = _ref4$username === void 0 ? null : _ref4$username,
+    _ref4$userId = _ref4.userId,
+    userId = _ref4$userId === void 0 ? null : _ref4$userId;
+  var columns = table.columns;
+  var validFilters = [];
+  try {
+    validFilters = deleteInvalidFilter(filters, columns);
+  } catch (err) {
+    return {
+      row_ids: [],
+      error_message: err.message
+    };
+  }
+  var filteredRows = [];
+  if (validFilters.length === 0) {
+    filteredRows = rows.map(function (row) {
+      return row._id;
+    });
+  } else {
+    filteredRows = filterRows(filterConjunction, validFilters, rows, {
+      formulaRows: formulaRows,
+      username: username,
+      userId: userId
+    });
+  }
+  return {
+    row_ids: filteredRows,
+    error_message: null
+  };
+};
+
+export { filterRow, filterRows, getFilteredRowsWithoutFormulaCalculation };

package/es/group/core.js

@@ -0,0 +1,107 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { isDateColumn } from '../column/date.js';
+import { getLinkedTableID } from '../link/core.js';
+import { getTableColumnByKey } from '../table/column.js';
+import { getTableById } from '../table/core.js';
+import { CellType } from '../constants/cell-type.js';
+import { SUPPORT_GROUP_COLUMN_TYPES, GROUP_DATE_GRANULARITY, GROUP_GEOLOCATION_GRANULARITY } from '../constants/group.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * check is valid groupby
+ * @param {object} groupby { column_key: '', count_type: '', sort_type: '' }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isValidGroupby = function isValidGroupby(groupby, columns) {
+  if (!groupby || !Array.isArray(columns)) return false;
+  var column_key = groupby.column_key;
+  var groupbyColumn = columns.find(function (column) {
+    return column.key === column_key;
+  });
+  if (!groupbyColumn) {
+    return false;
+  }
+  return SUPPORT_GROUP_COLUMN_TYPES.includes(groupbyColumn.type);
+};
+
+/**
+ * get valid groupbys
+ * @param {array} groupbys
+ * @param {array} columns
+ * @returns array
+ */
+var getValidGroupbys = function getValidGroupbys(groupbys, columns) {
+  if (!Array.isArray(groupbys) || !Array.isArray(columns)) {
+    return [];
+  }
+  return groupbys.filter(function (groupby) {
+    return isValidGroupby(groupby, columns);
+  });
+};
+var deleteInvalidGroupby = function deleteInvalidGroupby(groupbys, columns, currentTable, value) {
+  var validGroupbys = getValidGroupbys(groupbys, columns);
+  var cleanGroupbys = [];
+  validGroupbys.forEach(function (groupby) {
+    var groupbyColumnKey = groupby.column_key,
+      count_type = groupby.count_type;
+    var groupbyColumn = columns.find(function (column) {
+      return groupbyColumnKey === column.key;
+    });
+    var columnType = groupbyColumn.type,
+      columnData = groupbyColumn.data;
+    var newGroupby = _objectSpread(_objectSpread({}, groupby), {}, {
+      column: groupbyColumn
+    });
+    switch (columnType) {
+      case CellType.DATE:
+      case CellType.CTIME:
+      case CellType.MTIME:
+        {
+          newGroupby.count_type = count_type || GROUP_DATE_GRANULARITY.MONTH;
+          break;
+        }
+      case CellType.GEOLOCATION:
+        {
+          newGroupby.count_type = count_type || GROUP_GEOLOCATION_GRANULARITY.PROVINCE;
+          break;
+        }
+      case CellType.COLLABORATOR:
+        {
+          var collaborator_email_map = {};
+          value.collaborators.forEach(function (collaborator) {
+            collaborator_email_map[collaborator.email] = true;
+          });
+          newGroupby.collaborator_email_map = collaborator_email_map;
+          break;
+        }
+      case CellType.LINK:
+        {
+          var table_id = columnData.table_id,
+            other_table_id = columnData.other_table_id,
+            display_column_key = columnData.display_column_key;
+          var currentTableId = currentTable ? currentTable._id : '';
+          var linkedTableID = getLinkedTableID(currentTableId, table_id, other_table_id);
+          var linkedTable = getTableById(value.tables, linkedTableID);
+          var displayColumn = getTableColumnByKey(linkedTable, display_column_key);
+          newGroupby.linked_table = linkedTable;
+          newGroupby.display_column = displayColumn;
+          break;
+        }
+      case CellType.FORMULA:
+      case CellType.LINK_FORMULA:
+        {
+          if (isDateColumn(groupbyColumn) && !count_type) {
+            newGroupby.count_type = GROUP_DATE_GRANULARITY.MONTH;
+          }
+          break;
+        }
+    }
+    cleanGroupbys.push(newGroupby);
+  });
+  return cleanGroupbys;
+};
+
+export { deleteInvalidGroupby, getValidGroupbys, isValidGroupby };

package/es/group/group-row.js

@@ -0,0 +1,366 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { isTableRows } from '../row/core.js';
+import { getRowsByIds } from '../table/row.js';
+import { deleteInvalidGroupby } from './core.js';
+import { DateUtils } from '../date.js';
+import { isDateColumn } from '../column/date.js';
+import { getCollaboratorsNames } from '../cell-value-get/collaborator.js';
+import { getGeolocationByGranularity } from '../cell-value-get/geolocation.js';
+import { getFormulaDisplayString } from '../cell-value-get/cell-value.js';
+import { sortCheckbox } from '../sort/sort-column/checkbox.js';
+import { sortCollaborator } from '../sort/sort-column/collaborator.js';
+import { sortDate } from '../sort/sort-column/date.js';
+import { sortNumber } from '../sort/sort-column/number.js';
+import { sortText } from '../sort/sort-column/text.js';
+import { CellType } from '../constants/cell-type.js';
+import { SINGLE_CELL_VALUE_COLUMN_TYPE_MAP, MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP, DATE_COLUMN_OPTIONS } from '../constants/column.js';
+import { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from '../constants/formula.js';
+import { sortFormula } from '../sort/sort-column/formula.js';
+import { sortLink } from '../sort/sort-column/link.js';
+import { sortMultipleSelect } from '../sort/sort-column/multiple-select.js';
+import { sortSingleSelect } from '../sort/sort-column/single-select.js';
+import { MAX_GROUP_LEVEL } from '../constants/group.js';
+import { SORT_TYPE, SORT_COLUMN_OPTIONS, TEXT_SORTER_COLUMN_TYPES, NUMBER_SORTER_COLUMN_TYPES } from '../constants/sort.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var _getCellValue = function _getCellValue(row, formulaRows, groupby) {
+  var column_key = groupby.column_key,
+    column = groupby.column;
+  var cellValue = row[column_key];
+  var type = column.type;
+  if (FORMULA_COLUMN_TYPES_MAP[type]) {
+    var formulaRow = formulaRows[row._id] || {};
+    return formulaRow[column_key];
+  }
+  // link column value is calculate as a special formula column
+  if (type === CellType.LINK) {
+    var _formulaRow = formulaRows[row._id] || {};
+    return _formulaRow[column_key] || [];
+  }
+  return cellValue;
+};
+var _getFormattedCellValue = function _getFormattedCellValue(cellValue, groupby) {
+  var column = groupby.column,
+    countType = groupby.count_type;
+  var columnType = column.type,
+    columnData = column.data;
+  switch (columnType) {
+    case CellType.TEXT:
+    case CellType.URL:
+    case CellType.EMAIL:
+    case CellType.LAST_MODIFIER:
+    case CellType.CREATOR:
+      {
+        return cellValue || null;
+      }
+    case CellType.DATE:
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        return DateUtils.getDateByGranularity(cellValue, countType) || null;
+      }
+    case CellType.NUMBER:
+    case CellType.DURATION:
+    case CellType.RATE:
+      {
+        return cellValue || cellValue === 0 ? cellValue : null;
+      }
+    case CellType.CHECKBOX:
+      {
+        return !!cellValue;
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        return cellValue || null;
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        return Array.isArray(cellValue) ? cellValue : [];
+      }
+    case CellType.COLLABORATOR:
+      {
+        if (!Array.isArray(cellValue)) {
+          return [];
+        }
+        var collaborator_email_map = groupby.collaborator_email_map;
+        return cellValue.filter(function (email) {
+          return collaborator_email_map[email];
+        });
+      }
+    case CellType.GEOLOCATION:
+      {
+        return getGeolocationByGranularity(cellValue, countType);
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        var _ref = columnData || {},
+          result_type = _ref.result_type;
+        if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+          return cellValue || cellValue === 0 ? cellValue : null;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.DATE) {
+          return DateUtils.getDateByGranularity(cellValue, countType) || null;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+          return !!cellValue;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+          var newCellValue = cellValue;
+          if (isDateColumn(column) && Array.isArray(cellValue) && cellValue.length > 0) {
+            return DateUtils.getDateByGranularity(cellValue[0], countType) || null;
+          }
+
+          // convert to string
+          return getFormulaDisplayString(newCellValue, columnData) || null;
+        }
+        return cellValue || null;
+      }
+    case CellType.LINK:
+      {
+        if (!Array.isArray(cellValue) || cellValue.length === 0) {
+          return [];
+        }
+        return cellValue.map(function (linked) {
+          return linked.display_value;
+        });
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+var _getStrCellValue = function _getStrCellValue(cellValue, columnType) {
+  var sCellValue = null;
+  if (SINGLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = typeof cellValue === 'string' ? cellValue : String(cellValue);
+  } else if (MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = _toConsumableArray(cellValue).sort().toString();
+  }
+  return sCellValue;
+};
+var _findGroupIndexWithMultipleGroupbys = function _findGroupIndexWithMultipleGroupbys(sCellValue, cellValue2GroupIndexMap, groupsLength) {
+  var target = cellValue2GroupIndexMap[sCellValue];
+  if (target && target.index > -1) {
+    return target.index;
+  }
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue] = {};
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue].subgroups = {};
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue].index = groupsLength;
+  return -1;
+};
+var _findGroupIndex = function _findGroupIndex(sCellValue, cellValue2GroupIndexMap, groupsLength) {
+  var index = cellValue2GroupIndexMap[sCellValue];
+  if (index > -1) {
+    return index;
+  }
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue] = groupsLength;
+  return -1;
+};
+var getSortedGroups = function getSortedGroups(groups, groupbys, value, level) {
+  var _groupbys$level = groupbys[level],
+    column = _groupbys$level.column,
+    sort_type = _groupbys$level.sort_type;
+  var collaborators = value.collaborators;
+  var columnType = column.type,
+    columnData = column.data;
+  var normalizedSortType = sort_type || SORT_TYPE.UP;
+  var option_id_index_map = {};
+  if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+    var _ref2 = columnData || {},
+      options = _ref2.options;
+    if (Array.isArray(options)) {
+      options.forEach(function (option, index) {
+        option_id_index_map[option.id] = index;
+      });
+    }
+  }
+  groups.sort(function (currGroupRow, nextGroupRow) {
+    var currCellVal = currGroupRow.cell_value;
+    var nextCellVal = nextGroupRow.cell_value;
+    if (SORT_COLUMN_OPTIONS.includes(columnType)) {
+      var sortResult;
+      if (TEXT_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = sortText(currCellVal, nextCellVal, normalizedSortType);
+      } else if (NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = sortNumber(currCellVal, nextCellVal, normalizedSortType);
+      } else if (DATE_COLUMN_OPTIONS.includes(columnType)) {
+        sortResult = sortDate(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === CellType.CHECKBOX) {
+        sortResult = sortCheckbox(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === CellType.COLLABORATOR) {
+        var currCollaborators = currCellVal;
+        var nextCollaborators = nextCellVal;
+        if (collaborators) {
+          currCollaborators = getCollaboratorsNames(currCollaborators, collaborators);
+          nextCollaborators = getCollaboratorsNames(nextCollaborators, collaborators);
+        }
+        sortResult = sortCollaborator(currCollaborators, nextCollaborators, normalizedSortType);
+      } else if (columnType === CellType.SINGLE_SELECT) {
+        sortResult = sortSingleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (columnType === CellType.MULTIPLE_SELECT) {
+        sortResult = sortMultipleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currOriginalCellVal = currGroupRow.original_cell_value;
+        var nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = sortFormula(currOriginalCellVal, nextOriginalCellVal, normalizedSortType, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === CellType.LINK) {
+        var _currOriginalCellVal = currGroupRow.original_cell_value;
+        var _nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = sortLink(_currOriginalCellVal, _nextOriginalCellVal, normalizedSortType, {
+          columnData: columnData,
+          value: value
+        });
+      }
+      return sortResult;
+    }
+    if (currCellVal === '') return 1;
+    if (nextCellVal === '') return -1;
+    return 0;
+  });
+
+  // for nested group.
+  var isNestedGroup = Array.isArray(groups[0].subgroups) && groups[0].subgroups.length > 0;
+  if (isNestedGroup) {
+    var nextLevel = level + 1;
+
+    // eslint-disable-next-line
+    groups = groups.map(function (group) {
+      var sortedSubgroups = getSortedGroups(group.subgroups, groupbys, value, nextLevel);
+      return _objectSpread(_objectSpread({}, group), {}, {
+        subgroups: sortedSubgroups
+      });
+    });
+  }
+  return groups;
+};
+var groupRowsWithMultipleGroupbys = function groupRowsWithMultipleGroupbys(groupbys, rows, formulaRows, value) {
+  var validGroupbys = groupbys.length > MAX_GROUP_LEVEL ? groupbys.slice(0, MAX_GROUP_LEVEL) : _toConsumableArray(groupbys);
+  var groups = [];
+  var cellValue2GroupIndexMap = {};
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var updatedGroup;
+    var updateCellValue2GroupIndexMap;
+    for (var level = 0; level < validGroupbys.length; level++) {
+      var currentGroupby = validGroupbys[level];
+      var column = currentGroupby.column,
+        column_key = currentGroupby.column_key;
+      var columnType = column.type;
+      var cellValue = _getCellValue(row, formulaRows, currentGroupby);
+      var formattedValue = _getFormattedCellValue(cellValue, currentGroupby);
+      var sCellValue = _getStrCellValue(formattedValue, columnType);
+      var group = {
+        cell_value: formattedValue,
+        original_cell_value: cellValue,
+        row_ids: null,
+        column_key: column_key,
+        subgroups: [],
+        summaries: {}
+      };
+      if (level === 0) {
+        var groupedRowIndex = _findGroupIndexWithMultipleGroupbys(sCellValue, cellValue2GroupIndexMap, groups.length);
+        updateCellValue2GroupIndexMap = cellValue2GroupIndexMap[sCellValue].subgroups;
+        if (groupedRowIndex < 0) {
+          groups.push(group);
+          updatedGroup = groups[groups.length - 1];
+        } else {
+          updatedGroup = groups[groupedRowIndex];
+        }
+      } else {
+        var _groupedRowIndex = _findGroupIndexWithMultipleGroupbys(sCellValue, updateCellValue2GroupIndexMap, updatedGroup.subgroups.length);
+        updateCellValue2GroupIndexMap = updateCellValue2GroupIndexMap[sCellValue].subgroups;
+        if (_groupedRowIndex < 0) {
+          updatedGroup.subgroups.push(group);
+          updatedGroup = updatedGroup.subgroups[updatedGroup.subgroups.length - 1];
+        } else {
+          updatedGroup = updatedGroup.subgroups[_groupedRowIndex];
+        }
+
+        // update row_ids in the deepest group.
+        if (level === validGroupbys.length - 1) {
+          if (!updatedGroup.row_ids) {
+            updatedGroup.row_ids = [rowId];
+          } else {
+            updatedGroup.row_ids.push(rowId);
+          }
+        }
+      }
+    }
+  });
+  groups = getSortedGroups(groups, validGroupbys, value, 0);
+  return groups;
+};
+var groupTableRows = function groupTableRows(groupbys, rows, formulaRows, value) {
+  if (groupbys.length === 0) {
+    return [];
+  }
+  if (groupbys.length > 1) {
+    return groupRowsWithMultipleGroupbys(groupbys, rows, formulaRows, value);
+  }
+  var groupby = groupbys[0];
+  var column_key = groupby.column_key,
+    column = groupby.column;
+  var columnType = column.type;
+  var groups = [];
+  var cellValue2GroupIndexMap = {};
+  rows.forEach(function (r) {
+    var cellValue = _getCellValue(r, formulaRows, groupby);
+    var formattedValue = _getFormattedCellValue(cellValue, groupby);
+    var sCellValue = _getStrCellValue(formattedValue, columnType);
+    var groupedRowIndex = _findGroupIndex(sCellValue, cellValue2GroupIndexMap, groups.length);
+    if (groupedRowIndex > -1) {
+      groups[groupedRowIndex].row_ids.push(r._id);
+    } else {
+      groups.push({
+        cell_value: formattedValue,
+        original_cell_value: cellValue,
+        column_key: column_key,
+        row_ids: [r._id],
+        subgroups: null,
+        summaries: {}
+      });
+    }
+  });
+
+  // sort groups
+  groups = getSortedGroups(groups, groupbys, value, 0);
+  return groups;
+};
+var groupViewRows = function groupViewRows(groupbys, table, rows, formulaRows, value) {
+  if (rows.length === 0) {
+    return [];
+  }
+  var rowsData = getRowsByIds(table, rows);
+  return groupTableRows(groupbys, rowsData, formulaRows, value);
+};
+var getGroupedRowsWithoutFormulaCalculation = function getGroupedRowsWithoutFormulaCalculation(groupbys, rows, table, value) {
+  var _ref3 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref3$formulaRows = _ref3.formulaRows,
+    formulaRows = _ref3$formulaRows === void 0 ? null : _ref3$formulaRows;
+  var columns = table.columns;
+  var validGroupbys = deleteInvalidGroupby(groupbys, columns, table, value);
+  return isTableRows(rows) ? groupTableRows(validGroupbys, rows, formulaRows, value) : groupViewRows(validGroupbys, table, rows, formulaRows, value);
+};
+
+export { getGroupedRowsWithoutFormulaCalculation, groupTableRows, groupViewRows };