dtable-statistic 4.4.24-alpha.9 → 5.0.0

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

@@ -0,0 +1,276 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = calculateResult;
+var _dtableUtils = require("dtable-utils");
+var _statUtils = _interopRequireDefault(require("../../utils/stat-utils"));
+var _commonUtils = require("../../utils/common-utils");
+var _constants = require("../../constants");
+var _rowUtils = require("../../utils/row-utils");
+async function calculateResult(chart, value, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    x_axis_column_key,
+    x_axis_include_empty,
+    x_axis_date_granularity: groupby_date_granularity,
+    x_axis_geolocation_granularity: groupby_geolocation_granularity,
+    y_axis_left_summary_column,
+    y_axis_right_summary_column,
+    y_axis_left_summary_type,
+    y_axis_right_summary_type,
+    y_axis_left_summary_method,
+    y_axis_right_summary_method,
+    y_axis_left_group_by_multiple_numeric_column,
+    y_axis_left_group_by_numeric_columns
+  } = chart;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) {
+    return [];
+  }
+  const xAxisColumn = (0, _dtableUtils.getTableColumnByKey)(table, x_axis_column_key);
+  if (!xAxisColumn) return [];
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  const column1 = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_left_summary_column);
+  const column2 = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_right_summary_column);
+  const leftResultMap = new Map();
+  const rightResultMap = new Map();
+  let isColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(xAxisColumn);
+  let leftSummaryColumn = {};
+  let leftSummaryColumnKeys = [];
+  if (y_axis_left_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+    if (column1) {
+      leftSummaryColumn[y_axis_left_summary_column] = {
+        method: y_axis_left_summary_method,
+        column_name: column1.name,
+        type: column1.type,
+        data: column1.data,
+        color: _constants.LABEL_COLORS[0]
+      };
+    }
+    if (y_axis_left_group_by_multiple_numeric_column) {
+      y_axis_left_group_by_numeric_columns.forEach((item, index) => {
+        const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, item.column_key);
+        if (summaryColumn) {
+          leftSummaryColumn[item.column_key] = {
+            method: item.summary_method,
+            column_name: summaryColumn.name,
+            type: summaryColumn.type,
+            data: summaryColumn.data,
+            color: _constants.LABEL_COLORS[(index + 1) % 12]
+          };
+        }
+      });
+    }
+    leftSummaryColumnKeys = Object.keys(leftSummaryColumn);
+  }
+  statRows.forEach(row => {
+    let {
+      _id: rowId
+    } = row;
+    let formulaRow = formulaRows[rowId];
+    const currentValue = row[xAxisColumn.key];
+    let label = _statUtils.default.getGroupLabel(currentValue, formulaRow, xAxisColumn, groupby_date_granularity, groupby_geolocation_granularity, value);
+
+    // collect left y axis data
+    if (y_axis_left_summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      if (isColumnDataAsAnArray) {
+        if (label.length > 0) {
+          label.forEach(name => {
+            let currentValue = leftResultMap.get(name) || 0;
+            currentValue = currentValue + 1;
+            leftResultMap.set(name, currentValue);
+          });
+        }
+        if (label.length === 0 && x_axis_include_empty) {
+          let currentValue = leftResultMap.get(null) || 0;
+          currentValue += 1;
+          leftResultMap.set(null, currentValue);
+        }
+      } else {
+        if (x_axis_include_empty || label) {
+          let currentLabelCount = leftResultMap.get(label) || 0;
+          currentLabelCount = currentLabelCount + 1;
+          leftResultMap.set(label, currentLabelCount);
+        }
+      }
+    }
+    if (y_axis_left_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+      if (isColumnDataAsAnArray) {
+        if (label.length > 0) {
+          label.forEach(name => {
+            const currentLabelMap = leftResultMap.get(name) || {};
+            leftSummaryColumnKeys.forEach(key => {
+              const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, {
+                ...leftSummaryColumn[key],
+                key
+              });
+              const currentLabelList = currentLabelMap[key] || [];
+              if ((0, _dtableUtils.isNumber)(cellValue)) {
+                currentLabelList.push(cellValue);
+              }
+              currentLabelMap[key] = currentLabelList;
+            });
+            leftResultMap.set(name, currentLabelMap);
+          });
+        }
+        if (label.length === 0 && x_axis_include_empty) {
+          let currentValue = leftResultMap.get(null) || {};
+          leftSummaryColumnKeys.forEach(key => {
+            const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, {
+              ...leftSummaryColumn[key],
+              key
+            });
+            const currentLabelList = currentValue[key] || [];
+            if ((0, _dtableUtils.isNumber)(cellValue)) {
+              currentLabelList.push(cellValue);
+            }
+            currentValue[key] = currentLabelList;
+          });
+          leftResultMap.set(null, currentValue);
+        }
+      } else {
+        if (x_axis_include_empty || label) {
+          const currentValue = leftResultMap.get(label) || {};
+          leftSummaryColumnKeys.forEach(key => {
+            const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, {
+              ...leftSummaryColumn[key],
+              key
+            });
+            const currentList = currentValue[key] || [];
+            if ((0, _dtableUtils.isNumber)(cellValue)) {
+              currentList.push(cellValue);
+            }
+            currentValue[key] = currentList;
+          });
+          leftResultMap.set(label, currentValue);
+        }
+      }
+    }
+
+    // collect right y axis data
+    if (y_axis_right_summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      if (isColumnDataAsAnArray) {
+        if (label.length > 0) {
+          label.forEach(name => {
+            let currentValue = rightResultMap.get(name) || 0;
+            currentValue = currentValue + 1;
+            rightResultMap.set(name, currentValue);
+          });
+        }
+        if (label.length === 0 && x_axis_include_empty) {
+          let currentValue = rightResultMap.get(null) || 0;
+          currentValue += 1;
+          rightResultMap.set(null, currentValue);
+        }
+      } else {
+        if (x_axis_include_empty || label) {
+          let currentLabelCount = rightResultMap.get(label) || 0;
+          currentLabelCount = currentLabelCount + 1;
+          rightResultMap.set(label, currentLabelCount);
+        }
+      }
+    }
+    if (y_axis_right_summary_column && y_axis_right_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+      const cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, column2);
+      if (isColumnDataAsAnArray) {
+        if (label.length > 0) {
+          label.forEach(name => {
+            const currentLabelList = rightResultMap.get(name) || [];
+            if ((0, _dtableUtils.isNumber)(cellValue)) {
+              currentLabelList.push(cellValue);
+            }
+            rightResultMap.set(name, currentLabelList);
+          });
+        }
+        if (label.length === 0 && x_axis_include_empty) {
+          let currentValue = rightResultMap.get(null) || [];
+          if ((0, _dtableUtils.isNumber)(cellValue)) {
+            currentValue.push(cellValue);
+          }
+          rightResultMap.set(null, currentValue);
+        }
+      } else {
+        if (x_axis_include_empty || label) {
+          const currentLabelList = rightResultMap.get(label) || [];
+          if ((0, _dtableUtils.isNumber)(cellValue)) {
+            currentLabelList.push(cellValue);
+          }
+          rightResultMap.set(label, currentLabelList);
+        }
+      }
+    }
+  });
+
+  // Summary collect data
+  let results = [];
+  let targetMap = leftResultMap;
+  if (leftSummaryColumnKeys.length === 0 && y_axis_left_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+    targetMap = rightResultMap;
+  }
+  for (let item of targetMap) {
+    const key = item[0];
+    const leftValue = item[1];
+    let value1 = 0;
+    let value2 = 0;
+    let formattedValueLeft = value1;
+    let formattedValueRight = value2;
+    const rightValue = rightResultMap.get(key);
+    if (y_axis_right_summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      value2 = rightValue;
+      formattedValueRight = value2;
+    }
+    if (y_axis_right_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+      value2 = (0, _commonUtils.getSummaryResult)(rightValue, y_axis_right_summary_method);
+      formattedValueRight = _statUtils.default.getFormattedValue(value2, column2, y_axis_right_summary_method);
+    }
+    if (!y_axis_left_group_by_multiple_numeric_column) {
+      if (y_axis_left_summary_type === _constants.SUMMARY_TYPE.COUNT) {
+        value1 = leftValue;
+        formattedValueLeft = value1;
+      }
+      if (y_axis_left_summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+        const list = leftValue[column1.key];
+        value1 = (0, _commonUtils.getSummaryResult)(list, y_axis_left_summary_method);
+        formattedValueLeft = _statUtils.default.getFormattedValue(value1, column1, y_axis_left_summary_method);
+      }
+      results.push({
+        name: key,
+        value_left: value1,
+        value_right: value2,
+        formatted_value_left: formattedValueLeft,
+        formatted_value_right: formattedValueRight
+      });
+    } else {
+      leftSummaryColumnKeys.forEach(columnKey => {
+        const summaryColumn = leftSummaryColumn[columnKey];
+        const summaryMethod = summaryColumn.method;
+        const list = leftValue[columnKey];
+        const value = (0, _commonUtils.getSummaryResult)(list, summaryMethod);
+        formattedValueLeft = _statUtils.default.getFormattedValue(value, summaryColumn, summaryMethod);
+        results.push({
+          name: key,
+          value_left: value,
+          color: leftSummaryColumn[columnKey].color,
+          value_right: value2,
+          formatted_value_left: formattedValueLeft,
+          formatted_value_right: formattedValueRight
+        });
+      });
+    }
+  }
+  _statUtils.default.sortStatistics(results, xAxisColumn, 'name');
+  results.forEach(item => {
+    item.name = (0, _rowUtils.getFormattedLabel)(xAxisColumn, item.name, value.collaborators);
+  });
+  return results;
+}

