dtable-statistic 4.4.24-alpha.9 → 5.0.0

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

@@ -0,0 +1,495 @@
+"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 _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, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    type
+  } = chart;
+  if (MAP_CHART_TYPES.includes(type)) {
+    return calculateGeolocationBasicChart(chart, value, {
+      getViewRows,
+      getTableFormulaResults
+    });
+  }
+  if (type === _constants.STAT_TYPE.CUSTOM_BAR) {
+    return calculateCustomBar(chart, value, {
+      getViewRows,
+      getTableFormulaResults
+    });
+  }
+  const {
+    column_groupby_column_key,
+    column_groupby_multiple_numeric_column
+  } = chart;
+  if (!column_groupby_column_key && !column_groupby_multiple_numeric_column) {
+    return calculateBasicChart(chart, value, {
+      getViewRows,
+      getTableFormulaResults
+    });
+  }
+  return calculateGroupingChart(chart, value, {
+    getViewRows,
+    getTableFormulaResults
+  });
+}
+async function calculateBasicChart(chart, value, _ref2) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref2;
+  const {
+    table_id,
+    view_id,
+    sort_type
+  } = chart;
+  let groupby_column_key;
+  let summary_type;
+  let summary_method;
+  let summary_column_key;
+  let groupby_date_granularity;
+  let include_empty;
+  let groupby_geolocation_granularity;
+  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;
+    summary_column_key = chart.summary_column_key;
+    groupby_date_granularity = chart.groupby_date_granularity;
+    include_empty = chart.groupby_include_empty_cells;
+    groupby_geolocation_granularity = chart.groupby_geolocation_granularity;
+  } else {
+    groupby_column_key = chart.x_axis_column_key;
+    summary_type = chart.y_axis_summary_type;
+    summary_method = chart.y_axis_summary_method;
+    summary_column_key = chart.y_axis_column_key;
+    groupby_date_granularity = chart.x_axis_date_granularity;
+    groupby_geolocation_granularity = chart.x_axis_geolocation_granularity;
+    include_empty = chart.x_axis_include_empty;
+  }
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) {
+    return;
+  }
+  const groupbyColumn = groupby_column_key && (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+  if (!groupbyColumn) {
+    return;
+  }
+  const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
+  const {
+    type: groupby_column_type
+  } = groupbyColumn;
+  if (_dtableUtils.DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
+    groupby_date_granularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
+  }
+  if (groupby_column_type === _dtableUtils.CellType.GEOLOCATION && !groupby_geolocation_granularity) {
+    groupby_geolocation_granularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
+  }
+  const yAxisType = null;
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  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.default.sortStatisticData(results, sort_type); // sortby statistic value
+  } else {
+    _statUtils.default.sortStatistics(results, groupbyColumn, 'name'); // sortby statistic label
+  }
+
+  results.forEach(item => {
+    item.name = (0, _rowUtils.getFormattedLabel)(groupbyColumn, item.name, value.collaborators);
+  });
+  return results;
+}
+async function calculateGroupingChart(chart, value, _ref3) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref3;
+  const {
+    table_id,
+    view_id,
+    x_axis_column_key,
+    x_axis_include_empty,
+    y_axis_column_key,
+    y_axis_summary_type,
+    y_axis_summary_method,
+    column_groupby_multiple_numeric_column
+  } = chart;
+  const groupby_column_key = x_axis_column_key;
+  const column_groupby_column_key = chart.column_groupby_column_key;
+  const column_groupby_date_granularity = chart.column_groupby_date_granularity;
+  const column_groupby_geolocation_granularity = chart.column_groupby_geolocation_granularity;
+  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 = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) {
+    return;
+  }
+  const groupbyColumn = groupby_column_key && (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+  if (!groupbyColumn) {
+    return;
+  }
+  const {
+    type: groupby_column_type
+  } = groupbyColumn;
+  if (_dtableUtils.DATE_COLUMN_OPTIONS.includes(groupby_column_type) && !groupby_date_granularity) {
+    groupby_date_granularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
+  }
+  if (groupby_column_type === _dtableUtils.CellType.GEOLOCATION && !groupby_geolocation_granularity) {
+    groupby_geolocation_granularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
+  }
+  const yAxisType = null;
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  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.default.sortStatistics(results, groupbyColumn, 'name');
+  results = results.map(result => {
+    return {
+      ...result,
+      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 = (0, _dtableUtils.getTableColumnByKey)(table, groupColumnKey);
+  if (!columnGroupbyColumn) {
+    return [];
+  }
+  let result = [];
+  let isGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupbyColumn);
+  let isColumnGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(columnGroupbyColumn);
+  statRows.forEach(row => {
+    let {
+      _id: rowId
+    } = row;
+    let formulaRow = formulaRows[rowId];
+    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.default.getGroupLabel(row[columnGroupbyColumn.key], formulaRow, columnGroupbyColumn, columnGroupbyGateGranularity, columnGroupbyGeolocationGranularity, value);
+      }
+      if (isGroupbyColumnDataAsAnArray) {
+        if (name.length === 0 && includeEmpty) {
+          groupChartRows(result, null, row, isColumnGroupbyColumnDataAsAnArray, groupName, includeEmpty, yAxisType);
+        } else {
+          name.forEach(n => {
+            groupChartRows(result, n, row, isColumnGroupbyColumnDataAsAnArray, groupName, includeEmpty, yAxisType);
+          });
+        }
+      } else {
+        groupChartRows(result, name, row, isColumnGroupbyColumnDataAsAnArray, groupName, includeEmpty, yAxisType);
+      }
+    }
+  });
+  updateChartValue(summaryColumn, summaryType, summaryMethod, formulaRows, result);
+  return result;
+}
+function updateBasicChartRows(results, index, name, row, yAxisType) {
+  let updatedResult;
+  if (index > -1) {
+    updatedResult = results[index];
+    updatedResult.rows.push(row);
+    results[index] = updatedResult;
+  } else {
+    updatedResult = {
+      name,
+      rows: [row]
+    };
+    if (yAxisType) {
+      updatedResult.y_axis_type = yAxisType;
+    }
+    results.push(updatedResult);
+  }
+}
+function groupChartRows(results, name, row, isColumnGroupbyColumnDataAsAnArray, groupName, include_empty, yAxisType) {
+  if (isColumnGroupbyColumnDataAsAnArray) {
+    if (!groupName || groupName.length === 0) {
+      updateGroupingChartRows(results, name, null, row, yAxisType);
+    } else {
+      groupName.forEach(v => {
+        updateGroupingChartRows(results, name, v, row, yAxisType);
+      });
+    }
+  } else {
+    if (!groupName && groupName !== 0 && !include_empty) {
+      return;
+    }
+    updateGroupingChartRows(results, name, groupName, row, yAxisType);
+  }
+}
+function updateGroupingChartRows(results, name, groupName, row, yAxisType) {
+  let updatedIndex = -1;
+  for (let i = 0; i < results.length; i++) {
+    if (results[i].name === name && results[i].group_name === groupName) {
+      updatedIndex = i;
+      break;
+    }
+  }
+  let updatedResult;
+  if (updatedIndex > -1) {
+    updatedResult = results[updatedIndex];
+    updatedResult.rows.push(row);
+    results[updatedIndex] = updatedResult;
+  } else {
+    updatedResult = {
+      name,
+      rows: [row],
+      group_name: groupName
+    };
+    if (yAxisType) {
+      updatedResult.y_axis_type = yAxisType;
+    }
+    results.push(updatedResult);
+  }
+}
+function updateChartValue(summaryColumn, summary_type, summary_method, formula_rows) {
+  let results = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  const {
+    key: summaryColumnKey,
+    type: summaryColumnType
+  } = summaryColumn || {};
+  Array.isArray(results) && results.forEach((item, index) => {
+    const {
+      rows
+    } = item;
+    let updated = {
+      ...item
+    };
+    const value = _statUtils.default.getTotal(summaryColumnKey, summaryColumnType, summary_type, summary_method, rows, formula_rows);
+    updated.value = value;
+    updated.formatted_value = _statUtils.default.getFormattedValue(value, summaryColumn, summary_method);
+    results[index] = updated;
+  });
+}
+function getBasicChartResults(rows, formulaRows, groupbyColumn, includeEmpty, isGroupbyColumnDataAsAnArray, groupbyDateGranularity, groupbyGeolocationGranularity, summaryColumn, summaryType, summaryMethod, yAxisType, value) {
+  let results = [];
+  rows.forEach(row => {
+    const {
+      _id: rowId
+    } = row;
+    const formulaRow = formulaRows[rowId];
+    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);
+        updateBasicChartRows(results, nameIndex, null, row, yAxisType);
+      } else {
+        name.forEach(n => {
+          const nameIndex = results.findIndex(result => n === result.name);
+          updateBasicChartRows(results, nameIndex, n, row, yAxisType);
+        });
+      }
+    } else {
+      const nameIndex = results.findIndex(result => result.name === name);
+      updateBasicChartRows(results, nameIndex, name, row, yAxisType);
+    }
+  });
+  updateChartValue(summaryColumn, summaryType, summaryMethod, formulaRows, results);
+  return results;
+}
+function getGroupingChartResults(rows, formulaRows, groupbyColumn, xAxisIncludeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, yAxisColumnKey, yAxisSummaryType, yAxisSummaryMethod, isColumnGroupbyNumericColumns, columnGroupbyNumericColumns, yAxisType, table, value) {
+  let results = [];
+  if (isColumnGroupbyNumericColumns) {
+    let allColumnGroupbyNumericColumns = [{
+      column_key: yAxisColumnKey,
+      summary_method: yAxisSummaryMethod
+    }];
+    if (Array.isArray(columnGroupbyNumericColumns) && columnGroupbyNumericColumns.length > 0) {
+      allColumnGroupbyNumericColumns.push(...columnGroupbyNumericColumns);
+    }
+    allColumnGroupbyNumericColumns.forEach(numericSummaryColumn => {
+      const {
+        column_key: summary_column_key,
+        summary_method
+      } = numericSummaryColumn;
+      const currentResults = getGroupbyNumericColumnsChartResults(rows, formulaRows, groupbyColumn, xAxisIncludeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, summary_column_key, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, yAxisSummaryType, summary_method, yAxisType, table, value);
+      results = results.concat(currentResults);
+    });
+  } else {
+    results = getGroupbyOneColumnChartResults(rows, formulaRows, groupbyColumn, xAxisIncludeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, yAxisColumnKey, yAxisSummaryType, yAxisSummaryMethod, yAxisType, table, value);
+  }
+  return results;
+}
+function getGroupbyOneColumnChartResults(rows, formulaRows, groupbyColumn, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyColumnKey, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryColumnKey, summaryType, summaryMethod, yAxisType, table, value) {
+  const summaryColumn = (0, _dtableUtils.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 = (0, _dtableUtils.getTableColumnByKey)(table, columnGroupbyColumnKey);
+  results = results.map(result => {
+    const groupName = result.group_name;
+    let formattedResult = {
+      ...result
+    };
+    if (columnGroupByColumn.type === _dtableUtils.CellType.SINGLE_SELECT) {
+      formattedResult.color = (0, _columnUtils.getColorFromSingleSelectColumn)(columnGroupByColumn, groupName);
+    }
+    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 = (0, _dtableUtils.getTableColumnByKey)(table, numericSummaryColumnKey);
+  const columnGroupbyMultipleNumericColumn = true;
+  return getGroupChartStatResult(table, value, groupbyColumn, numericSummaryColumnKey, rows, formulaRows, includeEmpty, groupbyDateGranularity, groupbyGeolocationGranularity, columnGroupbyDateGranularity, columnGroupbyGeolocationGranularity, summaryColumn, summaryType, summaryMethod, columnGroupbyMultipleNumericColumn, yAxisType);
+}
+async function calculateGeolocationBasicChart(chart, value, _ref4) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref4;
+  const {
+    type,
+    table_id,
+    view_id,
+    geo_column,
+    summary_type,
+    summary_column,
+    summary_method
+  } = chart;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) {
+    return;
+  }
+  const geoColumn = geo_column && (0, _dtableUtils.getTableColumnByKey)(table, geo_column);
+  if (!geoColumn) {
+    return;
+  }
+  let geolocationGranularity = null;
+  if (type && type.includes('world')) {
+    geolocationGranularity = geoColumn.type === _dtableUtils.CellType.GEOLOCATION ? chart.geolocation_granularity : null;
+  } else {
+    geolocationGranularity = (0, _map.fixMapGeoGranularity)(chart);
+  }
+  const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column);
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  const geoColumnType = geoColumn.type;
+  let results = [];
+  statRows.forEach(row => {
+    const {
+      _id: rowId
+    } = row;
+    const formulaRow = formulaRows[rowId];
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, geoColumn, false)) {
+      if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[geoColumnType]) {
+        const list = formulaRow[geoColumn.key];
+        list.forEach(n => {
+          const nameIndex = results.findIndex(r => {
+            if (geolocationGranularity) {
+              return n[geolocationGranularity] === r.name;
+            }
+            return n = r.name;
+          });
+          if (geolocationGranularity) {
+            updateBasicChartRows(results, nameIndex, n[geolocationGranularity], row, null);
+          } else {
+            updateBasicChartRows(results, nameIndex, n, row, null);
+          }
+        });
+      } else {
+        let name = row[geoColumn.key] || null;
+        if (name && geolocationGranularity) {
+          name = name[geolocationGranularity];
+        }
+        const nameIndex = results.findIndex(r => r.name === name);
+        updateBasicChartRows(results, nameIndex, name, row, null);
+      }
+    }
+  });
+  updateChartValue(summaryColumn, summary_type, summary_method, formulaRows, results);
+  return results;
+}
+async function calculateCustomBar(statItem, value, _ref5) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref5;
+  const {
+    table_id,
+    view_id,
+    x_axis_column_key,
+    x_axis_date_granularity,
+    x_axis_geolocation_granularity,
+    x_axis_include_empty,
+    y_axises
+  } = statItem;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view || !x_axis_column_key || !Array.isArray(y_axises) || y_axises.length === 0) {
+    return [];
+  }
+  const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, x_axis_column_key);
+  if (!groupbyColumn) {
+    return [];
+  }
+  const {
+    type: groupbyColumnType
+  } = groupbyColumn;
+  let groupbyDateGranularity = x_axis_date_granularity;
+  let groupbyGeolocationGranularity = x_axis_geolocation_granularity;
+  if (_dtableUtils.DATE_COLUMN_OPTIONS.includes(groupbyColumnType) && !groupbyDateGranularity) {
+    groupbyDateGranularity = _constants.STATISTICS_COUNT_TYPE.MONTH;
+  }
+  if (groupbyColumnType === _dtableUtils.CellType.GEOLOCATION && !groupbyGeolocationGranularity) {
+    groupbyGeolocationGranularity = _constants.STATISTICS_COUNT_TYPE.PROVINCE;
+  }
+  const columnGroupbyDateGranularity = null;
+  const columnGroupbyGeolocationGranularity = null;
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  let results = [];
+  y_axises.forEach((yAxis, index) => {
+    const {
+      type: yAxisType,
+      column_groupby_numeric_columns
+    } = yAxis;
+    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(_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, _constants.STATISTICS_COUNT_TYPE.ADVANCED, summary_method, yAxisType, table, value);
+        results = results.concat(currentResults);
+      });
+    }
+  });
+  _statUtils.default.sortStatistics(results, groupbyColumn, 'name');
+  results = results.map(result => {
+    return {
+      ...result,
+      name: (0, _rowUtils.getFormattedLabel)(groupbyColumn, result.name, value.collaborators)
+    };
+  });
+  return results;
+}
+var _default = exports.default = calculateChart;

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

