dtable-statistic 4.3.4 → 4.3.6

package/es/calculator/trend-calculator.js

@@ -1,10 +1,17 @@
-import { filter2SqlCondition, TableUtils } from 'dtable-store';
-import BaseCalculator from './base-calculator';
-import { getSummaryColumnMethod } from '../utils/common-utils';
-import { getSqlGroup } from '../utils/sql-utils';
-import { getCompareDate, summaryDurationResult } from '../utils/trend-utils';
-import { DTABLE_DB_SUMMARY_METHOD, SUMMARY_TYPE } from '../constants';
-class TrendCalculator extends BaseCalculator {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableStore = require("dtable-store");
+var _baseCalculator = _interopRequireDefault(require("./base-calculator"));
+var _commonUtils = require("../utils/common-utils");
+var _sqlUtils = require("../utils/sql-utils");
+var _trendUtils = require("../utils/trend-utils");
+var _constants = require("../constants");
+class TrendCalculator extends _baseCalculator.default {
   constructor(_ref) {
     let {
       value,
@@ -30,8 +37,8 @@ class TrendCalculator extends BaseCalculator {
       summary_type
     } = chart;
     const table = this.getTableById(table_id);
-    if (!TableUtils.getTableColumnByKey(table, date_column)) return false;
-    if (summary_type === SUMMARY_TYPE.ADVANCED && !TableUtils.getTableColumnByKey(table, summary_column)) {
+    if (!_dtableStore.TableUtils.getTableColumnByKey(table, date_column)) return false;
+    if (summary_type === _constants.SUMMARY_TYPE.ADVANCED && !_dtableStore.TableUtils.getTableColumnByKey(table, summary_column)) {
       return false;
     }
     return true;
@@ -55,17 +62,17 @@ class TrendCalculator extends BaseCalculator {
     } = chart;
     const selectedTable = this.getTableById(table_id);
     const selectedView = this.getViewById(view_id, selectedTable);
-    const selectedColumn = TableUtils.getTableColumnByKey(selectedTable, date_column);
+    const selectedColumn = _dtableStore.TableUtils.getTableColumnByKey(selectedTable, date_column);
     if (!selectedColumn) return {};
-    const sqlCondition = filter2SqlCondition(selectedTable, selectedView);
-    const numericColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+    const sqlCondition = (0, _dtableStore.filter2SqlCondition)(selectedTable, selectedView);
+    const numericColumn = _dtableStore.TableUtils.getTableColumnByKey(selectedTable, summary_column);
     const columnName = selectedColumn.name;
-    const dateGroupBy = getSqlGroup(date_granularity, selectedColumn);
+    const dateGroupBy = (0, _sqlUtils.getSqlGroup)(date_granularity, selectedColumn);
     let sqlString = '';
-    if (summary_type === SUMMARY_TYPE.COUNT) {
-      sqlString = "select ".concat(dateGroupBy, ", ").concat(DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(dateGroupBy, " order by ").concat(dateGroupBy, " limit 5000");
+    if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      sqlString = "select ".concat(dateGroupBy, ", ").concat(_constants.DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(dateGroupBy, " order by ").concat(dateGroupBy, " limit 5000");
     } else {
-      const summaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
+      const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
       sqlString = "select ".concat(dateGroupBy, ", ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(dateGroupBy, " order by ").concat(dateGroupBy, " limit 5000");
     }
     const result = await this.sqlQuery(sqlString);
@@ -73,9 +80,9 @@ class TrendCalculator extends BaseCalculator {
       const data = result.data;
       if (!data.results) return {};
       const results = data.results;
-      let summaryKey = "".concat(DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ")");
-      if (summary_type === SUMMARY_TYPE.ADVANCED) {
-        const summaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
+      let summaryKey = "".concat(_constants.DTABLE_DB_SUMMARY_METHOD.Row_count, "(").concat(columnName, ")");
+      if (summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+        const summaryColumnMethod = (0, _commonUtils.getSummaryColumnMethod)(_constants.DTABLE_DB_SUMMARY_METHOD[summary_method], numericColumn.name);
         summaryKey = summaryColumnMethod;
       }
       let compareValue, comparedValue;
@@ -83,14 +90,14 @@ class TrendCalculator extends BaseCalculator {
         const {
           compareValue: value1,
           comparedValue: value2
-        } = summaryDurationResult(results, date_granularity, summary_type, summary_method, true, dateGroupBy, summaryKey);
+        } = (0, _trendUtils.summaryDurationResult)(results, date_granularity, summary_type, summary_method, true, dateGroupBy, summaryKey);
         compareValue = value1;
         comparedValue = value2;
       } else {
         const {
           compareDate,
           comparedDate
-        } = getCompareDate(date_granularity);
+        } = (0, _trendUtils.getCompareDate)(date_granularity);
         for (let index = results.length - 1; index >= 0; index--) {
           const item = results[index];
           if (!item[dateGroupBy]) continue;
@@ -117,4 +124,4 @@ class TrendCalculator extends BaseCalculator {
     return {};
   }
 }
-export default TrendCalculator;
+var _default = exports.default = TrendCalculator;

package/es/calculator/workers/basic-chart-calculator-worker.js

@@ -1,11 +1,18 @@
-import { CellType, DATE_COLUMN_OPTIONS, FORMULA_COLUMN_TYPES_MAP, TableUtils, Views } from 'dtable-store';
-import { STATISTICS_COUNT_TYPE, STAT_TYPE, Y_AXIS_TYPE_PREFIX } from '../../constants';
-import { getColorFromSingleSelectColumn } from '../../utils/column-utils';
-import { isArrayCellValue } from '../../utils/common-utils';
-import { getFormattedLabel, isValidRow } from '../../utils/row-utils';
-import StatUtils from '../../utils/stat-utils';
-import { fixMapGeoGranularity } from '../../utils/map';
-const MAP_CHART_TYPES = [STAT_TYPE.MAP, STAT_TYPE.WORLD_MAP, STAT_TYPE.MAP_BUBBLE, STAT_TYPE.WORLD_MAP_BUBBLE];
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableStore = require("dtable-store");
+var _constants = require("../../constants");
+var _columnUtils = require("../../utils/column-utils");
+var _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
+var _statUtils = _interopRequireDefault(require("../../utils/stat-utils"));
+var _map = require("../../utils/map");
+const MAP_CHART_TYPES = [_constants.STAT_TYPE.MAP, _constants.STAT_TYPE.WORLD_MAP, _constants.STAT_TYPE.MAP_BUBBLE, _constants.STAT_TYPE.WORLD_MAP_BUBBLE];
 function calculateChart(chart, value, username, userId) {
   const {
     type
@@ -13,7 +20,7 @@ function calculateChart(chart, value, username, userId) {
   if (MAP_CHART_TYPES.includes(type)) {
     return calculateGeolocationBasicChart(chart, value, username, userId);
   }
-  if (type === STAT_TYPE.CUSTOM_BAR) {
+  if (type === _constants.STAT_TYPE.CUSTOM_BAR) {
     return calculateCustomBar(chart, value, username, userId);
   }
   const {
@@ -38,7 +45,7 @@ function calculateBasicChart(chart, value, username, userId) {
   let groupby_date_granularity;
   let include_empty;
   let groupby_geolocation_granularity;
-  if (chart.type === STAT_TYPE.PIE || chart.type === STAT_TYPE.RING || chart.type === STAT_TYPE.TREEMAP) {
+  if (chart.type === _constants.STAT_TYPE.PIE || chart.type === _constants.STAT_TYPE.RING || chart.type === _constants.STAT_TYPE.TREEMAP) {
     groupby_column_key = chart.groupby_column_key;
     summary_type = chart.summary_type;
     summary_method = chart.summary_method;
@@ -55,38 +62,38 @@ function calculateBasicChart(chart, value, username, userId) {
     groupby_geolocation_granularity = chart.x_axis_geolocation_granularity;
     include_empty = chart.x_axis_include_empty;
   }
-  const table = TableUtils.getTableById(value.tables, table_id);
-  const view = table && Views.getViewById(table.views, view_id);
+  const table = _dtableStore.TableUtils.getTableById(value.tables, table_id);
+  const view = table && _dtableStore.Views.getViewById(table.views, view_id);
   if (!view) {
     return;
   }
-  const groupbyColumn = groupby_column_key && TableUtils.getTableColumnByKey(table, groupby_column_key);
+  const groupbyColumn = groupby_column_key && _dtableStore.TableUtils.getTableColumnByKey(table, groupby_column_key);
   if (!groupbyColumn) {
     return;
   }
-  const summaryColumn = TableUtils.getTableColumnByKey(table, summary_column_key);
+  const summaryColumn = _dtableStore.TableUtils.getTableColumnByKey(table, summary_column_key);
   const {
     type: groupby_column_type
   } = groupbyColumn;
-  if (DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
-    groupby_date_granularity = STATISTICS_COUNT_TYPE.MONTH;
+  if (_dtableStore.DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
+    groupby_date_granularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
   }
-  if (groupby_column_type === CellType.GEOLOCATION && !groupby_geolocation_granularity) {
-    groupby_geolocation_granularity = STATISTICS_COUNT_TYPE.PROVINCE;
+  if (groupby_column_type === _dtableStore.CellType.GEOLOCATION && !groupby_geolocation_granularity) {
+    groupby_geolocation_granularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
   }
   const yAxisType = null;
-  const statRows = Views.getViewRows(view, table, value, username, userId);
-  const formulaRows = Views.getTableFormulaResults(table, statRows, value);
-  const isGroupbyColumnDataAsAnArray = isArrayCellValue(groupbyColumn);
+  const statRows = _dtableStore.Views.getViewRows(view, table, value, username, userId);
+  const formulaRows = _dtableStore.Views.getTableFormulaResults(table, statRows, value);
+  const isGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupbyColumn);
   let results = getBasicChartResults(statRows, formulaRows, groupbyColumn, include_empty, isGroupbyColumnDataAsAnArray, groupby_date_granularity, groupby_geolocation_granularity, summaryColumn, summary_type, summary_method, yAxisType, value);
   if (sort_type) {
-    StatUtils.sortStatisticData(results, sort_type); // sortby statistic value
+    _statUtils.default.sortStatisticData(results, sort_type); // sortby statistic value
   } else {
-    StatUtils.sortStatistics(results, groupbyColumn, 'name'); // sortby statistic label
+    _statUtils.default.sortStatistics(results, groupbyColumn, 'name'); // sortby statistic label
   }
 
   results.forEach(item => {
-    item.name = getFormattedLabel(groupbyColumn, item.name, value.collaborators);
+    item.name = (0, _rowUtils.getFormattedLabel)(groupbyColumn, item.name, value.collaborators);
   });
   return results;
 }
@@ -108,55 +115,55 @@ function calculateGroupingChart(chart, value, username, userId) {
   let groupby_date_granularity = chart.x_axis_date_granularity;
   let groupby_geolocation_granularity = chart.x_axis_geolocation_granularity;
   let column_groupby_numeric_columns = chart.column_groupby_numeric_columns || [];
-  const table = TableUtils.getTableById(value.tables, table_id);
-  const view = table && Views.getViewById(table.views, view_id);
+  const table = _dtableStore.TableUtils.getTableById(value.tables, table_id);
+  const view = table && _dtableStore.Views.getViewById(table.views, view_id);
   if (!view) {
     return;
   }
-  const groupbyColumn = groupby_column_key && TableUtils.getTableColumnByKey(table, groupby_column_key);
+  const groupbyColumn = groupby_column_key && _dtableStore.TableUtils.getTableColumnByKey(table, groupby_column_key);
   if (!groupbyColumn) {
     return;
   }
   const {
     type: groupby_column_type
   } = groupbyColumn;
-  if (DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
-    groupby_date_granularity = STATISTICS_COUNT_TYPE.MONTH;
+  if (_dtableStore.DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
+    groupby_date_granularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
   }
-  if (groupby_column_type === CellType.GEOLOCATION && !groupby_geolocation_granularity) {
-    groupby_geolocation_granularity = STATISTICS_COUNT_TYPE.PROVINCE;
+  if (groupby_column_type === _dtableStore.CellType.GEOLOCATION && !groupby_geolocation_granularity) {
+    groupby_geolocation_granularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
   }
   const yAxisType = null;
-  const statRows = Views.getViewRows(view, table, value, username, userId);
-  const formulaRows = Views.getTableFormulaResults(table, statRows, value);
+  const statRows = _dtableStore.Views.getViewRows(view, table, value, username, userId);
+  const formulaRows = _dtableStore.Views.getTableFormulaResults(table, statRows, value);
   let results = getGroupingChartResults(statRows, formulaRows, groupbyColumn, x_axis_include_empty, groupby_date_granularity, groupby_geolocation_granularity, column_groupby_column_key, column_groupby_date_granularity, column_groupby_geolocation_granularity, y_axis_column_key, y_axis_summary_type, y_axis_summary_method, column_groupby_multiple_numeric_column, column_groupby_numeric_columns, yAxisType, table, value);
-  StatUtils.sortStatistics(results, groupbyColumn, 'name');
+  _statUtils.default.sortStatistics(results, groupbyColumn, 'name');
   results = results.map(result => {
     return {
       ...result,
-      name: getFormattedLabel(groupbyColumn, result.name, value.collaborators)
+      name: (0, _rowUtils.getFormattedLabel)(groupbyColumn, result.name, value.collaborators)
     };
   });
   return results;
 }
 function getGroupChartStatResult(table, value, groupbyColumn, groupColumnKey, statRows, formulaRows, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyGateGranularity, columnGroupbyGeolocationGranularity, summaryColumn, summaryType, summaryMethod, columnGroupbyMultipleNumericColumn, yAxisType) {
-  let columnGroupbyColumn = TableUtils.getTableColumnByKey(table, groupColumnKey);
+  let columnGroupbyColumn = _dtableStore.TableUtils.getTableColumnByKey(table, groupColumnKey);
   if (!columnGroupbyColumn) {
     return [];
   }
   let result = [];
-  let isGroupbyColumnDataAsAnArray = isArrayCellValue(groupbyColumn);
-  let isColumnGroupbyColumnDataAsAnArray = isArrayCellValue(columnGroupbyColumn);
+  let isGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupbyColumn);
+  let isColumnGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(columnGroupbyColumn);
   statRows.forEach(row => {
     let {
       _id: rowId
     } = row;
     let formulaRow = formulaRows[rowId];
-    if (isValidRow(row, formulaRow, groupbyColumn, includeEmpty)) {
-      let name = StatUtils.getGroupLabel(row[groupbyColumn.key], formulaRow, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, value);
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, groupbyColumn, includeEmpty)) {
+      let name = _statUtils.default.getGroupLabel(row[groupbyColumn.key], formulaRow, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, value);
       let groupName = columnGroupbyColumn.name;
       if (!columnGroupbyMultipleNumericColumn) {
-        groupName = StatUtils.getGroupLabel(row[columnGroupbyColumn.key], formulaRow, columnGroupbyColumn, columnGroupbyGateGranularity, columnGroupbyGeolocationGranularity, value);
+        groupName = _statUtils.default.getGroupLabel(row[columnGroupbyColumn.key], formulaRow, columnGroupbyColumn, columnGroupbyGateGranularity, columnGroupbyGeolocationGranularity, value);
       }
       if (isGroupbyColumnDataAsAnArray) {
         if (name.length === 0 && includeEmpty) {
@@ -245,9 +252,9 @@ function updateChartValue(summaryColumn, summary_type, summary_method, formula_r
     let updated = {
       ...item
     };
-    const value = StatUtils.getTotal(summaryColumnKey, summaryColumnType, summary_type, summary_method, rows, formula_rows);
+    const value = _statUtils.default.getTotal(summaryColumnKey, summaryColumnType, summary_type, summary_method, rows, formula_rows);
     updated.value = value;
-    updated.formatted_value = StatUtils.getFormattedValue(value, summaryColumn, summary_method);
+    updated.formatted_value = _statUtils.default.getFormattedValue(value, summaryColumn, summary_method);
     results[index] = updated;
   });
 }
@@ -258,8 +265,8 @@ function getBasicChartResults(rows, formulaRows, groupbyColumn, includeEmpty, is
       _id: rowId
     } = row;
     const formulaRow = formulaRows[rowId];
-    if (!isValidRow(row, formulaRow, groupbyColumn, includeEmpty)) return;
-    const name = StatUtils.getGroupLabel(row[groupbyColumn.key], formulaRow, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, value);
+    if (!(0, _rowUtils.isValidRow)(row, formulaRow, groupbyColumn, includeEmpty)) return;
+    const name = _statUtils.default.getGroupLabel(row[groupbyColumn.key], formulaRow, groupbyColumn, groupbyDateGranularity, groupbyGeolocationGranularity, value);
     if (isGroupbyColumnDataAsAnArray) {
       if (name.length === 0 && includeEmpty) {
         const nameIndex = results.findIndex(result => !result.name);
@@ -302,25 +309,25 @@ function getGroupingChartResults(rows, formulaRows, groupbyColumn, xAxisIncludeE
   return results;
 }
 function getGroupbyOneColumnChartResults(rows, formulaRows, groupbyColumn, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryColumnKey, summaryType, summaryMethod, yAxisType, table, value) {
-  const summaryColumn = TableUtils.getTableColumnByKey(table, summaryColumnKey);
+  const summaryColumn = _dtableStore.TableUtils.getTableColumnByKey(table, summaryColumnKey);
   const columnGroupbyMultipleNumericColumn = false;
   let results = getGroupChartStatResult(table, value, groupbyColumn, columnGroupbyColumnKey, rows, formulaRows, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryColumn, summaryType, summaryMethod, columnGroupbyMultipleNumericColumn, yAxisType);
-  const columnGroupByColumn = TableUtils.getTableColumnByKey(table, columnGroupbyColumnKey);
+  const columnGroupByColumn = _dtableStore.TableUtils.getTableColumnByKey(table, columnGroupbyColumnKey);
   results = results.map(result => {
     const groupName = result.group_name;
     let formattedResult = {
       ...result
     };
-    if (columnGroupByColumn.type === CellType.SINGLE_SELECT) {
-      formattedResult.color = getColorFromSingleSelectColumn(columnGroupByColumn, groupName);
+    if (columnGroupByColumn.type === _dtableStore.CellType.SINGLE_SELECT) {
+      formattedResult.color = (0, _columnUtils.getColorFromSingleSelectColumn)(columnGroupByColumn, groupName);
     }
-    formattedResult.group_name = getFormattedLabel(columnGroupByColumn, groupName, value.collaborators);
+    formattedResult.group_name = (0, _rowUtils.getFormattedLabel)(columnGroupByColumn, groupName, value.collaborators);
     return formattedResult;
   });
   return results;
 }
 function getGroupbyNumericColumnsChartResults(rows, formulaRows, groupbyColumn, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, numericSummaryColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryType, summaryMethod, yAxisType, table, value) {
-  const summaryColumn = TableUtils.getTableColumnByKey(table, numericSummaryColumnKey);
+  const summaryColumn = _dtableStore.TableUtils.getTableColumnByKey(table, numericSummaryColumnKey);
   const columnGroupbyMultipleNumericColumn = true;
   return getGroupChartStatResult(table, value, groupbyColumn, numericSummaryColumnKey, rows, formulaRows, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryColumn, summaryType, summaryMethod, columnGroupbyMultipleNumericColumn, yAxisType);
 }
@@ -334,24 +341,24 @@ function calculateGeolocationBasicChart(chart, value, username, userId) {
     summary_column,
     summary_method
   } = chart;
-  const table = TableUtils.getTableById(value.tables, table_id);
-  const view = table && Views.getViewById(table.views, view_id);
+  const table = _dtableStore.TableUtils.getTableById(value.tables, table_id);
+  const view = table && _dtableStore.Views.getViewById(table.views, view_id);
   if (!view) {
     return;
   }
-  const geoColumn = geo_column && TableUtils.getTableColumnByKey(table, geo_column);
+  const geoColumn = geo_column && _dtableStore.TableUtils.getTableColumnByKey(table, geo_column);
   if (!geoColumn) {
     return;
   }
   let geolocationGranularity = null;
   if (type && type.includes('world')) {
-    geolocationGranularity = geoColumn.type === CellType.GEOLOCATION ? chart.geolocation_granularity : null;
+    geolocationGranularity = geoColumn.type === _dtableStore.CellType.GEOLOCATION ? chart.geolocation_granularity : null;
   } else {
-    geolocationGranularity = fixMapGeoGranularity(chart);
+    geolocationGranularity = (0, _map.fixMapGeoGranularity)(chart);
   }
-  const summaryColumn = TableUtils.getTableColumnByKey(table, summary_column);
-  const statRows = Views.getViewRows(view, table, value, username, userId);
-  const formulaRows = Views.getTableFormulaResults(table, statRows, value);
+  const summaryColumn = _dtableStore.TableUtils.getTableColumnByKey(table, summary_column);
+  const statRows = _dtableStore.Views.getViewRows(view, table, value, username, userId);
+  const formulaRows = _dtableStore.Views.getTableFormulaResults(table, statRows, value);
   const geoColumnType = geoColumn.type;
   let results = [];
   statRows.forEach(row => {
@@ -359,8 +366,8 @@ function calculateGeolocationBasicChart(chart, value, username, userId) {
       _id: rowId
     } = row;
     const formulaRow = formulaRows[rowId];
-    if (isValidRow(row, formulaRow, geoColumn, false)) {
-      if (FORMULA_COLUMN_TYPES_MAP[geoColumnType]) {
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, geoColumn, false)) {
+      if (_dtableStore.FORMULA_COLUMN_TYPES_MAP[geoColumnType]) {
         const list = formulaRow[geoColumn.key];
         list.forEach(n => {
           const nameIndex = results.findIndex(r => {
@@ -398,12 +405,12 @@ function calculateCustomBar(statItem, value, username, userId) {
     x_axis_include_empty,
     y_axises
   } = statItem;
-  const table = TableUtils.getTableById(value.tables, table_id);
-  const view = table && Views.getViewById(table.views, view_id);
+  const table = _dtableStore.TableUtils.getTableById(value.tables, table_id);
+  const view = table && _dtableStore.Views.getViewById(table.views, view_id);
   if (!view || !x_axis_column_key || !Array.isArray(y_axises) || y_axises.length === 0) {
     return [];
   }
-  const groupbyColumn = TableUtils.getTableColumnByKey(table, x_axis_column_key);
+  const groupbyColumn = _dtableStore.TableUtils.getTableColumnByKey(table, x_axis_column_key);
   if (!groupbyColumn) {
     return [];
   }
@@ -412,45 +419,45 @@ function calculateCustomBar(statItem, value, username, userId) {
   } = groupbyColumn;
   let groupbyDateGranularity = x_axis_date_granularity;
   let groupbyGeolocationGranularity = x_axis_geolocation_granularity;
-  if (DATE_COLUMN_OPTIONS.includes(groupbyColumnType) && !groupbyDateGranularity) {
-    groupbyDateGranularity = STATISTICS_COUNT_TYPE.MONTH;
+  if (_dtableStore.DATE_COLUMN_OPTIONS.includes(groupbyColumnType) && !groupbyDateGranularity) {
+    groupbyDateGranularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
   }
-  if (groupbyColumnType === CellType.GEOLOCATION && !groupbyGeolocationGranularity) {
-    groupbyGeolocationGranularity = STATISTICS_COUNT_TYPE.PROVINCE;
+  if (groupbyColumnType === _dtableStore.CellType.GEOLOCATION && !groupbyGeolocationGranularity) {
+    groupbyGeolocationGranularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
   }
   const columnGroupbyDateGranularity = null;
   const columnGroupbyGeolocationGranularity = null;
-  const statRows = Views.getViewRows(view, table, value, username, userId);
-  const formulaRows = Views.getTableFormulaResults(table, statRows, value);
+  const statRows = _dtableStore.Views.getViewRows(view, table, value, username, userId);
+  const formulaRows = _dtableStore.Views.getTableFormulaResults(table, statRows, value);
   let results = [];
   y_axises.forEach((yAxis, index) => {
     const {
       type: yAxisType,
       column_groupby_numeric_columns
     } = yAxis;
-    if (yAxisType === STAT_TYPE.BAR_STACK) {
+    if (yAxisType === _constants.STAT_TYPE.BAR_STACK) {
       // just support summary numeric columns.
       if (!Array.isArray(column_groupby_numeric_columns) || column_groupby_numeric_columns.length === 0) {
         return;
       }
-      const yAxisType = "".concat(Y_AXIS_TYPE_PREFIX).concat(index);
+      const yAxisType = "".concat(_constants.Y_AXIS_TYPE_PREFIX).concat(index);
       column_groupby_numeric_columns.forEach(numericSummaryColumn => {
         const {
           column_key: summary_column_key,
           summary_method
         } = numericSummaryColumn;
-        const currentResults = getGroupbyNumericColumnsChartResults(statRows, formulaRows, groupbyColumn, x_axis_include_empty, groupbyDateGranularity, groupbyGeolocationGranularity, summary_column_key, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, STATISTICS_COUNT_TYPE.ADVANCED, summary_method, yAxisType, table, value);
+        const currentResults = getGroupbyNumericColumnsChartResults(statRows, formulaRows, groupbyColumn, x_axis_include_empty, groupbyDateGranularity, groupbyGeolocationGranularity, summary_column_key, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, _constants.STATISTICS_COUNT_TYPE.ADVANCED, summary_method, yAxisType, table, value);
         results = results.concat(currentResults);
       });
     }
   });
-  StatUtils.sortStatistics(results, groupbyColumn, 'name');
+  _statUtils.default.sortStatistics(results, groupbyColumn, 'name');
   results = results.map(result => {
     return {
       ...result,
-      name: getFormattedLabel(groupbyColumn, result.name, value.collaborators)
+      name: (0, _rowUtils.getFormattedLabel)(groupbyColumn, result.name, value.collaborators)
     };
   });
   return results;
 }
-export default calculateChart;
+var _default = exports.default = calculateChart;

package/es/calculator/workers/calculator.worker.js

@@ -1,38 +1,41 @@
-import { expose } from 'comlink';
-import PivotTableCalculatorWorker from './pivot-table-calculator-worker';
-import BasicChartCalculatorWorker from './basic-chart-calculator-worker';
-import CompareBarCalculatorWorker from './compare-bar-chart-calculator-worker';
-import CompletenessCalculatorWorker from './completeness-calculator-worker';
-import CombinationCalculatorWorker from './combination-calculator-worker';
-import ScatterCalculatorWorker from './scatter-calculator-worker';
-import MirrorCalculatorWorker from './mirror-calculator-worker';
-import CardCalculatorWorker from './card-calculator-worker';
-import TrendCalculatorWorker from './trend-calculator-worker';
-import DashboardCalculatorWorker from './dashboard-calculator-worker';
-import { STAT_TYPE } from '../../constants';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _comlink = require("comlink");
+var _pivotTableCalculatorWorker = _interopRequireDefault(require("./pivot-table-calculator-worker"));
+var _basicChartCalculatorWorker = _interopRequireDefault(require("./basic-chart-calculator-worker"));
+var _compareBarChartCalculatorWorker = _interopRequireDefault(require("./compare-bar-chart-calculator-worker"));
+var _completenessCalculatorWorker = _interopRequireDefault(require("./completeness-calculator-worker"));
+var _combinationCalculatorWorker = _interopRequireDefault(require("./combination-calculator-worker"));
+var _scatterCalculatorWorker = _interopRequireDefault(require("./scatter-calculator-worker"));
+var _mirrorCalculatorWorker = _interopRequireDefault(require("./mirror-calculator-worker"));
+var _cardCalculatorWorker = _interopRequireDefault(require("./card-calculator-worker"));
+var _trendCalculatorWorker = _interopRequireDefault(require("./trend-calculator-worker"));
+var _dashboardCalculatorWorker = _interopRequireDefault(require("./dashboard-calculator-worker"));
+var _constants = require("../../constants");
 const BASIC_CHART = 'basic_chart';
 const typeCalculatorWorkerMap = {
-  [STAT_TYPE.PIVOT_TABLE]: PivotTableCalculatorWorker,
-  [BASIC_CHART]: BasicChartCalculatorWorker,
-  [STAT_TYPE.COMPARE_BAR]: CompareBarCalculatorWorker,
-  [STAT_TYPE.HORIZONTAL_BAR]: BasicChartCalculatorWorker,
-  [STAT_TYPE.HORIZONTAL_GROUP_BAR]: BasicChartCalculatorWorker,
-  [STAT_TYPE.STACKED_HORIZONTAL_BAR]: BasicChartCalculatorWorker,
-  [STAT_TYPE.COMPLETENESS_CHART]: CompletenessCalculatorWorker,
-  [STAT_TYPE.GROUP_COMPLETENESS_CHART]: CompletenessCalculatorWorker,
-  [STAT_TYPE.SCATTER]: ScatterCalculatorWorker,
-  [STAT_TYPE.COMBINATION_CHART]: CombinationCalculatorWorker,
-  [STAT_TYPE.MAP]: BasicChartCalculatorWorker,
-  [STAT_TYPE.WORLD_MAP]: BasicChartCalculatorWorker,
-  [STAT_TYPE.HEAT_MAP]: BasicChartCalculatorWorker,
-  [STAT_TYPE.MIRROR]: MirrorCalculatorWorker,
-  [STAT_TYPE.BASIC_NUMBER_CARD]: CardCalculatorWorker,
-  [STAT_TYPE.TREND_CHART]: TrendCalculatorWorker,
-  [STAT_TYPE.DASHBOARD]: DashboardCalculatorWorker
+  [_constants.STAT_TYPE.PIVOT_TABLE]: _pivotTableCalculatorWorker.default,
+  [BASIC_CHART]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.COMPARE_BAR]: _compareBarChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.HORIZONTAL_BAR]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.HORIZONTAL_GROUP_BAR]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.STACKED_HORIZONTAL_BAR]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.COMPLETENESS_CHART]: _completenessCalculatorWorker.default,
+  [_constants.STAT_TYPE.GROUP_COMPLETENESS_CHART]: _completenessCalculatorWorker.default,
+  [_constants.STAT_TYPE.SCATTER]: _scatterCalculatorWorker.default,
+  [_constants.STAT_TYPE.COMBINATION_CHART]: _combinationCalculatorWorker.default,
+  [_constants.STAT_TYPE.MAP]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.WORLD_MAP]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.HEAT_MAP]: _basicChartCalculatorWorker.default,
+  [_constants.STAT_TYPE.MIRROR]: _mirrorCalculatorWorker.default,
+  [_constants.STAT_TYPE.BASIC_NUMBER_CARD]: _cardCalculatorWorker.default,
+  [_constants.STAT_TYPE.TREND_CHART]: _trendCalculatorWorker.default,
+  [_constants.STAT_TYPE.DASHBOARD]: _dashboardCalculatorWorker.default
 };
 function calculator(chart, value, username, userId) {
   const type = chart.type;
   const calculatorWorker = typeCalculatorWorkerMap[type] || typeCalculatorWorkerMap[BASIC_CHART];
   return calculatorWorker(chart, value, username, userId);
 }
-expose(calculator);
+(0, _comlink.expose)(calculator);

package/es/calculator/workers/card-calculator-worker.js

@@ -1,6 +1,12 @@
-import { isNumber, isNumericColumn, TableUtils, Views } from 'dtable-store';
-import { getSummaryResult } from '../../utils/common-utils';
-import { getCellValue } from '../../utils/row-utils';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableStore = require("dtable-store");
+var _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
 function calculateResult(chart, dtableValue, username, userId) {
   const {
     table_id,
@@ -8,23 +14,23 @@ function calculateResult(chart, dtableValue, username, userId) {
     numeric_column,
     summary_method
   } = chart;
-  const selectedTable = TableUtils.getTableById(dtableValue.tables, table_id);
-  const selectedView = selectedTable && Views.getViewById(selectedTable.views, view_id);
-  const selectedColumn = TableUtils.getTableColumnByKey(selectedTable, numeric_column);
-  const _isNumericColumn = selectedColumn && isNumericColumn(selectedColumn);
-  const statRows = Views.getViewRows(selectedView, selectedTable, dtableValue, username, userId);
-  const formulaRows = _isNumericColumn ? Views.getTableFormulaResults(selectedTable, statRows, dtableValue) : {};
+  const selectedTable = _dtableStore.TableUtils.getTableById(dtableValue.tables, table_id);
+  const selectedView = selectedTable && _dtableStore.Views.getViewById(selectedTable.views, view_id);
+  const selectedColumn = _dtableStore.TableUtils.getTableColumnByKey(selectedTable, numeric_column);
+  const _isNumericColumn = selectedColumn && (0, _dtableStore.isNumericColumn)(selectedColumn);
+  const statRows = _dtableStore.Views.getViewRows(selectedView, selectedTable, dtableValue, username, userId);
+  const formulaRows = _isNumericColumn ? _dtableStore.Views.getTableFormulaResults(selectedTable, statRows, dtableValue) : {};
   const numberList = [];
   _isNumericColumn && statRows.forEach(row => {
     const formulaRow = formulaRows[row._id];
-    const cellValue = getCellValue(row, formulaRow, selectedColumn);
-    if (isNumber(cellValue)) {
+    const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, selectedColumn);
+    if ((0, _dtableStore.isNumber)(cellValue)) {
       numberList.push(cellValue);
     }
   });
   if (summary_method === 'Row_count') {
     return statRows.length;
   }
-  return getSummaryResult(numberList, summary_method);
+  return (0, _commonUtils.getSummaryResult)(numberList, summary_method);
 }
-export default calculateResult;
+var _default = exports.default = calculateResult;