package/es/calculator/workers/compare-bar-chart-calculator-worker.js

@@ -0,0 +1,150 @@
+"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 _statUtils = _interopRequireDefault(require("../../utils/stat-utils"));
+var _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
+var _constants = require("../../constants");
+async function calculateChart(chart, value, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    x_axis_column_key,
+    y_axis_summary_type,
+    y_axis_summary_method,
+    y_axis_column_key,
+    x_axis_date_granularity,
+    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 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);
+  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) {
+    return [];
+  }
+  const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, x_axis_column_key);
+  if (!groupbyColumn) {
+    return [];
+  }
+  const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_column_key) || {};
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  const dateRangeResultMap = new Map();
+  const comparedDateRangeResultMap = new Map();
+  const isAdvance = y_axis_summary_type === _constants.SUMMARY_TYPE.ADVANCED;
+  statRows.forEach(row => {
+    const {
+      _id: rowId
+    } = row;
+    const cellValue = row[groupbyColumn.key];
+    const formulaRow = formulaRows[rowId];
+    if (!cellValue) return;
+    if (cellValue >= x_axis_date_range_start && cellValue <= x_axis_date_range_end || cellValue >= x_axis_compared_date_range_start && cellValue <= x_axis_compared_date_range_end) {
+      const name = _statUtils.default.getGroupLabel(cellValue, formulaRow, groupbyColumn, x_axis_date_granularity, '', value);
+      if (cellValue >= x_axis_date_range_start && cellValue <= x_axis_date_range_end) {
+        if (isAdvance) {
+          const currentValue = dateRangeResultMap.get(name);
+          const _cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, summaryColumn);
+          if (!currentValue) {
+            dateRangeResultMap.set(name, [_cellValue]);
+          } else {
+            currentValue.push(_cellValue);
+          }
+        } else {
+          const currentValue = dateRangeResultMap.get(name);
+          if (!currentValue) {
+            dateRangeResultMap.set(name, 1);
+          } else {
+            dateRangeResultMap.set(name, currentValue + 1);
+          }
+        }
+      } else {
+        if (isAdvance) {
+          const currentValue = comparedDateRangeResultMap.get(name);
+          const _cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, summaryColumn);
+          if (!currentValue && summaryColumn) {
+            comparedDateRangeResultMap.set(name, [_cellValue]);
+          } else {
+            currentValue.push(_cellValue);
+          }
+        } else {
+          const currentValue = comparedDateRangeResultMap.get(name);
+          if (!currentValue) {
+            comparedDateRangeResultMap.set(name, 1);
+          } else {
+            comparedDateRangeResultMap.set(name, currentValue + 1);
+          }
+        }
+      }
+    }
+  });
+  let dateRangeResult = [];
+  let comparedDateRangeResult = [];
+  const data = summaryColumn.data || {};
+  for (let item of dateRangeResultMap) {
+    const key = item[0];
+    let value = item[1];
+    let formatted_value = value;
+    if (isAdvance) {
+      value = (0, _commonUtils.getSummaryResult)(value, y_axis_summary_method, data.precision);
+      formatted_value = _statUtils.default.getFormattedValue(value, summaryColumn, y_axis_summary_method);
+    }
+    dateRangeResult.push({
+      name: key,
+      group_name: groupName1,
+      raw_name: key,
+      value,
+      formatted_value
+    });
+  }
+  _statUtils.default.sortStatistics(dateRangeResult, groupbyColumn, 'name');
+  for (let item of comparedDateRangeResultMap) {
+    const key = item[0];
+    let value = item[1];
+    let formatted_value = value;
+    if (isAdvance) {
+      value = (0, _commonUtils.getSummaryResult)(value, y_axis_summary_method, data.precision);
+      formatted_value = _statUtils.default.getFormattedValue(value, summaryColumn, y_axis_summary_method);
+    }
+    comparedDateRangeResult.push({
+      name: key,
+      group_name: groupName2,
+      raw_name: key,
+      value,
+      formatted_value
+    });
+  }
+  _statUtils.default.sortStatistics(comparedDateRangeResult, groupbyColumn, 'name');
+  for (let i = 0; i < dateRangeResult.length; i++) {
+    if (!comparedDateRangeResult[i]) break;
+    comparedDateRangeResult[i].name = dateRangeResult[i].name;
+    if (display_increase) {
+      const value1 = dateRangeResult[i].value;
+      const value2 = comparedDateRangeResult[i].value || 0.001;
+      if (!value2) {
+        comparedDateRangeResult[i].increase_value = 1;
+      } else {
+        comparedDateRangeResult[i].increase_value = Number(((value1 - value2) / value2).toFixed(2));
+      }
+    }
+  }
+  if (comparedDateRangeResult.length > dateRangeResult.length) {
+    comparedDateRangeResult = comparedDateRangeResult.slice(0, dateRangeResult.length);
+  }
+  return [...comparedDateRangeResult, ...dateRangeResult];
+}
+var _default = exports.default = calculateChart;

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

