dtable-statistic 4.2.2 → 4.3.0

package/es/stat-list/chart-preview.js

@@ -1,53 +1,44 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React, { Component } from 'react';
 import ReactDOM from 'react-dom';
 import html2canvas from 'html2canvas';
 import StatView from '../stat-view';
 import StatisticDropdownMenu from '../components/dropdown-menu/statistic-dropdown-menu';
 import { STAT_TYPE } from '../constants';
-var ChartPreview = /*#__PURE__*/function (_Component) {
-  _inherits(ChartPreview, _Component);
-  var _super = _createSuper(ChartPreview);
-  function ChartPreview() {
-    var _this;
-    _classCallCheck(this, ChartPreview);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _this.onToggleShowEnlarged = function (event) {
+class ChartPreview extends Component {
+  constructor() {
+    super(...arguments);
+    this.onToggleShowEnlarged = event => {
       if (event) {
         event.preventDefault();
         event.stopPropagation();
       }
-      _this.props.enlargeChart();
+      this.props.enlargeChart();
     };
-    _this.onExportChart = function (statItem) {
-      var exportContainerID = 'exported-chart-container';
-      var exportContainer = document.createElement('div');
+    this.onExportChart = statItem => {
+      const exportContainerID = 'exported-chart-container';
+      const exportContainer = document.createElement('div');
       exportContainer.setAttribute('id', exportContainerID);
 
       // for charts rendered with `<canvas>`
-      var id = statItem._id;
-      var originalElement = document.querySelector("#stat-item-".concat(id, " .statistic-chart-container > div"));
+      const {
+        _id: id
+      } = statItem;
+      const originalElement = document.querySelector("#stat-item-".concat(id, " .statistic-chart-container > div"));
       if (originalElement) {
-        var containerWidth = originalElement.scrollWidth + 15 * 2;
-        var containerHeight = originalElement.scrollHeight + 15 * 2;
+        const containerWidth = originalElement.scrollWidth + 15 * 2;
+        const containerHeight = originalElement.scrollHeight + 15 * 2;
         exportContainer.setAttribute('style', "width: ".concat(containerWidth, "px; height: ").concat(containerHeight, "px;"));
       }
       document.body.appendChild(exportContainer);
-      ReactDOM.render(_this.renderChart(statItem), exportContainer);
-      setTimeout(function () {
-        var ele = document.querySelector("#".concat(exportContainerID, " .statistic-chart-container"));
+      ReactDOM.render(this.renderChart(statItem), exportContainer);
+      setTimeout(() => {
+        const ele = document.querySelector("#".concat(exportContainerID, " .statistic-chart-container"));
         if (!ele) return;
         html2canvas(ele, {
           windowWidth: ele.scrollWidth,
           windowHeight: ele.scrollHeight
-        }).then(function (canvas) {
-          var eleA = document.createElement('a');
+        }).then(canvas => {
+          let eleA = document.createElement('a');
           eleA.href = canvas.toDataURL('image/png');
           eleA.download = "".concat(statItem.name || 'image', ".png");
           eleA.click();
@@ -55,29 +46,28 @@ var ChartPreview = /*#__PURE__*/function (_Component) {
         });
       }, 1000);
     };
-    _this.onNewTableDialogToggle = function () {
-      var statisticalResult = _this.chartView && _this.chartView.getStatData();
-      statisticalResult && _this.props.showNewTableDialog({
-        statisticalResult: statisticalResult
+    this.onNewTableDialogToggle = () => {
+      const statisticalResult = this.chartView && this.chartView.getStatData();
+      statisticalResult && this.props.showNewTableDialog({
+        statisticalResult
       });
     };
-    _this.onUpdateTableDialogToggle = function () {
-      var statisticalResult = _this.chartView && _this.chartView.getStatData();
-      statisticalResult && _this.props.showSelectTableDialog({
-        statisticalResult: statisticalResult
+    this.onUpdateTableDialogToggle = () => {
+      const statisticalResult = this.chartView && this.chartView.getStatData();
+      statisticalResult && this.props.showSelectTableDialog({
+        statisticalResult
       });
     };
-    _this.renderChart = function (statItem) {
-      var _this$props = _this.props,
-        dtableChangedTime = _this$props.dtableChangedTime,
-        chartCalculator = _this$props.chartCalculator,
-        theme = _this$props.theme,
-        colorThemeName = _this$props.colorThemeName,
-        eventBus = _this$props.eventBus;
+    this.renderChart = statItem => {
+      const {
+        dtableChangedTime,
+        chartCalculator,
+        theme,
+        colorThemeName,
+        eventBus
+      } = this.props;
       return /*#__PURE__*/React.createElement(StatView, {
-        ref: function ref(_ref) {
-          return _this.chartView = _ref;
-        },
+        ref: ref => this.chartView = ref,
         isPreview: true,
         isEnlarge: false,
         dtableChangedTime: dtableChangedTime,
@@ -86,60 +76,57 @@ var ChartPreview = /*#__PURE__*/function (_Component) {
         statItem: statItem,
         chartCalculator: chartCalculator,
         eventBus: eventBus,
-        getTableById: _this.props.getTableById,
-        queryMapJson: _this.props.queryMapJson,
-        toggleStatisticRecordsDialog: _this.props.toggleStatisticRecordsDialog
+        getTableById: this.props.getTableById,
+        queryMapJson: this.props.queryMapJson,
+        toggleStatisticRecordsDialog: this.props.toggleStatisticRecordsDialog
       });
     };
-    _this.moveChartToView = function (viewId) {
-      var statItem = _this.props.statItem;
-      _this.props.moveChartToView(statItem._id, viewId);
+    this.moveChartToView = viewId => {
+      const {
+        statItem
+      } = this.props;
+      this.props.moveChartToView(statItem._id, viewId);
     };
-    return _this;
   }
-  _createClass(ChartPreview, [{
-    key: "render",
-    value: function render() {
-      var _this2 = this;
-      var _this$props2 = this.props,
-        isTableReadOnly = _this$props2.isTableReadOnly,
-        statItem = _this$props2.statItem;
-      var statId = statItem._id,
-        statName = statItem.name,
-        type = statItem.type;
-      var showStatName = !(type === STAT_TYPE.BASIC_NUMBER_CARD || type === STAT_TYPE.DASHBOARD);
-      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
-        className: "statistic-chart-preview-header"
-      }, /*#__PURE__*/React.createElement("span", {
-        className: "statistic-chart-preview-name"
-      }, showStatName ? statName : ''), /*#__PURE__*/React.createElement("span", {
-        className: "statistic-chart-preview-operations"
-      }, /*#__PURE__*/React.createElement("span", {
-        className: "statistic-chart-preview-microscope",
-        onClick: this.onToggleShowEnlarged
-      }, /*#__PURE__*/React.createElement("i", {
-        className: "dtable-font dtable-icon-open"
-      })), /*#__PURE__*/React.createElement(StatisticDropdownMenu, {
-        isTableReadOnly: isTableReadOnly,
-        chartType: type,
-        getOtherStatistics: this.props.getOtherStatistics,
-        onExportChart: function onExportChart() {
-          return _this2.onExportChart(statItem);
-        },
-        editStatItem: this.props.onToggleEditChart.bind(this, statId),
-        copyStatItem: this.props.copyChart.bind(this, statId),
-        moveChartToView: this.moveChartToView,
-        deleteStatItem: this.props.deleteChart.bind(this, statId),
-        onNewTableDialogToggle: this.onNewTableDialogToggle,
-        onUpdateTableDialogToggle: this.onUpdateTableDialogToggle
-      }))), /*#__PURE__*/React.createElement("div", {
-        id: "stat-item-".concat(statItem._id),
-        className: "statistic-chart-preview-container"
-      }, this.renderChart(statItem)), /*#__PURE__*/React.createElement("div", {
-        className: "statistic-chart-preview-container-resize"
-      }));
-    }
-  }]);
-  return ChartPreview;
-}(Component);
+  render() {
+    const {
+      isTableReadOnly,
+      statItem
+    } = this.props;
+    const {
+      _id: statId,
+      name: statName,
+      type
+    } = statItem;
+    const showStatName = !(type === STAT_TYPE.BASIC_NUMBER_CARD || type === STAT_TYPE.DASHBOARD);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+      className: "statistic-chart-preview-header"
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "statistic-chart-preview-name"
+    }, showStatName ? statName : ''), /*#__PURE__*/React.createElement("span", {
+      className: "statistic-chart-preview-operations"
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "statistic-chart-preview-microscope",
+      onClick: this.onToggleShowEnlarged
+    }, /*#__PURE__*/React.createElement("i", {
+      className: "dtable-font dtable-icon-open"
+    })), /*#__PURE__*/React.createElement(StatisticDropdownMenu, {
+      isTableReadOnly: isTableReadOnly,
+      chartType: type,
+      getOtherStatistics: this.props.getOtherStatistics,
+      onExportChart: () => this.onExportChart(statItem),
+      editStatItem: this.props.onToggleEditChart.bind(this, statId),
+      copyStatItem: this.props.copyChart.bind(this, statId),
+      moveChartToView: this.moveChartToView,
+      deleteStatItem: this.props.deleteChart.bind(this, statId),
+      onNewTableDialogToggle: this.onNewTableDialogToggle,
+      onUpdateTableDialogToggle: this.onUpdateTableDialogToggle
+    }))), /*#__PURE__*/React.createElement("div", {
+      id: "stat-item-".concat(statItem._id),
+      className: "statistic-chart-preview-container"
+    }, this.renderChart(statItem)), /*#__PURE__*/React.createElement("div", {
+      className: "statistic-chart-preview-container-resize"
+    }));
+  }
+}
 export default ChartPreview;

package/es/stat-list/index.js

@@ -1,8 +1,3 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React, { Component } from 'react';
 import GridLayout, { WidthProvider } from 'react-grid-layout';
 import intl from 'react-intl-universal';
@@ -12,246 +7,243 @@ import EnlargeChartDialog from '../components/dialog/enlarged-chart-dialog';
 import TableSelectDialog from '../components/dialog/table-select-dialog';
 import { exportStatisticToTable, updateStatisticToTable } from '../utils/export-table-utils';
 import { CommonEventTypes, STAT_TYPE } from '../constants';
-var ReactGridLayout = WidthProvider(GridLayout);
-var StatList = /*#__PURE__*/function (_Component) {
-  _inherits(StatList, _Component);
-  var _super = _createSuper(StatList);
-  function StatList(props) {
-    var _this;
-    _classCallCheck(this, StatList);
-    _this = _super.call(this, props);
-    _this.getStatItemsLayout = function (statItems) {
-      return Array.isArray(statItems) ? statItems.map(function (chart) {
+const ReactGridLayout = WidthProvider(GridLayout);
+class StatList extends Component {
+  constructor(props) {
+    super(props);
+    this.getStatItemsLayout = statItems => {
+      return Array.isArray(statItems) ? statItems.map(chart => {
         // eslint-disable-next-line
         if (chart.layout.y == null) {
-          return _objectSpread(_objectSpread({}, chart.layout), {}, {
+          return {
+            ...chart.layout,
             y: Infinity
-          });
+          };
         }
         return chart.layout;
       }) : [];
     };
-    _this.editStatItem = function (id) {
-      _this.props.editStatItem(id);
+    this.editStatItem = id => {
+      this.props.editStatItem(id);
     };
-    _this.onLayoutChange = function (layout) {
-      _this.props.modifyDashboardLayout(layout);
+    this.onLayoutChange = layout => {
+      this.props.modifyDashboardLayout(layout);
     };
-    _this.enlargeChart = function (chartIndex) {
-      _this.setState({
+    this.enlargeChart = chartIndex => {
+      this.setState({
         enlargedChartIndex: chartIndex
       });
     };
-    _this.closeEnlargedChart = function (event) {
+    this.closeEnlargedChart = event => {
       if (event) {
         event.preventDefault();
         event.stopPropagation();
       }
-      _this.setState({
+      this.setState({
         enlargedChartIndex: -1
       });
     };
-    _this.showNewTableDialog = function (chartIndexExport2Table, statisticalResult) {
-      _this.statisticalResult4Export = statisticalResult;
-      _this.setState({
-        chartIndexExport2Table: chartIndexExport2Table
+    this.showNewTableDialog = (chartIndexExport2Table, statisticalResult) => {
+      this.statisticalResult4Export = statisticalResult;
+      this.setState({
+        chartIndexExport2Table
       });
     };
-    _this.exportChart2Table = function (tableName, chart) {
+    this.exportChart2Table = (tableName, chart) => {
       if (chart.type !== STAT_TYPE.PIVOT_TABLE) {
-        _this.statisticalResult4Export = null;
+        this.statisticalResult4Export = null;
         toaster.danger(intl.get('Failed_export_statistic_to_Table'));
-        _this.closeNewTableDialog();
+        this.closeNewTableDialog();
         return;
       }
-      _this.closeNewTableDialog();
-      if (!_this.statisticalResult4Export) {
+      this.closeNewTableDialog();
+      if (!this.statisticalResult4Export) {
         return;
       }
-      var _exportStatisticToTab = exportStatisticToTable({
-          statisticalResult: _this.statisticalResult4Export
-        }),
-        columns = _exportStatisticToTab.columns,
-        rows = _exportStatisticToTab.rows;
+      const {
+        columns,
+        rows
+      } = exportStatisticToTable({
+        statisticalResult: this.statisticalResult4Export
+      });
       if (window.app && window.app.onExportStatisticToTable) {
         window.app.onExportStatisticToTable({
-          tableName: tableName,
-          columns: columns,
-          rows: rows
+          tableName,
+          columns,
+          rows
         });
       }
-      _this.statisticalResult4Export = null;
-      _this.props.onCloseDashboard();
+      this.statisticalResult4Export = null;
+      this.props.onCloseDashboard();
     };
-    _this.closeNewTableDialog = function () {
-      _this.setState({
+    this.closeNewTableDialog = () => {
+      this.setState({
         chartIndexExport2Table: -1
       });
     };
-    _this.showSelectTableDialog = function (chartIndexUpdate2Table, statisticalResult) {
-      _this.statisticalResult4Update = statisticalResult;
-      _this.setState({
-        chartIndexUpdate2Table: chartIndexUpdate2Table
+    this.showSelectTableDialog = (chartIndexUpdate2Table, statisticalResult) => {
+      this.statisticalResult4Update = statisticalResult;
+      this.setState({
+        chartIndexUpdate2Table
       });
     };
-    _this.updateChart2Table = function (selectedTableId, chartUpdate2Table) {
-      var getTableById = _this.props.getTableById;
+    this.updateChart2Table = (selectedTableId, chartUpdate2Table) => {
+      const {
+        getTableById
+      } = this.props;
       if (chartUpdate2Table.type !== STAT_TYPE.PIVOT_TABLE) {
-        _this.statisticalResult4Update = null;
+        this.statisticalResult4Update = null;
         toaster.danger(intl.get('Failed_export_statistic_to_Table'));
-        _this.closeSelectTableDialog();
+        this.closeSelectTableDialog();
         return;
       }
-      var updateTable = getTableById(selectedTableId);
-      _this.closeSelectTableDialog();
-      if (!_this.statisticalResult4Update || !updateTable) {
+      const updateTable = getTableById(selectedTableId);
+      this.closeSelectTableDialog();
+      if (!this.statisticalResult4Update || !updateTable) {
         return;
       }
-      var _updateStatisticToTab = updateStatisticToTable({
-          updateTable: updateTable,
-          statisticalResult: _this.statisticalResult4Update
-        }),
-        newRows = _updateStatisticToTab.newRows,
-        updatedRows = _updateStatisticToTab.updatedRows,
-        rowIds = _updateStatisticToTab.rowIds,
-        oldRows = _updateStatisticToTab.oldRows;
+      const {
+        newRows,
+        updatedRows,
+        rowIds,
+        oldRows
+      } = updateStatisticToTable({
+        updateTable,
+        statisticalResult: this.statisticalResult4Update
+      });
       if (window.app && window.app.onUpdateStatisticToTable) {
         window.app.onUpdateStatisticToTable({
           tableId: selectedTableId,
-          newRows: newRows,
-          updatedRows: updatedRows,
-          rowIds: rowIds,
-          oldRows: oldRows
+          newRows,
+          updatedRows,
+          rowIds,
+          oldRows
         });
 
         // refresh charts if has updates
         if (Array.isArray(rowIds) && rowIds.length > 0 || Array.isArray(newRows) && newRows.length > 0) {
-          _this.props.eventBus.dispatch(CommonEventTypes.REFRESH_CHARTS);
+          this.props.eventBus.dispatch(CommonEventTypes.REFRESH_CHARTS);
         }
       }
-      _this.statisticalResult4Update = null;
-      _this.closeSelectTableDialog();
+      this.statisticalResult4Update = null;
+      this.closeSelectTableDialog();
     };
-    _this.closeSelectTableDialog = function () {
-      _this.setState({
+    this.closeSelectTableDialog = () => {
+      this.setState({
         chartIndexUpdate2Table: -1
       });
     };
-    var _statItems = props.statItems;
-    _this.state = {
-      layout: _this.getStatItemsLayout(_statItems),
+    const {
+      statItems: _statItems
+    } = props;
+    this.state = {
+      layout: this.getStatItemsLayout(_statItems),
       enlargedChartIndex: -1,
       chartIndexExport2Table: -1,
       chartIndexUpdate2Table: -1
     };
-    return _this;
   }
-  _createClass(StatList, [{
-    key: "UNSAFE_componentWillReceiveProps",
-    value: function UNSAFE_componentWillReceiveProps(nextProps) {
-      var statItems = nextProps.statItems;
-      this.setState({
-        layout: this.getStatItemsLayout(statItems)
-      });
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this2 = this;
-      var _this$props = this.props,
-        isTableReadOnly = _this$props.isTableReadOnly,
-        dtableChangedTime = _this$props.dtableChangedTime,
-        theme = _this$props.theme,
-        colorThemeName = _this$props.colorThemeName,
-        statItems = _this$props.statItems,
-        chartCalculator = _this$props.chartCalculator,
-        eventBus = _this$props.eventBus;
-      var _this$state = this.state,
-        layout = _this$state.layout,
-        enlargedChartIndex = _this$state.enlargedChartIndex,
-        chartIndexExport2Table = _this$state.chartIndexExport2Table,
-        chartIndexUpdate2Table = _this$state.chartIndexUpdate2Table;
-      var enlargedChart = enlargedChartIndex > -1 && statItems[enlargedChartIndex];
-      var chartExport2Table = chartIndexExport2Table > -1 && statItems[chartIndexExport2Table];
-      var chartUpdate2Table = chartIndexUpdate2Table > -1 && statItems[chartIndexUpdate2Table];
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    const {
+      statItems
+    } = nextProps;
+    this.setState({
+      layout: this.getStatItemsLayout(statItems)
+    });
+  }
+  render() {
+    const {
+      isTableReadOnly,
+      dtableChangedTime,
+      theme,
+      colorThemeName,
+      statItems,
+      chartCalculator,
+      eventBus
+    } = this.props;
+    const {
+      layout,
+      enlargedChartIndex,
+      chartIndexExport2Table,
+      chartIndexUpdate2Table
+    } = this.state;
+    const enlargedChart = enlargedChartIndex > -1 && statItems[enlargedChartIndex];
+    const chartExport2Table = chartIndexExport2Table > -1 && statItems[chartIndexExport2Table];
+    const chartUpdate2Table = chartIndexUpdate2Table > -1 && statItems[chartIndexUpdate2Table];
+    return /*#__PURE__*/React.createElement("div", {
+      className: "statistic-list"
+    }, Array.isArray(statItems) && /*#__PURE__*/React.createElement(ReactGridLayout, {
+      className: "statistic-layout layout",
+      isDraggable: true,
+      rowHeight: 35,
+      layout: layout,
+      containerPadding: [15, 15],
+      margin: [10, 10],
+      draggableHandle: '.statistic-chart-preview-header',
+      onLayoutChange: this.onLayoutChange,
+      cols: 4,
+      useCSSTransforms: false
+    }, statItems.map((statItem, index) => {
+      const statId = statItem._id;
+      if (!statId) return null;
       return /*#__PURE__*/React.createElement("div", {
-        className: "statistic-list"
-      }, Array.isArray(statItems) && /*#__PURE__*/React.createElement(ReactGridLayout, {
-        className: "statistic-layout layout",
-        isDraggable: true,
-        rowHeight: 35,
-        layout: layout,
-        containerPadding: [15, 15],
-        margin: [10, 10],
-        draggableHandle: '.statistic-chart-preview-header',
-        onLayoutChange: this.onLayoutChange,
-        cols: 4,
-        useCSSTransforms: false
-      }, statItems.map(function (statItem, index) {
-        var statId = statItem._id;
-        if (!statId) return null;
-        return /*#__PURE__*/React.createElement("div", {
-          id: statId,
-          key: statId,
-          className: "statistic-chart-preview"
-        }, /*#__PURE__*/React.createElement(ChartPreview, {
-          isTableReadOnly: isTableReadOnly,
-          dtableChangedTime: dtableChangedTime,
-          theme: theme,
-          colorThemeName: colorThemeName,
-          statItem: statItem,
-          chartCalculator: chartCalculator,
-          eventBus: eventBus,
-          getOtherStatistics: _this2.props.getOtherStatistics,
-          getTableById: _this2.props.getTableById,
-          getTables: _this2.props.getTables,
-          queryMapJson: _this2.props.queryMapJson,
-          copyChart: _this2.props.copyChart,
-          moveChartToView: _this2.props.moveChartToView,
-          deleteChart: _this2.props.deleteChart,
-          enlargeChart: function enlargeChart() {
-            return _this2.enlargeChart(index);
-          },
-          showNewTableDialog: function showNewTableDialog(_ref) {
-            var statisticalResult = _ref.statisticalResult;
-            return _this2.showNewTableDialog(index, statisticalResult);
-          },
-          showSelectTableDialog: function showSelectTableDialog(_ref2) {
-            var statisticalResult = _ref2.statisticalResult;
-            return _this2.showSelectTableDialog(index, statisticalResult);
-          },
-          onToggleEditChart: _this2.props.onToggleEditChart,
-          onCloseDashboard: _this2.props.onCloseDashboard,
-          toggleStatisticRecordsDialog: _this2.props.toggleStatisticRecordsDialog
-        }));
-      })), enlargedChart && /*#__PURE__*/React.createElement(EnlargeChartDialog, {
+        id: statId,
+        key: statId,
+        className: "statistic-chart-preview"
+      }, /*#__PURE__*/React.createElement(ChartPreview, {
+        isTableReadOnly: isTableReadOnly,
         dtableChangedTime: dtableChangedTime,
+        theme: theme,
         colorThemeName: colorThemeName,
-        statItem: enlargedChart,
-        eventBus: eventBus,
+        statItem: statItem,
         chartCalculator: chartCalculator,
+        eventBus: eventBus,
+        getOtherStatistics: this.props.getOtherStatistics,
         getTableById: this.props.getTableById,
-        queryMapJson: this.props.queryMapJson,
-        onEnlargeToggle: this.closeEnlargedChart,
-        onToggleShowEnlarged: this.closeEnlargedChart,
-        toggleStatisticRecordsDialog: this.props.toggleStatisticRecordsDialog
-      }), chartExport2Table && /*#__PURE__*/React.createElement(NewTableDialog, {
         getTables: this.props.getTables,
-        tableName: chartExport2Table.name,
-        onNewTableConfirm: function onNewTableConfirm(tableName) {
-          return _this2.exportChart2Table(tableName, chartExport2Table);
+        queryMapJson: this.props.queryMapJson,
+        copyChart: this.props.copyChart,
+        moveChartToView: this.props.moveChartToView,
+        deleteChart: this.props.deleteChart,
+        enlargeChart: () => this.enlargeChart(index),
+        showNewTableDialog: _ref => {
+          let {
+            statisticalResult
+          } = _ref;
+          return this.showNewTableDialog(index, statisticalResult);
         },
-        onNewTableCancel: this.closeNewTableDialog
-      }), chartUpdate2Table && /*#__PURE__*/React.createElement(TableSelectDialog, {
-        tables: this.props.getTables(),
-        title: intl.get('Update_to_a_table'),
-        toggle: this.closeSelectTableDialog,
-        onSelectTable: function onSelectTable(selectedTableId) {
-          return _this2.updateChart2Table(selectedTableId, chartUpdate2Table);
-        }
+        showSelectTableDialog: _ref2 => {
+          let {
+            statisticalResult
+          } = _ref2;
+          return this.showSelectTableDialog(index, statisticalResult);
+        },
+        onToggleEditChart: this.props.onToggleEditChart,
+        onCloseDashboard: this.props.onCloseDashboard,
+        toggleStatisticRecordsDialog: this.props.toggleStatisticRecordsDialog
       }));
-    }
-  }]);
-  return StatList;
-}(Component);
+    })), enlargedChart && /*#__PURE__*/React.createElement(EnlargeChartDialog, {
+      dtableChangedTime: dtableChangedTime,
+      colorThemeName: colorThemeName,
+      statItem: enlargedChart,
+      eventBus: eventBus,
+      chartCalculator: chartCalculator,
+      getTableById: this.props.getTableById,
+      queryMapJson: this.props.queryMapJson,
+      onEnlargeToggle: this.closeEnlargedChart,
+      onToggleShowEnlarged: this.closeEnlargedChart,
+      toggleStatisticRecordsDialog: this.props.toggleStatisticRecordsDialog
+    }), chartExport2Table && /*#__PURE__*/React.createElement(NewTableDialog, {
+      getTables: this.props.getTables,
+      tableName: chartExport2Table.name,
+      onNewTableConfirm: tableName => this.exportChart2Table(tableName, chartExport2Table),
+      onNewTableCancel: this.closeNewTableDialog
+    }), chartUpdate2Table && /*#__PURE__*/React.createElement(TableSelectDialog, {
+      tables: this.props.getTables(),
+      title: intl.get('Update_to_a_table'),
+      toggle: this.closeSelectTableDialog,
+      onSelectTable: selectedTableId => this.updateChart2Table(selectedTableId, chartUpdate2Table)
+    }));
+  }
+}
 export default StatList;