dtable-utils 0.0.1 → 0.0.3-beta.1

package/lib/group/core.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var date = require('../column/date.js');
+var core$1 = require('../link/core.js');
+var column = require('../table/column.js');
+var core = require('../table/core.js');
+var cellType = require('../constants/cell-type.js');
+var group = require('../constants/group.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+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__default["default"](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 group.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.CellType.DATE:
+      case cellType.CellType.CTIME:
+      case cellType.CellType.MTIME:
+        {
+          newGroupby.count_type = count_type || group.GROUP_DATE_GRANULARITY.MONTH;
+          break;
+        }
+      case cellType.CellType.GEOLOCATION:
+        {
+          newGroupby.count_type = count_type || group.GROUP_GEOLOCATION_GRANULARITY.PROVINCE;
+          break;
+        }
+      case cellType.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.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 = core$1.getLinkedTableID(currentTableId, table_id, other_table_id);
+          var linkedTable = core.getTableById(value.tables, linkedTableID);
+          var displayColumn = column.getTableColumnByKey(linkedTable, display_column_key);
+          newGroupby.linked_table = linkedTable;
+          newGroupby.display_column = displayColumn;
+          break;
+        }
+      case cellType.CellType.FORMULA:
+      case cellType.CellType.LINK_FORMULA:
+        {
+          if (date.isDateColumn(groupbyColumn) && !count_type) {
+            newGroupby.count_type = group.GROUP_DATE_GRANULARITY.MONTH;
+          }
+          break;
+        }
+    }
+    cleanGroupbys.push(newGroupby);
+  });
+  return cleanGroupbys;
+};
+
+exports.deleteInvalidGroupby = deleteInvalidGroupby;
+exports.getValidGroupbys = getValidGroupbys;
+exports.isValidGroupby = isValidGroupby;

package/lib/group/group-row.js

