dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/utils/sql-utils.js

@@ -0,0 +1,359 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSqlString = exports.getSqlOrder = exports.getSqlGroup = exports.getPieChartSqlGroupName = void 0;
+var _dtableUtils = require("dtable-utils");
+var _constants = require("../constants");
+const getSqlOrder = (sortType, groupName) => {
+  if (!sortType) {
+    return "order by ".concat(groupName);
+  }
+  return '';
+};
+exports.getSqlOrder = getSqlOrder;
+const getSqlGroup = (granularity, column) => {
+  const {
+    name,
+    type
+  } = column;
+  let columnName = "`".concat(name, "`");
+  if (_constants.TIME_COLUMN_LIST.includes(type)) {
+    if (granularity && granularity.includes(_constants.STATISTICS_COUNT_TYPE.DAY)) {
+      return "ISODATE(".concat(columnName, ")");
+    }
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.WEEK) {
+      return 'ISODATE(STARTOFWEEK(' + columnName + ', "monday"))';
+    }
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.MONTH) {
+      return "ISOMONTH(".concat(columnName, ")");
+    }
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.QUARTER) {
+      return "CONCATENATE(year(".concat(columnName, "), \"-Q\", quarter(").concat(columnName, "))");
+    }
+    return "YEAR(".concat(columnName, ")");
+  } else if (type === _dtableUtils.CellType.GEOLOCATION) {
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.PROVINCE) {
+      return "PROVINCE(".concat(columnName, ")");
+    }
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.CITY) {
+      return "CITY(".concat(columnName, ")");
+    }
+    if (granularity === _constants.STATISTICS_COUNT_TYPE.DISTRICT) {
+      return "DISTRICT(".concat(columnName, ")");
+    }
+  }
+  return "`".concat(columnName, "`");
+};
+exports.getSqlGroup = getSqlGroup;
+const getPieChartSqlGroupName = (statisticRecord, selectedColumn, groupName) => {
+  const {
+    original_name_list,
+    name_list
+  } = statisticRecord;
+  let sqlString = '';
+  const list = original_name_list.length > 0 ? original_name_list : name_list;
+  list.forEach((item, index) => {
+    if (index === 0) {
+      sqlString += getSqlGroupName(name_list[0], original_name_list[0], selectedColumn);
+    } else {
+      const sqlName = getSqlGroupName(name_list[index], original_name_list[index], selectedColumn);
+      sqlString = "".concat(sqlString, " or ").concat(groupName, "=").concat(sqlName);
+    }
+  });
+  return sqlString;
+};
+exports.getPieChartSqlGroupName = getPieChartSqlGroupName;
+const getSqlString = (statItem, statisticRecord, _ref) => {
+  let {
+    isColumn,
+    isCurrentView,
+    isRow,
+    getTableById,
+    username,
+    userId,
+    userDepartmentIdsMap
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    column_groupby_column_key,
+    column_groupby_multiple_numeric_column,
+    type
+  } = statItem;
+  const selectedTable = getTableById(table_id);
+  const selectedView = (0, _dtableUtils.getViewById)(selectedTable.views, view_id);
+  const {
+    groupName,
+    selectedColumn,
+    columnGroupName,
+    columnSelectedColumn
+  } = getDatabaseGroupName(statItem, selectedTable, {
+    isCurrentView
+  });
+  const sqlCondition = (0, _dtableUtils.filter2SqlCondition)(selectedTable, selectedView, username, userId, userDepartmentIdsMap);
+  const isGroup = column_groupby_column_key && !column_groupby_multiple_numeric_column;
+  const {
+    name,
+    original_name,
+    group_original_name,
+    group_name
+  } = statisticRecord;
+  let sqlName = getSqlGroupName(name, original_name, selectedColumn);
+  if ((type === _constants.STAT_TYPE.PIE || type === _constants.STAT_TYPE.RING) && original_name === 'Others') {
+    sqlName = getPieChartSqlGroupName(statisticRecord, selectedColumn, groupName);
+  }
+  let sqlGroupName;
+  if (isGroup) {
+    sqlGroupName = getSqlGroupName(group_name, group_original_name, columnSelectedColumn);
+  }
+  let sqlString;
+  if (_constants.STAT_TYPE.PIVOT_TABLE === type) {
+    let pivotGroupName = "".concat(isGroup ? "".concat(columnGroupName, "=").concat(sqlGroupName) : '');
+    if (isColumn) {
+      if (sqlCondition && pivotGroupName) {
+        sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " and ").concat(pivotGroupName, " limit 5000");
+      } else if (groupName && !sqlCondition) {
+        sqlString = "select * from ".concat(selectedTable.name, " where ").concat(pivotGroupName, " limit 5000");
+      } else {
+        sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " limit 5000");
+      }
+      return sqlString;
+    }
+    if (isRow) {
+      if (groupName && sqlCondition) {
+        sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " and ").concat(groupName, "=").concat(sqlName, " limit 5000");
+      } else if (groupName && !sqlCondition) {
+        sqlString = "select * from ".concat(selectedTable.name, " where ").concat(groupName, "=").concat(sqlName, " limit 5000");
+      } else {
+        sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " limit 5000");
+      }
+      return sqlString;
+    }
+  }
+  if (groupName && sqlCondition) {
+    sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " and ").concat(groupName, "=").concat(sqlName, " ").concat(isGroup ? "and ".concat(columnGroupName, "=").concat(sqlGroupName) : '', " limit 5000");
+  } else if (groupName && !sqlCondition) {
+    sqlString = "select * from ".concat(selectedTable.name, " where ").concat(groupName, "=").concat(sqlName, " ").concat(isGroup ? "and ".concat(columnGroupName, "=").concat(sqlGroupName) : '', " limit 5000");
+  } else {
+    sqlString = "select * from ".concat(selectedTable.name, " ").concat(sqlCondition, " limit 5000");
+  }
+  return sqlString;
+};
+exports.getSqlString = getSqlString;
+const getSqlGroupName = (name, original_name, column) => {
+  const {
+    type
+  } = column || {};
+  if (type === _dtableUtils.CellType.SINGLE_SELECT || type === _dtableUtils.CellType.MULTIPLE_SELECT) {
+    return "'".concat(name, "'");
+  }
+  const newName = original_name ? original_name : name;
+  if (typeof newName === 'number') {
+    return newName;
+  }
+  return "'".concat(newName, "'");
+};
+const getGroupName = (selectedColumn, _ref2) => {
+  let {
+    groupby_date_granularity,
+    groupby_geolocation_granularity
+  } = _ref2;
+  let groupName = "`".concat(selectedColumn.name, "`");
+  const isTimeColumn = _constants.TIME_COLUMN_LIST.includes(selectedColumn.type);
+  if (isTimeColumn) {
+    groupName = getSqlGroup(groupby_date_granularity, selectedColumn);
+  } else if (selectedColumn.type === _dtableUtils.CellType.GEOLOCATION) {
+    groupName = getSqlGroup(groupby_geolocation_granularity, selectedColumn);
+  }
+  return groupName;
+};
+const getDatabaseGroupName = (statItem, selectedTable, _ref3) => {
+  let {
+    isColumn = false,
+    isCurrentView = false
+  } = _ref3;
+  if (isCurrentView) return '';
+  const type = statItem.type;
+  let groupName, selectedColumn, columnGroupName, columnSelectedColumn;
+  switch (type) {
+    case _constants.STAT_TYPE.BAR:
+    case _constants.STAT_TYPE.BAR_GROUP:
+    case _constants.STAT_TYPE.BAR_STACK:
+    case _constants.STAT_TYPE.LINE:
+    case _constants.STAT_TYPE.PIE:
+    case _constants.STAT_TYPE.RING:
+    case _constants.STAT_TYPE.AREA_CHART:
+    case _constants.STAT_TYPE.AREA_GROUP_CHART:
+    case _constants.STAT_TYPE.TREEMAP:
+    case _constants.STAT_TYPE.HORIZONTAL_BAR:
+    case _constants.STAT_TYPE.HORIZONTAL_GROUP_BAR:
+    case _constants.STAT_TYPE.STACKED_HORIZONTAL_BAR:
+      {
+        let groupby_column_key, groupby_date_granularity, groupby_geolocation_granularity;
+        const {
+          column_groupby_multiple_numeric_column,
+          column_groupby_column_key,
+          column_groupby_date_granularity,
+          column_groupby_geolocation_granularity
+        } = statItem;
+        if (type === _constants.STAT_TYPE.PIE || type === _constants.STAT_TYPE.RING || type === _constants.STAT_TYPE.TREEMAP) {
+          groupby_column_key = statItem.groupby_column_key;
+          groupby_date_granularity = statItem.groupby_date_granularity;
+          groupby_geolocation_granularity = statItem.groupby_geolocation_granularity;
+        } else if (type === _constants.STAT_TYPE.HORIZONTAL_BAR || type === _constants.STAT_TYPE.HORIZONTAL_GROUP_BAR || type === _constants.STAT_TYPE.STACKED_HORIZONTAL_BAR) {
+          groupby_column_key = statItem.vertical_axis_column_key;
+          groupby_date_granularity = statItem.vertical_axis_date_granularity;
+          groupby_geolocation_granularity = statItem.vertical_axis_geolocation_granularity;
+        } else {
+          groupby_column_key = statItem.x_axis_column_key;
+          groupby_date_granularity = statItem.x_axis_date_granularity;
+          groupby_geolocation_granularity = statItem.x_axis_geolocation_granularity;
+        }
+        if (!column_groupby_multiple_numeric_column && column_groupby_column_key) {
+          columnSelectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, column_groupby_column_key);
+          columnGroupName = getGroupName(columnSelectedColumn, {
+            groupby_date_granularity: column_groupby_date_granularity,
+            groupby_geolocation_granularity: column_groupby_geolocation_granularity
+          });
+        }
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, groupby_column_key);
+        groupName = getGroupName(selectedColumn, {
+          groupby_date_granularity,
+          groupby_geolocation_granularity
+        });
+        break;
+      }
+    case _constants.STAT_TYPE.MAP:
+    case _constants.STAT_TYPE.MAP_BUBBLE:
+      {
+        const {
+          geolocation_granularity,
+          geo_column
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, geo_column);
+        groupName = getSqlGroup(geolocation_granularity, selectedColumn);
+        break;
+      }
+    case _constants.STAT_TYPE.WORLD_MAP:
+    case _constants.STAT_TYPE.WORLD_MAP_BUBBLE:
+    case _constants.STAT_TYPE.MIRROR:
+      {
+        const {
+          column
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, column);
+        groupName = selectedColumn.name;
+        break;
+      }
+    case _constants.STAT_TYPE.HEAT_MAP:
+      {
+        const {
+          time_column
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, time_column);
+        groupName = "ISODATE(".concat(selectedColumn.name, ")");
+        break;
+      }
+    case _constants.STAT_TYPE.SCATTER:
+      {
+        const {
+          group_column
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, group_column);
+        groupName = selectedColumn.name;
+        break;
+      }
+    case _constants.STAT_TYPE.BASIC_NUMBER_CARD:
+      {
+        // todo
+        break;
+      }
+    case _constants.STAT_TYPE.COMPARE_BAR:
+      {
+        const {
+          x_axis_column_key,
+          x_axis_date_granularity
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, x_axis_column_key);
+        groupName = getSqlGroup(x_axis_date_granularity, selectedColumn);
+        break;
+      }
+    case _constants.STAT_TYPE.COMBINATION_CHART:
+      {
+        const {
+          x_axis_column_key,
+          x_axis_date_granularity: groupby_date_granularity,
+          x_axis_geolocation_granularity: groupby_geolocation_granularity
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, x_axis_column_key);
+        if (!selectedColumn) return [];
+        groupName = "`".concat(selectedColumn.name, "`");
+        if (_constants.TIME_COLUMN_LIST.includes(selectedColumn.type)) {
+          groupName = getSqlGroup(groupby_date_granularity, selectedColumn);
+        } else if (selectedColumn.type === _dtableUtils.CellType.GEOLOCATION) {
+          groupName = getSqlGroup(groupby_geolocation_granularity, selectedColumn);
+        }
+        break;
+      }
+    case _constants.STAT_TYPE.TREND_CHART:
+      {
+        const {
+          date_column,
+          date_granularity
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, date_column);
+        groupName = getSqlGroup(date_granularity, selectedColumn);
+        break;
+      }
+    case _constants.STAT_TYPE.COMPLETENESS_CHART:
+    case _constants.STAT_TYPE.GROUP_COMPLETENESS_CHART:
+      {
+        const {
+          name_column
+        } = statItem;
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, name_column);
+        groupName = "`".concat(selectedColumn.name, "`");
+        break;
+      }
+    case _constants.STAT_TYPE.DASHBOARD:
+      {
+        // todo
+        break;
+      }
+    case _constants.STAT_TYPE.PIVOT_TABLE:
+      {
+        let {
+          groupby_column_key,
+          groupby_date_granularity,
+          groupby_geolocation_granularity,
+          column_groupby_column_key,
+          column_groupby_date_granularity,
+          column_groupby_geolocation_granularity,
+          column_groupby_multiple_numeric_column
+        } = statItem;
+        if (!column_groupby_multiple_numeric_column && column_groupby_column_key) {
+          columnSelectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, column_groupby_column_key);
+          columnGroupName = getGroupName(columnSelectedColumn, {
+            groupby_date_granularity: column_groupby_date_granularity,
+            groupby_geolocation_granularity: column_groupby_geolocation_granularity
+          });
+        }
+        selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, groupby_column_key);
+        groupName = getGroupName(selectedColumn, {
+          groupby_date_granularity,
+          groupby_geolocation_granularity
+        });
+        break;
+      }
+    default:
+      break;
+  }
+  return {
+    groupName,
+    selectedColumn,
+    columnGroupName,
+    columnSelectedColumn
+  };
+};

