sea-chart 2.0.38 → 2.0.39

package/dist/utils/chart-utils/original-data-utils/index.js

@@ -1,52 +1,59 @@
+"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 _baseUtils = _interopRequireDefault(require("../base-utils"));
+var _context = _interopRequireDefault(require("../../../context"));
+var _ = require("../..");
+var _pivotTableCalculator = _interopRequireDefault(require("./pivot-table-calculator"));
+var _basicChartCalculator = _interopRequireDefault(require("./basic-chart-calculator"));
+var _compareBarChartCalculator = _interopRequireDefault(require("./compare-bar-chart-calculator"));
+var _completenessCalculator = _interopRequireDefault(require("./completeness-calculator"));
+var _combinationCalculator = _interopRequireDefault(require("./combination-calculator"));
+var _scatterCalculator = _interopRequireDefault(require("./scatter-calculator"));
+var _mirrorCalculator = _interopRequireDefault(require("./mirror-calculator"));
+var _cardCalculator = _interopRequireDefault(require("./card-calculator"));
+var _trendCalculator = _interopRequireDefault(require("./trend-calculator"));
+var _dashboardCalculator = _interopRequireDefault(require("./dashboard-calculator"));
 var _OriginalDataUtils;
-import { getTableById, getViewById } from 'dtable-utils';
-import { CHART_TYPE, SUPPORT_DATA_SORT_CHART_TYPES } from '../../../constants';
-import BaseUtils from '../base-utils';
-import context from '../../../context';
-import { getErrorMessage } from '../..';
-import PivotTableCalculator from './pivot-table-calculator';
-import BasicChartCalculator from './basic-chart-calculator';
-import CompareBarCalculator from './compare-bar-chart-calculator';
-import CompletenessCalculator from './completeness-calculator';
-import CombinationCalculator from './combination-calculator';
-import ScatterCalculator from './scatter-calculator';
-import MirrorCalculator from './mirror-calculator';
-import CardCalculator from './card-calculator';
-import TrendCalculator from './trend-calculator';
-import DashboardCalculator from './dashboard-calculator';
 const BASIC_CHART = 'basic_chart';
 const calculatorMap = {
-  [CHART_TYPE.TABLE]: PivotTableCalculator,
-  [BASIC_CHART]: BasicChartCalculator,
-  [CHART_TYPE.COMPARE_BAR]: CompareBarCalculator,
-  [CHART_TYPE.HORIZONTAL_BAR]: BasicChartCalculator,
-  [CHART_TYPE.HORIZONTAL_GROUP_BAR]: BasicChartCalculator,
-  [CHART_TYPE.STACKED_HORIZONTAL_BAR]: BasicChartCalculator,
-  [CHART_TYPE.COMPLETENESS]: CompletenessCalculator,
-  [CHART_TYPE.COMPLETENESS_GROUP]: CompletenessCalculator,
-  [CHART_TYPE.SCATTER]: ScatterCalculator,
-  [CHART_TYPE.COMBINATION]: CombinationCalculator,
-  [CHART_TYPE.MAP]: BasicChartCalculator,
-  [CHART_TYPE.WORLD_MAP]: BasicChartCalculator,
-  [CHART_TYPE.HEAT_MAP]: BasicChartCalculator,
-  [CHART_TYPE.MIRROR]: MirrorCalculator,
-  [CHART_TYPE.BASIC_NUMBER_CARD]: CardCalculator,
-  [CHART_TYPE.TREND]: TrendCalculator,
-  [CHART_TYPE.DASHBOARD]: DashboardCalculator,
-  [CHART_TYPE.FUNNEL]: BasicChartCalculator
+  [_constants.CHART_TYPE.TABLE]: _pivotTableCalculator.default,
+  [BASIC_CHART]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.COMPARE_BAR]: _compareBarChartCalculator.default,
+  [_constants.CHART_TYPE.HORIZONTAL_BAR]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.HORIZONTAL_GROUP_BAR]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.STACKED_HORIZONTAL_BAR]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.COMPLETENESS]: _completenessCalculator.default,
+  [_constants.CHART_TYPE.COMPLETENESS_GROUP]: _completenessCalculator.default,
+  [_constants.CHART_TYPE.SCATTER]: _scatterCalculator.default,
+  [_constants.CHART_TYPE.COMBINATION]: _combinationCalculator.default,
+  [_constants.CHART_TYPE.MAP]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.WORLD_MAP]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.HEAT_MAP]: _basicChartCalculator.default,
+  [_constants.CHART_TYPE.MIRROR]: _mirrorCalculator.default,
+  [_constants.CHART_TYPE.BASIC_NUMBER_CARD]: _cardCalculator.default,
+  [_constants.CHART_TYPE.TREND]: _trendCalculator.default,
+  [_constants.CHART_TYPE.DASHBOARD]: _dashboardCalculator.default,
+  [_constants.CHART_TYPE.FUNNEL]: _basicChartCalculator.default
 };
 class OriginalDataUtils {}
 _OriginalDataUtils = OriginalDataUtils;
 OriginalDataUtils.DATA_SOURCE = 'original_data';
 OriginalDataUtils.isValidExistChart = (tables, chart) => {
-  const isValid = BaseUtils.isValidExistChart(tables || [], chart);
+  const isValid = _baseUtils.default.isValidExistChart(tables || [], chart);
   if (!isValid) return false;
   const {
     view_id,
     table_id
   } = chart.config || {};
-  const table = getTableById(tables, table_id);
-  const view = getViewById(table.views, view_id);
+  const table = (0, _dtableUtils.getTableById)(tables, table_id);
+  const view = (0, _dtableUtils.getViewById)(table.views, view_id);
   if (!view) return false;
   return true;
 };