@@ -0,0 +1,44 @@
+"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 = {
+  [_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, getViewRows, getTableFormulaResults) {
+  const type = chart.type;
+  const calculatorWorker = typeCalculatorWorkerMap[type] || typeCalculatorWorkerMap[BASIC_CHART];
+  return calculatorWorker(chart, value, {
+    getViewRows,
+    getTableFormulaResults
+  });
+}
+(0, _comlink.expose)(calculator);

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dtableUtils = require("dtable-utils");
+var _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
+async function calculateResult(chart, dtableValue, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    numeric_column,
+    summary_method
+  } = chart;
+  const selectedTable = (0, _dtableUtils.getTableById)(dtableValue.tables, table_id);
+  const selectedView = selectedTable && (0, _dtableUtils.getViewById)(selectedTable.views, view_id);
+  const selectedColumn = (0, _dtableUtils.getTableColumnByKey)(selectedTable, numeric_column);
+  const _isNumericColumn = selectedColumn && (0, _dtableUtils.isNumericColumn)(selectedColumn);
+  const statRows = await getViewRows(selectedView, selectedTable);
+  const formulaRows = _isNumericColumn ? await getTableFormulaResults(selectedTable, statRows) : {};
+  const numberList = [];
+  _isNumericColumn && statRows.forEach(row => {
+    const formulaRow = formulaRows[row._id];
+    const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, selectedColumn);
+    if ((0, _dtableUtils.isNumber)(cellValue)) {
+      numberList.push(cellValue);
+    }
+  });
+  if (summary_method === 'Row_count') {
+    return statRows.length;
+  }
+  return (0, _commonUtils.getSummaryResult)(numberList, summary_method);
+}
+var _default = exports.default = calculateResult;