package/es/utils/stat-utils.js

@@ -0,0 +1,351 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _utils = require("../utils");
+var _collaborator = require("./collaborator");
+var _constants = require("../constants");
+const SUPPORT_SORT_COLUMNS = [_dtableUtils.CellType.TEXT, _dtableUtils.CellType.NUMBER, _dtableUtils.CellType.DATE, _dtableUtils.CellType.SINGLE_SELECT, _dtableUtils.CellType.FORMULA, _dtableUtils.CellType.LINK_FORMULA, _dtableUtils.CellType.CTIME, _dtableUtils.CellType.MTIME, _dtableUtils.CellType.RATE];
+class StatUtils {
+  static getGroupLabel(cellValue, formulaRow, column, dateGranularity, geoGranularity, value) {
+    let {
+      type,
+      key,
+      data
+    } = column;
+    switch (type) {
+      case _dtableUtils.CellType.TEXT:
+        {
+          return cellValue || null;
+        }
+      case _dtableUtils.CellType.NUMBER:
+        {
+          if (!cellValue && cellValue !== 0) {
+            return null;
+          }
+          const number = (0, _dtableUtils.getPrecisionNumber)(cellValue, data);
+          let valueNumber = parseFloat(number);
+          return (0, _dtableUtils.isNumber)(valueNumber) ? (0, _dtableUtils.getNumberDisplayString)(valueNumber, column.data) : valueNumber;
+        }
+      case _dtableUtils.CellType.SINGLE_SELECT:
+        {
+          let isInvalidValue = data && data.options.findIndex(opt => opt.id === cellValue) < 0;
+          if (isInvalidValue) {
+            return null;
+          }
+          return cellValue;
+        }
+      case _dtableUtils.CellType.DATE:
+      case _dtableUtils.CellType.CTIME:
+      case _dtableUtils.CellType.MTIME:
+        {
+          if (!dateGranularity) {
+            return (0, _dtableUtils.getDateDisplayString)(cellValue);
+          }
+          if (dateGranularity.toUpperCase() === 'QUARTER') {
+            // TODO: fix the unknown word 'QUARTAR'
+            return _dtableUtils.DateUtils.getDateByGranularity(cellValue, 'QUARTAR');
+          }
+          return _dtableUtils.DateUtils.getDateByGranularity(cellValue, dateGranularity);
+        }
+      case _dtableUtils.CellType.MULTIPLE_SELECT:
+        {
+          let options = data && data.options;
+          if (!Array.isArray(cellValue)) {
+            return [];
+          }
+          return cellValue.filter(id => options.findIndex(o => o.id === id) > -1);
+        }
+      case _dtableUtils.CellType.COLLABORATOR:
+        {
+          if (!Array.isArray(cellValue)) return [];
+          return cellValue.filter(email => (0, _collaborator.isValidCollaboratorEmail)(email));
+        }
+      case _dtableUtils.CellType.CREATOR:
+      case _dtableUtils.CellType.LAST_MODIFIER:
+        {
+          return cellValue ? cellValue : null;
+        }
+      case _dtableUtils.CellType.LINK_FORMULA:
+      case _dtableUtils.CellType.FORMULA:
+        {
+          if (!formulaRow) return '';
+          let formulaCellValue = formulaRow[key];
+          let {
+            result_type
+          } = data || {};
+          if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY) {
+            return (0, _dtableUtils.getFormulaDisplayString)(formulaCellValue, data, {
+              tables: value.tables
+            }) || null;
+          }
+          if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.NUMBER) {
+            return (0, _dtableUtils.getPrecisionNumber)(formulaCellValue, data);
+          }
+          return formulaCellValue ? formulaCellValue + '' : null;
+        }
+      case _dtableUtils.CellType.GEOLOCATION:
+        {
+          const {
+            geo_format
+          } = data || {};
+          if (geo_format === 'country_region' || geo_format === 'lng_lat' || !geoGranularity) {
+            return (0, _dtableUtils.getGeolocationDisplayString)(cellValue, data);
+          }
+          return cellValue ? cellValue[geoGranularity] : null;
+        }
+      case _dtableUtils.CellType.LINK:
+        {
+          const linkCellValue = formulaRow && formulaRow[key];
+          if (!Array.isArray(linkCellValue)) {
+            return [];
+          }
+          return linkCellValue.map(linkVal => linkVal.display_value);
+        }
+      case _dtableUtils.CellType.CHECKBOX:
+        {
+          return String(!!cellValue);
+        }
+      case _dtableUtils.CellType.RATE:
+        {
+          if (!cellValue) return null;
+          return cellValue + '';
+        }
+      default:
+        {
+          return null;
+        }
+    }
+  }
+  static sortStatistics(statistics, column, sort_key) {
+    let {
+      type: column_type,
+      data
+    } = column;
+    let sortType = 'up';
+    let option_id_index_map = {};
+    if (column_type === _dtableUtils.CellType.SINGLE_SELECT) {
+      const {
+        options
+      } = data || {};
+      Array.isArray(options) && options.forEach((option, index) => {
+        option_id_index_map[option.id] = index;
+      });
+    }
+    statistics.sort((currResult, nextResult) => {
+      let {
+        [sort_key]: current
+      } = currResult;
+      let {
+        [sort_key]: next
+      } = nextResult;
+      if (!current && current !== 0) {
+        return -1;
+      }
+      if (!next && next !== 0) {
+        return 1;
+      }
+      if (SUPPORT_SORT_COLUMNS.includes(column_type)) {
+        switch (column_type) {
+          case _dtableUtils.CellType.NUMBER:
+            {
+              if (current) {
+                current = current - 0;
+              }
+              if (next) {
+                next = next - 0;
+              }
+              return (0, _dtableUtils.sortNumber)(current, next, sortType);
+            }
+          case _dtableUtils.CellType.DATE:
+          case _dtableUtils.CellType.CTIME:
+          case _dtableUtils.CellType.MTIME:
+            {
+              return (0, _dtableUtils.sortDate)(current, next, sortType);
+            }
+          case _dtableUtils.CellType.SINGLE_SELECT:
+          case _dtableUtils.CellType.MULTIPLE_SELECT:
+            {
+              return (0, _dtableUtils.sortSingleSelect)(current, next, {
+                sort_type: sortType,
+                option_id_index_map
+              });
+            }
+          case _dtableUtils.CellType.FORMULA:
+          case _dtableUtils.CellType.LINK_FORMULA:
+            {
+              let {
+                result_type
+              } = data || {};
+              if (result_type === _dtableUtils.FORMULA_RESULT_TYPE.NUMBER) {
+                if (current) {
+                  current = current - 0;
+                }
+                if (next) {
+                  next = next - 0;
+                }
+                return (0, _dtableUtils.sortNumber)(current, next, sortType);
+              }
+              return (0, _dtableUtils.sortText)(current, next, sortType);
+            }
+          default:
+            {
+              return (0, _dtableUtils.sortText)(current, next, sortType);
+            }
+        }
+      }
+      return 0;
+    });
+  }
+  static sortDataByKey(data, key, sortType) {
+    data.sort((curr, next) => {
+      const currentVal = curr[key];
+      const nextVal = next[key];
+      if (!currentVal && currentVal !== 0) {
+        return -1;
+      }
+      if (!nextVal && nextVal !== 0) {
+        return 1;
+      }
+      if (sortType === _constants.DATA_SORT_TYPE.ASCENDING) {
+        return currentVal > nextVal ? 1 : -1;
+      } else {
+        return currentVal > nextVal ? -1 : 1;
+      }
+    });
+  }
+  static sortStatisticData(statistics, sort_type) {
+    this.sortDataByKey(statistics, 'value', sort_type);
+  }
+  static getTotal(summary_column_key, summary_column_type, summary_type, summary_method) {
+    let rows = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+    let formula_rows = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+    let rowsLength = rows.length;
+    let total;
+    if (summary_type === _constants.STATISTICS_COUNT_TYPE.COUNT) {
+      total = rowsLength;
+    } else if (summary_type === _constants.STATISTICS_COUNT_TYPE.ADVANCED) {
+      switch (summary_method) {
+        case 'Distinct_values':
+          {
+            let count = 0;
+            let existMap = {};
+            rows.forEach(r => {
+              let num;
+              if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                const formulaRow = formula_rows[r._id] || {};
+                num = formulaRow[summary_column_key];
+                num = Array.isArray(num) ? num[0] : num;
+              } else {
+                num = r[summary_column_key];
+              }
+              if (!num) {
+                if (num === 0) {
+                  num = '0';
+                } else {
+                  num = !!num;
+                }
+              }
+              if (!existMap[num]) {
+                existMap[num] = true;
+                count++;
+              }
+            });
+            total = count;
+            break;
+          }
+        case 'Sum':
+        case 'Mean':
+          {
+            let sum = 0;
+            let validNumbersCount = 0;
+            rows.forEach(r => {
+              let num;
+              if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                let formulaRow = formula_rows[r._id] || {};
+                num = formulaRow[summary_column_key];
+                num = Array.isArray(num) ? num[0] : num;
+              } else {
+                num = r[summary_column_key];
+              }
+              if ((0, _dtableUtils.isNumber)(num)) {
+                validNumbersCount++;
+                sum += num;
+              }
+            });
+            if (summary_method === 'Sum') {
+              total = Number.parseFloat(sum.toFixed(8));
+            } else if (summary_method === 'Mean') {
+              total = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+            }
+            break;
+          }
+        case 'Max':
+        case 'Min':
+          {
+            if (rowsLength > 0) {
+              let result = rows.reduce((current, next) => {
+                let currentValue, nextValue;
+                if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                  let currentFormulaRow = formula_rows[current._id];
+                  let nextFormulaRow = formula_rows[next._id];
+                  currentValue = currentFormulaRow && currentFormulaRow[summary_column_key];
+                  nextValue = nextFormulaRow && nextFormulaRow[summary_column_key];
+                  currentValue = Array.isArray(currentValue) ? currentValue[0] : currentValue;
+                  nextValue = Array.isArray(nextValue) ? nextValue[0] : nextValue;
+                } else {
+                  currentValue = current[summary_column_key];
+                  nextValue = next[summary_column_key];
+                }
+                if (!nextValue && nextValue !== 0) {
+                  return current;
+                }
+                let isNextGreater = currentValue < nextValue;
+                if (summary_method === 'Min') {
+                  return isNextGreater ? current : next;
+                } else {
+                  return isNextGreater ? next : current;
+                }
+              });
+              if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                let formulaRow = formula_rows[result._id];
+                total = formulaRow && formulaRow[summary_column_key];
+                total = Array.isArray(total) ? total[0] : total;
+              } else {
+                total = result[summary_column_key];
+              }
+            }
+            break;
+          }
+        default:
+          {
+            break;
+          }
+      }
+    }
+    return total || 0;
+  }
+  static getFormattedValue(value, column, summaryMethod) {
+    if (!column) {
+      return value;
+    }
+    if (summaryMethod === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+      return value;
+    }
+    const {
+      type,
+      data
+    } = column;
+    if ((0, _dtableUtils.isNumericColumn)(column)) {
+      return (0, _dtableUtils.getNumberDisplayString)(value, data);
+    }
+    if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[type]) {
+      return (0, _utils.getClientFormulaDisplayString)(value, data);
+    }
+    return value;
+  }
+}
+var _default = exports.default = StatUtils;