dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/calculator/compare-bar-calculator.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _sqlUtils = require("../utils/sql-utils");
+var _statUtils = _interopRequireDefault(require("../utils/stat-utils"));
+var _commonUtils = require("../utils/common-utils");
+var _constants = require("../constants");
+class CompareBarCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      x_axis_column_key,
+      summary_column_key,
+      y_axis_column_key,
+      x_axis_date_range_start,
+      x_axis_date_range_end,
+      x_axis_compared_date_range_start,
+      x_axis_compared_date_range_end
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, x_axis_column_key)) return false;
+    const summaryColumnKey = summary_column_key || y_axis_column_key;
+    if (summaryColumnKey && !(0, _dtableUtils.getTableColumnByKey)(table, summaryColumnKey)) return false;
+    if (!x_axis_date_range_start || !x_axis_date_range_end || !x_axis_compared_date_range_start || !x_axis_compared_date_range_end) {
+      return false;
+    }
+    if (x_axis_date_range_start > x_axis_date_range_end || x_axis_compared_date_range_start > x_axis_compared_date_range_end) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return [];
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      x_axis_column_key,
+      x_axis_date_granularity,
+      y_axis_summary_type,
+      y_axis_summary_method,
+      y_axis_column_key,
+      x_axis_date_range_start,
+      x_axis_date_range_end,
+      x_axis_compared_date_range_start,
+      x_axis_compared_date_range_end,
+      display_increase
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, x_axis_column_key);
+    const isAdvanced = y_axis_summary_type === _constants.SUMMARY_TYPE.ADVANCED;
+    const method = isAdvanced ? _constants.DTABLE_DB_SUMMARY_METHOD[y_axis_summary_method] : _constants.DTABLE_DB_SUMMARY_METHOD.Count;
+    let sqlString = '';
+    let groupName = (0, _sqlUtils.getSqlGroup)('day', selectedColumn);
+    const sqlOrder = (0, _sqlUtils.getSqlOrder)(null, groupName);
+    let summaryColumnName = "".concat(selectedColumn.name);
+    let selectedSummaryColumn = {};
+    if (isAdvanced) {
+      selectedSummaryColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, y_axis_column_key);
+      if (!selectedSummaryColumn) return [];
+      summaryColumnName = "".concat(selectedSummaryColumn.name);
+    }
+    const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(method, summaryColumnName);
+    let sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    sqlCondition = this.getStatItemSqlCondition(chart, sqlCondition, "`".concat(selectedColumn.name, "`"));
+    sqlString = "select ".concat(groupName, ", ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, " ").concat(sqlOrder, " limit 5000");
+    const result = await this.sqlQuery(sqlString);
+    const groupName1 = "".concat(x_axis_date_range_start, " - ").concat(x_axis_date_range_end);
+    const groupName2 = "".concat(x_axis_compared_date_range_start, " - ").concat(x_axis_compared_date_range_end);
+    if (result.status === 200 && result.data.success) {
+      const dateRangeResult = new Map();
+      let dateComparedResult = new Map();
+      const valueKey = isAdvanced ? "".concat(method, "(").concat(summaryColumnName, ")") : "".concat(method, "(").concat(selectedColumn.name, ")");
+      result.data.results.forEach(item => {
+        const name = item[groupName];
+        const label = _statUtils.default.getGroupLabel(name, item, selectedColumn, x_axis_date_granularity, '', this.value);
+        const value = item[valueKey];
+        if (name >= x_axis_date_range_start && name <= x_axis_date_range_end) {
+          const currentValue = dateRangeResult.get(label);
+          if (!currentValue) {
+            if (isAdvanced) {
+              dateRangeResult.set(label, [value]);
+            } else {
+              dateRangeResult.set(label, value);
+            }
+          } else {
+            if (isAdvanced) {
+              currentValue.push(value);
+            } else {
+              dateRangeResult.set(label, value + currentValue);
+            }
+          }
+        } else if (name >= x_axis_compared_date_range_start && name <= x_axis_compared_date_range_end) {
+          const currentValue = dateComparedResult.get(label);
+          if (!currentValue) {
+            if (isAdvanced) {
+              dateComparedResult.set(label, [value]);
+            } else {
+              dateComparedResult.set(label, value);
+            }
+          } else {
+            if (isAdvanced) {
+              dateComparedResult.push(value);
+            } else {
+              dateComparedResult.set(label, value + currentValue);
+            }
+          }
+        }
+      });
+      let comparedResult = [];
+      let rangeResult = [];
+      const data = selectedSummaryColumn.data || {};
+
+      // eslint-disable-next-line
+      for (let item of dateRangeResult) {
+        let value = item[1];
+        let formatted_value = value;
+        if (isAdvanced) {
+          value = (0, _commonUtils.getSummaryResult)(item[1], y_axis_summary_method, data.precision);
+          formatted_value = _statUtils.default.getFormattedValue(value, selectedSummaryColumn, y_axis_summary_method);
+        }
+        rangeResult.push({
+          name: item[0],
+          group_name: groupName1,
+          raw_name: item[0],
+          value,
+          formatted_value
+        });
+      }
+      let index = 0;
+      // eslint-disable-next-line
+      for (let item of dateComparedResult) {
+        let dateRangeItem = rangeResult[index];
+        if (!dateRangeItem) {
+          break;
+        }
+        let value = item[1];
+        let formatted_value = value;
+        if (isAdvanced) {
+          value = (0, _commonUtils.getSummaryResult)(item[1], y_axis_summary_method, data.precision);
+          formatted_value = _statUtils.default.getFormattedValue(value, selectedSummaryColumn, y_axis_summary_method);
+        }
+        const newItem = {
+          name: dateRangeItem.name,
+          group_name: groupName2,
+          raw_name: item[0],
+          value,
+          formatted_value
+        };
+        if (display_increase) {
+          const value1 = dateRangeItem.value;
+          let increaseValue = Number(((value1 - value) / value).toFixed(2));
+          if (!value) {
+            increaseValue = 1;
+          }
+          newItem.increase_value = increaseValue;
+        }
+        comparedResult.push(newItem);
+        index++;
+      }
+      if (comparedResult.length > rangeResult.length) {
+        comparedResult = comparedResult.slice(0, rangeResult.length);
+      }
+      return [...comparedResult, ...rangeResult];
+    }
+    return [];
+  }
+  getStatItemSqlCondition(chart, sqlCondition, name) {
+    const {
+      x_axis_date_range_start,
+      x_axis_date_range_end,
+      x_axis_compared_date_range_start,
+      x_axis_compared_date_range_end
+    } = chart;
+    const newSqlCondition = sqlCondition.length === 0 ? 'where ' : sqlCondition + ' AND';
+    const formattedXAxisDateRangeEnd = (0, _dayjs.default)(x_axis_date_range_end).add(1, 'days').format('YYYY-MM-DD');
+    const formattedXAxisComparedDateRangeEnd = (0, _dayjs.default)(x_axis_compared_date_range_end).add(1, 'days').format('YYYY-MM-DD');
+    return newSqlCondition + " ((".concat(name, " >= '").concat(x_axis_date_range_start, "' AND ").concat(name, " < '").concat(formattedXAxisDateRangeEnd, "') Or (").concat(name, " >= '").concat(x_axis_compared_date_range_start, "' AND ").concat(name, " < '").concat(formattedXAxisComparedDateRangeEnd, "'))");
+  }
+}
+var _default = exports.default = CompareBarCalculator;