@@ -0,0 +1,208 @@
+"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 _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
+var _statUtils = _interopRequireDefault(require("../../utils/stat-utils"));
+var _constants = require("../../constants");
+async function calculateResult(chart, value, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    name_column,
+    completed_column,
+    target_column,
+    group_column,
+    date_granularity,
+    geolocation_granularity
+  } = chart;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) {
+    return [];
+  }
+  const nameColumn = (0, _dtableUtils.getTableColumnByKey)(table, name_column);
+  if (!nameColumn) return [];
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  const groupColumn = (0, _dtableUtils.getTableColumnByKey)(table, group_column);
+  const isColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(nameColumn);
+  const isGroupChart = !!groupColumn;
+  let result = [];
+  if (!isGroupChart) {
+    const completedColumn = (0, _dtableUtils.getTableColumnByKey)(table, completed_column);
+    const targetColumn = (0, _dtableUtils.getTableColumnByKey)(table, target_column);
+    let labelCountMap = {};
+    let labels = [];
+    statRows.forEach(row => {
+      let {
+        _id: rowId
+      } = row;
+      let formulaRow = formulaRows[rowId] || {};
+      const name = row[nameColumn.key];
+      if (name || Number.isFinite(name)) {
+        let label = _statUtils.default.getGroupLabel(name, formulaRow, nameColumn, '', '', value);
+        if (isColumnDataAsAnArray) {
+          label = label[0];
+        }
+        label = (0, _rowUtils.getFormattedLabel)(nameColumn, label, value.collaborators);
+        let currentValue = (0, _rowUtils.getCellValue)(row, formulaRow, completedColumn);
+        let targetValue = (0, _rowUtils.getCellValue)(row, formulaRow, targetColumn);
+        currentValue = (0, _dtableUtils.isNumber)(currentValue) ? currentValue : 0;
+        targetValue = (0, _dtableUtils.isNumber)(targetValue) ? targetValue : 0;
+        if (labelCountMap[label]) {
+          labelCountMap[label].currentValue = currentValue + labelCountMap[label].currentValue;
+          labelCountMap[label].targetValue = targetValue + labelCountMap[label].targetValue;
+        } else {
+          labelCountMap[label] = {
+            currentValue,
+            targetValue
+          };
+          labels.push(label);
+        }
+      }
+    });
+    labels.forEach(label => {
+      if (labelCountMap[label]) {
+        const {
+          currentValue,
+          targetValue
+        } = labelCountMap[label];
+        if (currentValue < targetValue) {
+          result.unshift({
+            name: label,
+            value: currentValue,
+            type: 'completed',
+            current_value: currentValue,
+            target_value: targetValue
+          }, {
+            name: label,
+            value: targetValue - currentValue,
+            type: 'uncompleted',
+            current_value: currentValue,
+            target_value: targetValue
+          });
+        } else {
+          result.unshift({
+            name: label,
+            value: currentValue,
+            type: 'completed',
+            current_value: currentValue,
+            target_value: targetValue
+          });
+        }
+      }
+    });
+  } else {
+    const completedColumn = (0, _dtableUtils.getTableColumnByKey)(table, completed_column);
+    const targetColumn = (0, _dtableUtils.getTableColumnByKey)(table, target_column);
+    let labelCountMap = {};
+    let colorMap = {};
+    let labelGroups = [];
+    let colorIndex = 0;
+    let isFormulaType = _dtableUtils.FORMULA_COLUMN_TYPES_MAP[groupColumn.type];
+    const isGroupColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupColumn);
+    statRows.forEach(row => {
+      let {
+        _id: rowId
+      } = row;
+      let formulaRow = formulaRows[rowId] || {};
+      const name = row[nameColumn.key],
+        groupLabelName = !isFormulaType ? row[groupColumn.key] : formulaRow[rowId][groupColumn.key];
+      if ((name || Number.isFinite(name)) && (groupLabelName || Number.isFinite(groupLabelName))) {
+        let label = _statUtils.default.getGroupLabel(name, formulaRow, nameColumn, '', '', value),
+          groupLabel = _statUtils.default.getGroupLabel(groupLabelName, formulaRow, groupColumn, date_granularity, geolocation_granularity, value);
+        if (isColumnDataAsAnArray) {
+          label = label[0];
+        }
+        if (isGroupColumnDataAsAnArray) {
+          groupLabel = groupLabel[0];
+        }
+        label = (0, _rowUtils.getFormattedLabel)(nameColumn, label, value.collaborators);
+        groupLabel = (0, _rowUtils.getFormattedLabel)(groupColumn, groupLabel, value.collaborators);
+        let color = colorMap[groupLabel];
+        if (!color) {
+          color = _constants.PIE_CHART_COLORS[colorIndex % 12];
+          colorMap[groupLabel] = color;
+          colorIndex++;
+        }
+        if (groupLabel) {
+          let currentValue = (0, _rowUtils.getCellValue)(row, formulaRow, completedColumn);
+          let targetValue = (0, _rowUtils.getCellValue)(row, formulaRow, targetColumn);
+          currentValue = (0, _dtableUtils.isNumber)(currentValue) ? currentValue : 0;
+          targetValue = (0, _dtableUtils.isNumber)(targetValue) ? targetValue : 0;
+          const concatLabel = "".concat(label, "_").concat(groupLabel);
+          if (labelCountMap[concatLabel]) {
+            labelCountMap[concatLabel].currentValue = currentValue + labelCountMap[concatLabel].currentValue;
+            labelCountMap[concatLabel].targetValue = targetValue + labelCountMap[concatLabel].targetValue;
+          } else {
+            labelCountMap[concatLabel] = {
+              currentValue,
+              targetValue
+            };
+            labelGroups.push({
+              key: concatLabel,
+              label,
+              groupLabel
+            });
+          }
+        }
+      }
+    });
+    labelGroups.forEach(labelGroup => {
+      const {
+        key,
+        label,
+        groupLabel
+      } = labelGroup;
+      if (labelCountMap[key]) {
+        const color = colorMap[groupLabel];
+        const {
+          currentValue,
+          targetValue
+        } = labelCountMap[key];
+        if (currentValue < targetValue) {
+          result.unshift({
+            name: label,
+            group_label: groupLabel,
+            value: currentValue,
+            color,
+            type: 'completed',
+            current_value: currentValue,
+            target_value: targetValue
+          }, {
+            name: label,
+            group_label: groupLabel,
+            value: targetValue - currentValue,
+            color,
+            type: 'uncompleted',
+            current_value: currentValue,
+            target_value: targetValue
+          });
+        } else {
+          result.unshift({
+            name: label,
+            group_label: groupLabel,
+            value: currentValue,
+            color,
+            type: 'completed',
+            current_value: currentValue,
+            target_value: targetValue
+          });
+        }
+      }
+    });
+    result.colorMap = colorMap;
+  }
+  return result;
+}
+var _default = exports.default = calculateResult;

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