@@ -0,0 +1,377 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var core$1 = require('../row/core.js');
+var row = require('../table/row.js');
+var core = require('./core.js');
+var date = require('../date.js');
+var date$1 = require('../column/date.js');
+var collaborator = require('../cell-value-get/collaborator.js');
+var geolocation = require('../cell-value-get/geolocation.js');
+var cellValue = require('../cell-value-get/cell-value.js');
+var checkbox = require('../sort/sort-column/checkbox.js');
+var collaborator$1 = require('../sort/sort-column/collaborator.js');
+var date$2 = require('../sort/sort-column/date.js');
+var number = require('../sort/sort-column/number.js');
+var text = require('../sort/sort-column/text.js');
+var cellType = require('../constants/cell-type.js');
+var column = require('../constants/column.js');
+var formula = require('../constants/formula.js');
+var formula$1 = require('../sort/sort-column/formula.js');
+var link = require('../sort/sort-column/link.js');
+var multipleSelect = require('../sort/sort-column/multiple-select.js');
+var singleSelect = require('../sort/sort-column/single-select.js');
+var group = require('../constants/group.js');
+var sort = require('../constants/sort.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
+
+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__default["default"](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.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.CellType.LINK) {
+    var _formulaRow = formulaRows[row._id] || {};
+    return _formulaRow[column_key] || [];
+  }
+  return cellValue;
+};
+var _getFormattedCellValue = function _getFormattedCellValue(cellValue$1, groupby) {
+  var column = groupby.column,
+    countType = groupby.count_type;
+  var columnType = column.type,
+    columnData = column.data;
+  switch (columnType) {
+    case cellType.CellType.TEXT:
+    case cellType.CellType.URL:
+    case cellType.CellType.EMAIL:
+    case cellType.CellType.LAST_MODIFIER:
+    case cellType.CellType.CREATOR:
+      {
+        return cellValue$1 || null;
+      }
+    case cellType.CellType.DATE:
+    case cellType.CellType.CTIME:
+    case cellType.CellType.MTIME:
+      {
+        return date.DateUtils.getDateByGranularity(cellValue$1, countType) || null;
+      }
+    case cellType.CellType.NUMBER:
+    case cellType.CellType.DURATION:
+    case cellType.CellType.RATE:
+      {
+        return cellValue$1 || cellValue$1 === 0 ? cellValue$1 : null;
+      }
+    case cellType.CellType.CHECKBOX:
+      {
+        return !!cellValue$1;
+      }
+    case cellType.CellType.SINGLE_SELECT:
+      {
+        return cellValue$1 || null;
+      }
+    case cellType.CellType.MULTIPLE_SELECT:
+      {
+        return Array.isArray(cellValue$1) ? cellValue$1 : [];
+      }
+    case cellType.CellType.COLLABORATOR:
+      {
+        if (!Array.isArray(cellValue$1)) {
+          return [];
+        }
+        var collaborator_email_map = groupby.collaborator_email_map;
+        return cellValue$1.filter(function (email) {
+          return collaborator_email_map[email];
+        });
+      }
+    case cellType.CellType.GEOLOCATION:
+      {
+        return geolocation.getGeolocationByGranularity(cellValue$1, countType);
+      }
+    case cellType.CellType.FORMULA:
+    case cellType.CellType.LINK_FORMULA:
+      {
+        var _ref = columnData || {},
+          result_type = _ref.result_type;
+        if (result_type === formula.FORMULA_RESULT_TYPE.NUMBER) {
+          return cellValue$1 || cellValue$1 === 0 ? cellValue$1 : null;
+        }
+        if (result_type === formula.FORMULA_RESULT_TYPE.DATE) {
+          return date.DateUtils.getDateByGranularity(cellValue$1, countType) || null;
+        }
+        if (result_type === formula.FORMULA_RESULT_TYPE.BOOL) {
+          return !!cellValue$1;
+        }
+        if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+          var newCellValue = cellValue$1;
+          if (date$1.isDateColumn(column) && Array.isArray(cellValue$1) && cellValue$1.length > 0) {
+            return date.DateUtils.getDateByGranularity(cellValue$1[0], countType) || null;
+          }
+
+          // convert to string
+          return cellValue.getFormulaDisplayString(newCellValue, columnData) || null;
+        }
+        return cellValue$1 || null;
+      }
+    case cellType.CellType.LINK:
+      {
+        if (!Array.isArray(cellValue$1) || cellValue$1.length === 0) {
+          return [];
+        }
+        return cellValue$1.map(function (linked) {
+          return linked.display_value;
+        });
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+var _getStrCellValue = function _getStrCellValue(cellValue, columnType) {
+  var sCellValue = null;
+  if (column.SINGLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = typeof cellValue === 'string' ? cellValue : String(cellValue);
+  } else if (column.MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = _toConsumableArray__default["default"](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$1 = _groupbys$level.column,
+    sort_type = _groupbys$level.sort_type;
+  var collaborators = value.collaborators;
+  var columnType = column$1.type,
+    columnData = column$1.data;
+  var normalizedSortType = sort_type || sort.SORT_TYPE.UP;
+  var option_id_index_map = {};
+  if (columnType === cellType.CellType.SINGLE_SELECT || columnType === cellType.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.SORT_COLUMN_OPTIONS.includes(columnType)) {
+      var sortResult;
+      if (sort.TEXT_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = text.sortText(currCellVal, nextCellVal, normalizedSortType);
+      } else if (sort.NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = number.sortNumber(currCellVal, nextCellVal, normalizedSortType);
+      } else if (column.DATE_COLUMN_OPTIONS.includes(columnType)) {
+        sortResult = date$2.sortDate(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === cellType.CellType.CHECKBOX) {
+        sortResult = checkbox.sortCheckbox(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === cellType.CellType.COLLABORATOR) {
+        var currCollaborators = currCellVal;
+        var nextCollaborators = nextCellVal;
+        if (collaborators) {
+          currCollaborators = collaborator.getCollaboratorsNames(currCollaborators, collaborators);
+          nextCollaborators = collaborator.getCollaboratorsNames(nextCollaborators, collaborators);
+        }
+        sortResult = collaborator$1.sortCollaborator(currCollaborators, nextCollaborators, normalizedSortType);
+      } else if (columnType === cellType.CellType.SINGLE_SELECT) {
+        sortResult = singleSelect.sortSingleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (columnType === cellType.CellType.MULTIPLE_SELECT) {
+        sortResult = multipleSelect.sortMultipleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (formula.FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currOriginalCellVal = currGroupRow.original_cell_value;
+        var nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = formula$1.sortFormula(currOriginalCellVal, nextOriginalCellVal, normalizedSortType, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === cellType.CellType.LINK) {
+        var _currOriginalCellVal = currGroupRow.original_cell_value;
+        var _nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = link.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 > group.MAX_GROUP_LEVEL ? groupbys.slice(0, group.MAX_GROUP_LEVEL) : _toConsumableArray__default["default"](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 = row.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 = core.deleteInvalidGroupby(groupbys, columns, table, value);
+  return core$1.isTableRows(rows) ? groupTableRows(validGroupbys, rows, formulaRows, value) : groupViewRows(validGroupbys, table, rows, formulaRows, value);
+};
+
+exports.getGroupedRowsWithoutFormulaCalculation = getGroupedRowsWithoutFormulaCalculation;
+exports.groupTableRows = groupTableRows;
+exports.groupViewRows = groupViewRows;