package/es/calculator/completeness-calculator.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _sqlUtils = require("../utils/sql-utils");
+var _constants = require("../constants");
+var _commonUtils = require("../utils/common-utils");
+var _statUtils = _interopRequireDefault(require("../utils/stat-utils"));
+var _rowUtils = require("../utils/row-utils");
+class CompletenessCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      type,
+      table_id,
+      name_column,
+      completed_column,
+      target_column,
+      group_column
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, name_column)) {
+      return false;
+    }
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, completed_column)) {
+      return false;
+    }
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, target_column)) {
+      return false;
+    }
+    if (type === _constants.STAT_TYPE.GROUP_COMPLETENESS_CHART && (!group_column || !(0, _dtableUtils.getTableColumnByKey)(table, group_column))) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return [];
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      name_column,
+      completed_column,
+      target_column,
+      group_column,
+      date_granularity
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    if (!selectedView) {
+      return [];
+    }
+    const selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, name_column);
+    const groupName = "`".concat(selectedColumn.name, "`");
+    const sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    const completedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, completed_column);
+    const targetColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, target_column);
+    const groupColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, group_column);
+    const sqlOrder = (0, _sqlUtils.getSqlOrder)(null, groupName);
+    const isColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(selectedColumn);
+    const memo = new Map();
+    const resultList = [];
+    if (!groupColumn) {
+      const completedColumnName = "`".concat(completedColumn.name, "`"),
+        targetColumnName = "`".concat(targetColumn.name, "`");
+      const sqlString = "select ".concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, " ").concat(sqlOrder, " desc limit 5000");
+      const result = await this.sqlQuery(sqlString);
+      if (!result.status === 200 || !result.data.success) return [];
+      const data = result.data;
+      if (!data.results) return [];
+      data.results.forEach(item => {
+        const name = item[selectedColumn.key];
+        let label;
+        if (name || Number.isFinite(name)) {
+          label = _statUtils.default.getGroupLabel(name, item, selectedColumn, '', '', this.value);
+          if (isColumnDataAsAnArray) {
+            label = label[0];
+          }
+          label = (0, _rowUtils.getFormattedLabel)(selectedColumn, label, this.value.collaborators);
+          if (!memo.get(label)) {
+            const completedValue = item[completedColumn.key] || 0;
+            const targetValue = item[targetColumn.key] || 0;
+            if (completedValue >= targetValue) {
+              resultList.push({
+                name: label,
+                original_name: name,
+                value: completedValue,
+                type: 'completed',
+                current_value: completedValue,
+                target_value: targetValue
+              });
+            } else {
+              resultList.push({
+                name: label,
+                original_name: name,
+                value: completedValue,
+                type: 'completed',
+                current_value: completedValue,
+                target_value: targetValue
+              }, {
+                name: label,
+                original_name: name,
+                value: targetValue - completedValue,
+                type: 'uncompleted',
+                current_value: completedValue,
+                target_value: targetValue
+              });
+            }
+            memo.set(label, 1);
+          }
+        }
+      });
+    } else {
+      const isTimeGroupColumn = _constants.TIME_COLUMN_LIST.includes(groupColumn.type);
+      const isGroupColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupColumn);
+      const completedColumnName = "`".concat(completedColumn.name, "`");
+      const targetColumnName = "`".concat(targetColumn.name, "`");
+      let groupColumnName = "`".concat(groupColumn.name, "`");
+      if (isTimeGroupColumn) {
+        groupColumnName = (0, _sqlUtils.getSqlGroup)(date_granularity, groupColumn);
+      }
+      const sqlString = "select ".concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, ", ").concat(groupColumnName, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, ", ").concat(groupColumnName, " ").concat(sqlOrder, " desc limit 5000");
+      const result = await this.sqlQuery(sqlString);
+      let colorMap = {};
+      if (!result.status === 200 || !result.data.success) return [];
+      const data = result.data;
+      if (!data.results) return [];
+      let colorIndex = 0;
+      data.results.forEach(item => {
+        const name = item[selectedColumn.key];
+        let label;
+        let groupLabel;
+
+        // get and format name
+        if (name || Number.isFinite(name)) {
+          label = _statUtils.default.getGroupLabel(name, item, selectedColumn, '', '', this.value);
+          if (isColumnDataAsAnArray) {
+            label = label[0];
+          }
+          label = (0, _rowUtils.getFormattedLabel)(selectedColumn, label, this.value.collaborators);
+        }
+
+        // get and format group name
+        if (!isTimeGroupColumn) {
+          groupLabel = item[groupColumn.key];
+          groupLabel = _statUtils.default.getGroupLabel(groupLabel, item, groupColumn, '', '', this.value);
+          if (groupLabel && isGroupColumnDataAsAnArray) {
+            groupLabel = groupLabel[0];
+          }
+          groupLabel = (0, _rowUtils.getFormattedLabel)(groupColumn, groupLabel, this.value.collaborators);
+        } else {
+          groupLabel = item[groupColumnName] + '';
+        }
+
+        // get group color
+        let color = colorMap[groupLabel];
+        if (!color) {
+          color = _constants.PIE_CHART_COLORS[colorIndex % 12];
+          colorMap[groupLabel] = color;
+          colorIndex++;
+        }
+        const cache = memo.get(label);
+        if (!cache || !cache[groupLabel]) {
+          const completedValue = item[completedColumn.key] || 0;
+          const targetValue = item[targetColumn.key] || 0;
+          if (label && groupLabel) {
+            resultList.push({
+              name: label,
+              original_name: name,
+              group_label: groupLabel,
+              value: completedValue,
+              type: 'completed',
+              current_value: completedValue,
+              target_value: targetValue
+            });
+            if (completedValue < targetValue) {
+              resultList.push({
+                name: label,
+                original_name: name,
+                group_label: groupLabel,
+                value: targetValue - completedValue,
+                type: 'uncompleted',
+                current_value: completedValue,
+                target_value: targetValue
+              });
+            }
+            if (cache) {
+              cache[groupLabel] = 1;
+              memo.set(label, cache);
+            } else {
+              memo.set(label, {
+                [groupLabel]: 1
+              });
+            }
+          }
+        }
+      });
+      resultList.colorMap = colorMap;
+    }
+    return resultList;
+  }
+}
+var _default = exports.default = CompletenessCalculator;