@@ -0,0 +1,68 @@
+"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, value, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    table_id,
+    view_id,
+    target_value_column,
+    target_value_column_summary_method,
+    total_value_column,
+    total_value_column_summary_method
+  } = chart;
+  const selectedTable = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const selectedView = selectedTable && (0, _dtableUtils.getViewById)(selectedTable.views, view_id);
+  const selectedColumn1 = (0, _dtableUtils.getTableColumnByKey)(selectedTable, target_value_column);
+  const selectedColumn2 = (0, _dtableUtils.getTableColumnByKey)(selectedTable, total_value_column);
+  const statRows = await getViewRows(selectedView, selectedTable);
+  if (statRows.length === 0) {
+    return 0;
+  }
+  const isNumericColumn1 = selectedColumn1 && (0, _dtableUtils.isNumericColumn)(selectedColumn1);
+  const isNumericColumn2 = selectedColumn2 && (0, _dtableUtils.isNumericColumn)(selectedColumn2);
+  const formulaRows = isNumericColumn1 || isNumericColumn2 ? await getTableFormulaResults(selectedTable, statRows) : {};
+  let result1;
+  let result2;
+  let numberList1 = [];
+  let numberList2 = [];
+  statRows.forEach(row => {
+    const formulaRow = formulaRows[row._id];
+    if (isNumericColumn1) {
+      const cellValue1 = (0, _rowUtils.getCellValue)(row, formulaRow, selectedColumn1);
+      if ((0, _dtableUtils.isNumber)(cellValue1)) {
+        numberList1.push(cellValue1);
+      }
+    }
+    if (isNumericColumn2) {
+      const cellValue2 = (0, _rowUtils.getCellValue)(row, formulaRow, selectedColumn2);
+      if ((0, _dtableUtils.isNumber)(cellValue2)) {
+        numberList2.push(cellValue2);
+      }
+    }
+  });
+  if (target_value_column_summary_method === 'Row_count') {
+    result1 = statRows.length;
+  } else {
+    result1 = (0, _commonUtils.getSummaryResult)(numberList1, target_value_column_summary_method);
+  }
+  if (total_value_column_summary_method === 'Row_count') {
+    result2 = statRows.length;
+  } else {
+    result2 = (0, _commonUtils.getSummaryResult)(numberList2, total_value_column_summary_method);
+  }
+  if (result2 === 0) {
+    return 0;
+  }
+  return result1 / result2;
+}
+var _default = exports.default = calculateResult;