@@ -64,21 +71,21 @@ OriginalDataUtils.calculateChart = async (chart, value, callback, refreshCache)
       view_id,
       type
     } = config || {};
-    const table = getTableById(value.tables, table_id);
+    const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
     const calculator = calculatorMap[type] || calculatorMap[BASIC_CHART];
     const result = await calculator(config, value, {
       getViewRows: async (view, table) => {
-        const rows = await context.getViewRows(view, table, value, refreshCache);
+        const rows = await _context.default.getViewRows(view, table, value, refreshCache);
         return rows;
       },
       getTableFormulaResults: async (table, rows) => {
-        const res = await context.getTableFormulaResults(table, rows, value, view_id, refreshCache);
+        const res = await _context.default.getTableFormulaResults(table, rows, value, view_id, refreshCache);
         return res;
       }
     });
-    const groupbyColumn = BaseUtils.getGroupColumn(table, chart);
-    const columnGroupbyColumn = BaseUtils.getColumnGroupColumn(table, chart);
-    const summaryColumn = BaseUtils.getSummaryColumn(table, chart);
+    const groupbyColumn = _baseUtils.default.getGroupColumn(table, chart);
+    const columnGroupbyColumn = _baseUtils.default.getColumnGroupColumn(table, chart);
+    const summaryColumn = _baseUtils.default.getSummaryColumn(table, chart);
     const chartTableColumns = table.columns;
     return callback && callback('', '', {
       result,
@@ -90,7 +97,7 @@ OriginalDataUtils.calculateChart = async (chart, value, callback, refreshCache)
     });
   } catch (error) {
     console.log('Error', error);
-    const error_message = getErrorMessage(error);
+    const error_message = (0, _.getErrorMessage)(error);
     return callback && callback(error_message, '', null);
   }
 };