package/es/calculator/copy-value.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const IGNORE_KEYS = ['description', 'format_version', 'plugin_settings', 'plugins', 'statistics', 'version', 'scripts', 'settings'];
+const TABLE_IGNORE_KEYS = ['summary_configs', 'is_header_locked'];
+const copyValue = value => {
+  const newValue = {};
+  Object.keys(value).forEach(key => {
+    if (key !== 'tables' && !IGNORE_KEYS.includes(key)) {
+      newValue[key] = value[key];
+    }
+  });
+  const tables = value.tables;
+  const newTables = [];
+  tables.forEach(table => {
+    const newTable = {};
+    Object.keys(table).forEach(key => {
+      if (key === 'columns') {
+        const columns = table.columns;
+        const newColumns = [];
+        columns.forEach(column => {
+          const newColumn = Object.assign({}, column, {
+            editor: null,
+            formatter: null
+          });
+          newColumns.push(newColumn);
+        });
+        newTable.columns = newColumns;
+      } else if (key === 'views') {
+        const views = table['views'];
+        const newViews = [];
+        views.forEach(view => {
+          const newView = Object.assign({}, view, {
+            colorbys: null,
+            archived_columns: null,
+            archived_rows: null
+          });
+          newViews.push(newView);
+        });
+        newTable[key] = newViews;
+      } else if (!TABLE_IGNORE_KEYS.includes(key)) {
+        newTable[key] = table[key];
+      }
+    });
+    newTables.push(newTable);
+  });
+  newValue.tables = newTables;
+  return newValue;
+};
+var _default = exports.default = copyValue;

package/es/calculator/dashboard-calculator.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _constants = require("../constants");
+var _commonUtils = require("../utils/common-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+class DashboardCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      target_value_column,
+      total_value_column
+    } = chart;
+    const table = this.getTableById(table_id);
+    const selectedColumn1 = (0, _dtableUtils.getTableColumnByKey)(table, target_value_column);
+    const selectedColumn2 = (0, _dtableUtils.getTableColumnByKey)(table, total_value_column);
+    if (!selectedColumn1 || !selectedColumn2) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return 0;
+    if (this.isCalcByQueryDB(chart)) {
+      return await this.queryDb(chart);
+    }
+    return await this.calculateWithWorker(chart);
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      target_value_column,
+      target_value_column_summary_method,
+      total_value_column,
+      total_value_column_summary_method
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const selectedColumn1 = (0, _dtableUtils.getTableColumnByKey)(selectedTable, target_value_column);
+    const selectedColumn2 = (0, _dtableUtils.getTableColumnByKey)(selectedTable, total_value_column);
+    const sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    const key1 = (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[target_value_column_summary_method], selectedColumn1.name);
+    const key2 = (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[total_value_column_summary_method], selectedColumn2.name);
+    const sqlString = "select ".concat(key1, ", ").concat(key2, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " limit 5000");
+    const result = await this.sqlQuery(sqlString);
+    if (result.status === 200 && result.data.success) {
+      const data = result.data.results;
+      if (!data) return 0;
+      if (data.length > 0) {
+        const result1 = data[0][key1];
+        const result2 = data[0][key2];
+        if (result2 === 0) {
+          return 0;
+        }
+        return result1 / result2;
+      }
+    }
+    return 0;
+  }
+}
+var _default = exports.default = DashboardCalculator;