@@ -102,31 +109,31 @@ OriginalDataUtils.calculateStaticChart = (chart, value, statisticalResult, callb
   const {
     type
   } = config;
-  if (type === CHART_TYPE.TABLE) return callback && callback('', '', statisticalResult);
+  if (type === _constants.CHART_TYPE.TABLE) return callback && callback('', '', statisticalResult);
   const {
     table_id,
     sort_type
   } = config;
-  const table = getTableById(tables, table_id);
-  const groupbyColumn = BaseUtils.getGroupColumn(table, chart);
+  const table = (0, _dtableUtils.getTableById)(tables, table_id);
+  const groupbyColumn = _baseUtils.default.getGroupColumn(table, chart);
   let result = statisticalResult.result;
   if (!result) {
     const tip_message = 'There_are_no_statistic_results_yet';
     return callback && callback('', tip_message, null);
   }
-  if (SUPPORT_DATA_SORT_CHART_TYPES.includes(type) && sort_type) {
-    BaseUtils.sortChartData(result, sort_type);
+  if (_constants.SUPPORT_DATA_SORT_CHART_TYPES.includes(type) && sort_type) {
+    _baseUtils.default.sortChartData(result, sort_type);
     const newStatisticalResult = {
       ...statisticalResult,
       result
     };
     return callback && callback('', '', newStatisticalResult);
   }
-  BaseUtils.sortCharts(result, groupbyColumn, 'name');
+  _baseUtils.default.sortCharts(result, groupbyColumn, 'name');
   const newStatisticalResult = {
     ...statisticalResult,
     result
   };
   return callback && callback('', '', newStatisticalResult);
 };
-export default OriginalDataUtils;
+var _default = exports.default = OriginalDataUtils;

package/dist/utils/chart-utils/original-data-utils/mirror-calculator.js

@@ -1,15 +1,22 @@
-import { isNumber, getTableById, getViewById, getTableColumnByKey } from 'dtable-utils';
-import { getClientCellValueDisplayString } from '../../cell-format-utils';
-import BaseUtils from '../base-utils';
-import { getCellValue } from '../../row-utils';
-import { CHART_SUMMARY_TYPE } from '../../../constants';
+"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 _cellFormatUtils = require("../../cell-format-utils");
+var _baseUtils = _interopRequireDefault(require("../base-utils"));
+var _rowUtils = require("../../row-utils");
+var _constants = require("../../../constants");
 function summaryResult(result, summaryMethod, precision) {
   const newResult = {};
   Object.keys(result).forEach(groupId => {
     newResult[groupId] = {};
     Object.keys(result[groupId]).forEach(key => {
       const currentValue = result[groupId][key];
-      newResult[groupId][key] = BaseUtils.getSummaryResult(currentValue, summaryMethod, precision);
+      newResult[groupId][key] = _baseUtils.default.getSummaryResult(currentValue, summaryMethod, precision);
     });
   });
   return newResult;
@@ -24,8 +31,8 @@ function normalizeResult(result, groupColumn, summaryColumn, summaryType, summar
     Object.keys(result[groupId]).forEach(name => {
       const value = result[groupId][name];
       let formattedValue = value;
-      if (summaryType === CHART_SUMMARY_TYPE.ADVANCED) {
-        formattedValue = BaseUtils.getFormattedValue(value, summaryColumn, summaryMethod);
+      if (summaryType === _constants.CHART_SUMMARY_TYPE.ADVANCED) {
+        formattedValue = _baseUtils.default.getFormattedValue(value, summaryColumn, summaryMethod);
       }
       data.push({
         name,
@@ -67,23 +74,23 @@ async function calculator(chart, dtableValue, _ref) {
     summary_method,
     group_column_key
   } = chart;
-  const table = getTableById(dtableValue.tables, table_id);
-  const view = table && getViewById(table.views, view_id);
-  const columnItem = getTableColumnByKey(table, column_key);
+  const table = (0, _dtableUtils.getTableById)(dtableValue.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  const columnItem = (0, _dtableUtils.getTableColumnByKey)(table, column_key);
   const rows = await getViewRows(view, table);
   const formulaRows = await getTableFormulaResults(table, rows);
-  const groupColumn = getTableColumnByKey(table, group_column_key);
-  const numericColumn = summary_column_key && getTableColumnByKey(table, summary_column_key);
+  const groupColumn = (0, _dtableUtils.getTableColumnByKey)(table, group_column_key);
+  const numericColumn = summary_column_key && (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
   const groupItems = getGroupItems(rows, groupColumn);
   if (groupColumn.length === 0) return;
   let result = {};
   groupItems.forEach(groupValue => {
     result[groupValue] = {};
   });
-  if (summary_type === CHART_SUMMARY_TYPE.COUNT) {
+  if (summary_type === _constants.CHART_SUMMARY_TYPE.COUNT) {
     groupItems.forEach(groupItem => {
       rows.forEach(row => {
-        let value = getClientCellValueDisplayString(row, columnItem.type, columnItem.key, {
+        let value = (0, _cellFormatUtils.getClientCellValueDisplayString)(row, columnItem.type, columnItem.key, {
           collaborators: dtableValue.collaborators,
           data: columnItem.data,
           formulaRows
@@ -109,7 +116,7 @@ async function calculator(chart, dtableValue, _ref) {
   } else {
     groupItems.forEach(groupItem => {
       rows.forEach(row => {
-        let value = getClientCellValueDisplayString(row, columnItem.type, columnItem.key, {
+        let value = (0, _cellFormatUtils.getClientCellValueDisplayString)(row, columnItem.type, columnItem.key, {
           collaborators: dtableValue.collaborators,
           data: columnItem.data,
           formulaRows
@@ -119,8 +126,8 @@ async function calculator(chart, dtableValue, _ref) {
         if (groupItems.includes(groupValue)) {
           const list = result[groupItem][value];
           const formulaRow = formulaRows[row._id];
-          let cellValue = getCellValue(row, formulaRow, numericColumn);
-          cellValue = isNumber(cellValue) ? cellValue : 0;
+          let cellValue = (0, _rowUtils.getCellValue)(row, formulaRow, numericColumn);
+          cellValue = (0, _dtableUtils.isNumber)(cellValue) ? cellValue : 0;
           if (groupItem === groupValue) {
             if (!list) {
               result[groupItem][value] = [cellValue];
@@ -142,4 +149,4 @@ async function calculator(chart, dtableValue, _ref) {
   }
   return normalizeResult(result, groupColumn, numericColumn, summary_type, summary_method, rows);
 }
-export default calculator;
+var _default = exports.default = calculator;