package/es/calculator/heat-map-calculator.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _dtableUtils = require("dtable-utils");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _commonUtils = require("../utils/common-utils");
+var _constants = require("../constants");
+class HeatMapCalculator extends _baseCalculator.default {
+  isValidChart(chart) {
+    if (!this.validateBaseConfigs(chart)) {
+      return false;
+    }
+    const {
+      table_id,
+      time_column,
+      summary_column
+    } = chart;
+    const table = this.getTableById(table_id);
+    if (!(0, _dtableUtils.getTableColumnByKey)(table, time_column)) {
+      return false;
+    }
+    if (summary_column && !(0, _dtableUtils.getTableColumnByKey)(table, summary_column)) {
+      return false;
+    }
+    return true;
+  }
+  async calculate(chart) {
+    if (!this.isValidChart(chart)) return {
+      data: [],
+      years: []
+    };
+    const result = this.isCalcByQueryDB(chart) ? await this.queryDb(chart) : await this.calculateWithWorker(this.convertChart(chart));
+    let data = [];
+    let years = [];
+    result.forEach(item => {
+      if (!item.name) {
+        data.push(item);
+        return;
+      }
+      const year = (0, _dayjs.default)(item.name).year();
+      data.push({
+        ...item,
+        year
+      });
+      if (years.indexOf(year) < 0) {
+        years.push(year);
+      }
+    });
+    this.sortDataByYear(data);
+    return {
+      data,
+      years
+    };
+  }
+  async queryDb(chart) {
+    const {
+      table_id,
+      view_id,
+      time_column,
+      summary_type,
+      summary_method,
+      summary_column
+    } = chart;
+    const selectedTable = this.getTableById(table_id);
+    const selectedView = this.getViewById(view_id, selectedTable);
+    const selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, time_column);
+    const columnName = selectedColumn.name;
+    const isAdvanced = summary_type === 'advanced';
+    const method = isAdvanced ? _constants.DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
+    const sqlCondition = this.filter2SqlCondition(selectedTable, selectedView);
+    let summaryColumnName = '';
+    let summaryColumn;
+    let sqlString = '';
+    if (isAdvanced) {
+      summaryColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, summary_column);
+      if (!summaryColumn) {
+        return [];
+      }
+      summaryColumnName = summaryColumn.name;
+      const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(method, summaryColumnName);
+      sqlString = "select `".concat(columnName, "`, ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "` limit 5000");
+    } else {
+      sqlString = "select `".concat(columnName, "`, ").concat(method, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "` limit 5000");
+    }
+    const result = await this.sqlQuery(sqlString);
+    if (result.status === 200 && result.data.success) {
+      const data = result.data;
+      if (!data.results) return [];
+      const newResult = [];
+      const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(method, summaryColumnName);
+      const valueKey = isAdvanced ? "".concat(summaryColumnMethod) : "".concat(method, "(").concat(columnName, ")");
+      data.results.forEach(item => {
+        const currentValue = item[time_column];
+        if (currentValue) {
+          let value = item[valueKey];
+          if (isAdvanced) {
+            value = (0, _commonUtils.formatNumericValue)(value, summaryColumn);
+          }
+          const name = typeof currentValue === 'string' ? currentValue : currentValue.country_region;
+          newResult.push({
+            name: (0, _dayjs.default)(name).format('YYYY-MM-DD'),
+            value
+          });
+        }
+      });
+      return newResult;
+    }
+    return [];
+  }
+  convertChart(chart) {
+    const {
+      _id,
+      table_id,
+      view_id,
+      time_column,
+      summary_type,
+      summary_column,
+      summary_method
+    } = chart;
+    return {
+      _id,
+      table_id,
+      view_id,
+      x_axis_column_key: time_column,
+      y_axis_summary_type: summary_type,
+      y_axis_summary_method: summary_method,
+      y_axis_column_key: summary_column,
+      x_axis_date_granularity: 'day'
+    };
+  }
+  sortDataByYear(data) {
+    data.sort((current, next) => {
+      if (current.year > next.year) {
+        return -1;
+      } else if (current.year < next.year) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+  }
+}
+var _default = exports.default = HeatMapCalculator;