sea-chart 2.0.43 → 2.0.45

package/dist/view/wrapper/chart-component.js

@@ -1,56 +1,116 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var d3 = _interopRequireWildcard(require("d3"));
-var _lodashEs = require("lodash-es");
-var _dtableUtils = require("dtable-utils");
-var _utils = require("../../utils");
-var _constants = require("../../constants");
-var _style = require("../../constants/style");
-var _intl = _interopRequireDefault(require("../../intl"));
-require("../../assets/css/sea-chart-d3-tooltip.css");
-class ChartComponent extends _react.Component {
+import React from 'react';
+import { Component } from 'react';
+import * as d3 from 'd3';
+import { cloneDeep, debounce } from 'lodash-es';
+import { getTableById, getTableColumnByKey } from 'dtable-utils';
+import { BaseUtils, formatXAxisLabel } from '../../utils';
+import { CHART_TYPE, CHART_SUMMARY_TYPE, LABEL_POSITION_TYPE, CHART_THEME_COLOR, EMPTY_NAME, THEME_NAME_MAP, CHART_STYLE_COLORS, DEFAULT_AXIS_LABEL_FONT_COLOR, DEFAULT_AXIS_LABEL_FONT_COLOR_DARK, DEFAULT_AXIS_LABEL_FONT_SIZE } from '../../constants';
+import { FILL_BORDER_COLOR_MAP } from '../../constants/style';
+import intl from '../../intl';
+import '../../assets/css/sea-chart-d3-tooltip.css';
+export default class ChartComponent extends Component {
   constructor(props) {
     var _this;
     super(props);
     _this = this;
+    // Filter out the data whose legend group has been toggled off, so the chart
+    // body can be re-laid out without the hidden categories. The full data set is
+    // still passed to setLegend so every legend item (including hidden ones) shows.
+    this.getVisibleLegendData = (data, legendName) => {
+      if (!Array.isArray(data) || !this.hiddenLegendGroups || this.hiddenLegendGroups.size === 0) {
+        return data;
+      }
+      const filtered = data.filter(d => !this.hiddenLegendGroups.has(String(d === null || d === void 0 ? void 0 : d[legendName])));
+      // Never hide everything, keep the original data as a fallback.
+      return filtered.length ? filtered : data;
+    };
+    this.handleLegendClick = groupName => {
+      if (!this.hiddenLegendGroups) this.hiddenLegendGroups = new Set();
+      const key = String(groupName);
+      const isHidden = this.hiddenLegendGroups.has(key);
+      if (isHidden) {
+        this.hiddenLegendGroups.delete(key);
+      } else {
+        // Keep at least one visible group so the chart is never fully empty.
+        const total = this.legendGroupNames ? this.legendGroupNames.size : 0;
+        const visibleCount = total - this.hiddenLegendGroups.size;
+        if (visibleCount <= 1) return;
+        this.hiddenLegendGroups.add(key);
+      }
+      this.redrawChart();
+    };
+    this.redrawChart = () => {
+      if (!this.createChart || !this.drawChart) return;
+      this.destroyChart();
+      this.createChart();
+      this.drawChart();
+    };
     this.initLabelStroke = theme => {
-      this.globalTheme = theme || _constants.THEME_NAME_MAP.LIGHT;
-      this.labelStroke = theme === _constants.THEME_NAME_MAP.DARK ? {} : {
+      this.globalTheme = theme || THEME_NAME_MAP.LIGHT;
+      this.labelStroke = theme === THEME_NAME_MAP.DARK ? {} : {
         stroke: '#fff',
         lineWidth: 1
       };
     };
-    this.handleResize = (0, _lodashEs.debounce)(() => {
+    this.handleResize = debounce(() => {
       if (!this.createChart || !this.drawChart) return;
       this.destroyChart();
       this.createChart();
       this.drawChart();
-      if (this.needRenderAxisLabel) {
-        this.renderAxisLabel(this.props.chart, this.props.tables);
-      }
     }, 300);
     this.destroyChart = () => {
       this.chart && this.chart.node() && this.chart.node().remove();
+      this.container && this.setAxisTitlePadding(this.container, {
+        left: null,
+        bottom: null,
+        right: null
+      });
+      this._clipMaskByRect.clear();
+      this._defs = null;
+    };
+    this.toggleRecords = function (statisticRecord) {
+      if (!statisticRecord) return;
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      _this.props.toggleRecords && _this.props.toggleRecords(statisticRecord, ...args);
     };
     this.getTitle = (tables, table_id, yAxisType, yAxisKey) => {
-      return yAxisType === _constants.CHART_SUMMARY_TYPE.COUNT ? _intl.default.get('Amount') : this.getAxisLabel(tables, table_id, yAxisKey);
+      return yAxisType === CHART_SUMMARY_TYPE.COUNT ? intl.get('Amount') : this.getAxisLabel(tables, table_id, yAxisKey);
     };
     this.getColumn = (tables, table_id, columnKey) => {
-      const table = (0, _dtableUtils.getTableById)(tables, table_id);
-      const column = (0, _dtableUtils.getTableColumnByKey)(table, columnKey) || {};
+      const table = getTableById(tables, table_id);
+      const column = getTableColumnByKey(table, columnKey) || {};
       return column;
     };
     this.getAxisLabel = (tables, tableId, columnKey) => {
       const column = this.getColumn(tables, tableId, columnKey);
       return column.name || '';
     };
+    this.getAxisTitleHeight = fontSize => {
+      const safeFontSize = Number(fontSize) || DEFAULT_AXIS_LABEL_FONT_SIZE;
+      return Math.max(this.axisTitleMinHeight, safeFontSize + 4);
+    };
+    this.setAxisTitlePadding = function (chartContainer) {
+      let {
+        left = null,
+        bottom = null,
+        right = null
+      } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!chartContainer) return;
+      chartContainer.style.paddingLeft = left != null ? `${left}px` : '';
+      chartContainer.style.paddingBottom = bottom != null ? `${bottom}px` : '';
+      chartContainer.style.paddingRight = right != null ? `${right}px` : '';
+    };
+    this.getRotatedAxisTitleTransform = function (containerHeight, titleHeight) {
+      let placement = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'left';
+      const translateX = containerHeight / 2 - titleHeight / 2;
+      const translateY = containerHeight / 2 - titleHeight / 2;
+      if (placement === 'right') {
+        return `translate(${translateX}px, ${translateY}px) rotate(-90deg)`;
+      }
+      return `translate(-${translateX}px, ${translateY}px) rotate(-90deg)`;
+    };
     this.initChart = function (container, id) {
       let initConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       const {
@@ -68,6 +128,8 @@ class ChartComponent extends _react.Component {
       const height = customHeight ? customHeight : containerHeight - marginBottom;
       _this.chart = d3.create('svg').attr('id', id).attr('width', width).attr('height', height).attr('viewBox', [0, 0, width, height]);
       _this.container.appendChild(_this.chart.node());
+      _this._defs = null;
+      _this._clipMaskByRect = new Map();
       _this.chartBoundingClientRect = {
         ...JSON.parse(JSON.stringify(_this.chart.node().getBoundingClientRect())),
         ...initConfig,
@@ -75,6 +137,12 @@ class ChartComponent extends _react.Component {
         height
       };
     };
+    this.getDefs = () => {
+      if (!this._defs || !this._defs.node() || !this._defs.node().isConnected) {
+        this._defs = this.chart.append('defs').attr('class', 'sea-chart-defs');
+      }
+      return this._defs;
+    };
     this.initDefs = () => {
       if (this.container) {
         // add Mask
@@ -107,7 +175,7 @@ class ChartComponent extends _react.Component {
         if (item.group_name === 'rest' && isCompleteness) return;
         const groupData = chartGroupData.find(g => g.name === item.name);
         if (!groupData) {
-          const newItem = (0, _lodashEs.cloneDeep)(item);
+          const newItem = cloneDeep(item);
           newItem.currentGroupCount = 1;
           chartGroupData.push(newItem);
         } else {
@@ -161,13 +229,13 @@ class ChartComponent extends _react.Component {
           // mark the first item in each group,but if item value is 0, mark the next item
           let targetMarkItem = item[0],
             i = 1;
-          while (!((_targetMarkItem = targetMarkItem) !== null && _targetMarkItem !== void 0 && _targetMarkItem.value) && !Number.isNaN((_targetMarkItem2 = targetMarkItem) === null || _targetMarkItem2 === void 0 ? void 0 : _targetMarkItem2.value)) {
+          while (!((_targetMarkItem = targetMarkItem) === null || _targetMarkItem === void 0 ? void 0 : _targetMarkItem.value) && !Number.isNaN((_targetMarkItem2 = targetMarkItem) === null || _targetMarkItem2 === void 0 ? void 0 : _targetMarkItem2.value)) {
             var _targetMarkItem, _targetMarkItem2;
             targetMarkItem = item[i];
             i++;
             if (i >= item.length) break;
           }
-          if (!((_targetMarkItem3 = targetMarkItem) !== null && _targetMarkItem3 !== void 0 && _targetMarkItem3.value)) return;
+          if (!((_targetMarkItem3 = targetMarkItem) === null || _targetMarkItem3 === void 0 ? void 0 : _targetMarkItem3.value)) return;
           targetMarkItem.isFirst = 1;
         } else if (position === 'last') {
           var _targetMarkItem6;
@@ -175,13 +243,13 @@ class ChartComponent extends _react.Component {
           const l = item.length;
           let targetMarkItem = item[l - 1],
             i = l - 2;
-          while (!((_targetMarkItem4 = targetMarkItem) !== null && _targetMarkItem4 !== void 0 && _targetMarkItem4.value) && !Number.isNaN((_targetMarkItem5 = targetMarkItem) === null || _targetMarkItem5 === void 0 ? void 0 : _targetMarkItem5.value)) {
+          while (!((_targetMarkItem4 = targetMarkItem) === null || _targetMarkItem4 === void 0 ? void 0 : _targetMarkItem4.value) && !Number.isNaN((_targetMarkItem5 = targetMarkItem) === null || _targetMarkItem5 === void 0 ? void 0 : _targetMarkItem5.value)) {
             var _targetMarkItem4, _targetMarkItem5;
             targetMarkItem = item[i];
             i--;
             if (i < 0) break;
           }
-          if (!((_targetMarkItem6 = targetMarkItem) !== null && _targetMarkItem6 !== void 0 && _targetMarkItem6.value)) return;
+          if (!((_targetMarkItem6 = targetMarkItem) === null || _targetMarkItem6 === void 0 ? void 0 : _targetMarkItem6.value)) return;
           targetMarkItem.isLast = 1;
         } else {
           console.error('on markFirstOrLast: unknown position');
@@ -229,23 +297,38 @@ class ChartComponent extends _react.Component {
         y_axis_summary_type,
         type,
         title_name,
+        x_axis_label_font_size,
+        x_axis_label_font_color,
+        y_axis_label_font_size,
+        y_axis_label_font_color,
         // left axis - combination chart
         show_y_axis_left_label,
         y_axis_left_label_position,
         y_axis_left_summary_type,
         y_axis_left_summary_column,
+        y_axis_left_label_font_size,
+        y_axis_left_label_font_color,
         // right axis - combination chart
         show_y_axis_right_label,
         y_axis_right_label_position,
         y_axis_right_summary_type,
-        y_axis_right_summary_column
+        y_axis_right_summary_column,
+        y_axis_right_label_font_size,
+        y_axis_right_label_font_color
       } = chart.config;
       if (y_axis_summary_column_key) {
         y_axis_column_key = y_axis_summary_column_key;
       }
-      const table = (0, _dtableUtils.getTableById)(tables, table_id);
-      let textColor;
-      this.globalTheme === _constants.THEME_NAME_MAP.DARK ? textColor = '#fff' : textColor = '#999';
+      const table = getTableById(tables, table_id);
+      const defaultTextColor = this.globalTheme === THEME_NAME_MAP.DARK ? DEFAULT_AXIS_LABEL_FONT_COLOR_DARK : DEFAULT_AXIS_LABEL_FONT_COLOR;
+      const xColor = x_axis_label_font_color || defaultTextColor;
+      const xFontSize = x_axis_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
+      const yColor = y_axis_label_font_color || defaultTextColor;
+      const yFontSize = y_axis_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
+      const yLeftColor = y_axis_left_label_font_color || defaultTextColor;
+      const yLeftFontSize = y_axis_left_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
+      const yRightColor = y_axis_right_label_font_color || defaultTextColor;
+      const yRightFontSize = y_axis_right_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
 
       // xAxis
       const xAxisID = `chart-x-axis-label_${chart.id}`;
@@ -253,17 +336,18 @@ class ChartComponent extends _react.Component {
       const {
         width: containerWidth
       } = this.chartBoundingClientRect;
+      const xTitleHeight = this.getAxisTitleHeight(xFontSize);
       if (!xLabel && x_axis_show_label) {
         const div = document.createElement('div');
         div.id = xAxisID;
         div.className = 'chart-axis-label';
-        const column = (0, _dtableUtils.getTableColumnByKey)(table, x_axis_column_key);
+        const column = getTableColumnByKey(table, x_axis_column_key);
         div.innerHTML = `${column ? column.name : ''}`;
-        div.setAttribute('style', `color:${textColor}; width: ${containerWidth}px; text-align: ${x_axis_label_position}; position: absolute; bottom: 0;`);
+        div.setAttribute('style', `color:${xColor}; font-size:${xFontSize}px; width: ${containerWidth}px; height: ${xTitleHeight}px; line-height: ${xTitleHeight}px; text-align: ${x_axis_label_position}; position: absolute; bottom: 0;`);
         chartContainer.appendChild(div);
       }
       if (xLabel && x_axis_show_label) {
-        xLabel.setAttribute('style', `color:${textColor}; width: ${containerWidth}px; text-align: ${x_axis_label_position}; position: absolute; bottom: 0;`);
+        xLabel.setAttribute('style', `color:${xColor}; font-size:${xFontSize}px; width: ${containerWidth}px; height: ${xTitleHeight}px; line-height: ${xTitleHeight}px; text-align: ${x_axis_label_position}; position: absolute; bottom: 0;`);
       }
       if (xLabel && !x_axis_show_label) {
         xLabel.parentNode.removeChild(xLabel);
@@ -272,18 +356,18 @@ class ChartComponent extends _react.Component {
       // yAxis
       const yAxisID = `chart-y-axis-label_${chart.id}`;
       const yLabel = chartContainer.querySelector(`#${yAxisID}`);
-      const divHeight = 20;
+      const yTitleHeight = this.getAxisTitleHeight(yFontSize);
       if (!yLabel && y_axis_show_label) {
         const div = document.createElement('div');
         div.id = yAxisID;
         div.className = 'chart-axis-label';
         // SCATTER always has y_axis_column_key
-        if (y_axis_summary_type === _constants.CHART_SUMMARY_TYPE.COUNT && type !== _constants.CHART_TYPE.SCATTER) {
-          div.innerHTML = _intl.default.get('Amount');
+        if (y_axis_summary_type === CHART_SUMMARY_TYPE.COUNT && type !== CHART_TYPE.SCATTER) {
+          div.innerHTML = intl.get('Amount');
         } else {
-          const column = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_column_key) || {};
+          const column = getTableColumnByKey(table, y_axis_column_key) || {};
           div.innerHTML = column.name || '';
-          if (type === _constants.CHART_TYPE.BAR_STACK) {
+          if (type === CHART_TYPE.BAR_STACK) {
             div.innerHTML = title_name || '';
           }
         }
@@ -291,9 +375,9 @@ class ChartComponent extends _react.Component {
           height: containerHeight
         } = this.chartBoundingClientRect;
         let textAlign = 'center';
-        if (y_axis_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (y_axis_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        div.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (y_axis_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (y_axis_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        div.setAttribute('style', `color:${yColor}; font-size:${yFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yTitleHeight}px; line-height: ${yTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yTitleHeight)}`);
         chartContainer.appendChild(div);
       }
       if (yLabel && y_axis_show_label) {
@@ -301,9 +385,9 @@ class ChartComponent extends _react.Component {
           height: containerHeight
         } = this.chartBoundingClientRect;
         let textAlign = 'center';
-        if (y_axis_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (y_axis_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        yLabel.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (y_axis_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (y_axis_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        yLabel.setAttribute('style', `color:${yColor}; font-size:${yFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yTitleHeight}px; line-height: ${yTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yTitleHeight)}`);
       }
       if (yLabel && !y_axis_show_label) {
         yLabel.parentNode.removeChild(yLabel);
@@ -312,21 +396,22 @@ class ChartComponent extends _react.Component {
       // yAxis(left) - combination chart
       const yAxisLeftID = `chart-y-axis-left-label_${chart.id}`;
       const yAxisLeftLabel = chartContainer.querySelector(`#${yAxisLeftID}`);
+      const yLeftTitleHeight = this.getAxisTitleHeight(yLeftFontSize);
       if (!yAxisLeftLabel && show_y_axis_left_label) {
         const div = document.createElement('div');
         div.id = yAxisLeftID;
         div.className = 'chart-axis-label text-truncate';
-        if (y_axis_left_summary_type === _constants.CHART_SUMMARY_TYPE.COUNT) {
-          div.innerHTML = _intl.default.get('Amount');
+        if (y_axis_left_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+          div.innerHTML = intl.get('Amount');
         } else {
-          const column = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_left_summary_column) || {};
+          const column = getTableColumnByKey(table, y_axis_left_summary_column) || {};
           div.innerHTML = column.name || '';
         }
         const containerHeight = chartContainer.offsetHeight;
         let textAlign = 'center';
-        if (y_axis_left_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (y_axis_left_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        div.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (y_axis_left_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (y_axis_left_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        div.setAttribute('style', `color:${yLeftColor}; font-size:${yLeftFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yLeftTitleHeight}px; line-height: ${yLeftTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yLeftTitleHeight)}`);
         chartContainer.appendChild(div);
       }
       if (yAxisLeftLabel && show_y_axis_left_label) {
@@ -334,7 +419,7 @@ class ChartComponent extends _react.Component {
         let textAlign = 'center';
         if (y_axis_left_label_position === 'bottom') textAlign = 'left';
         if (y_axis_left_label_position === 'top') textAlign = 'right';
-        yAxisLeftLabel.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        yAxisLeftLabel.setAttribute('style', `color:${yLeftColor}; font-size:${yLeftFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yLeftTitleHeight}px; line-height: ${yLeftTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yLeftTitleHeight)}`);
       }
       if (yAxisLeftLabel && !show_y_axis_left_label) {
         yAxisLeftLabel.parentNode.removeChild(yAxisLeftLabel);
@@ -343,21 +428,22 @@ class ChartComponent extends _react.Component {
       // yAxis(right) - combination chart
       const yAxisRightID = `chart-y-axis-right-label_${chart.id}`;
       const yAxisRightLabel = chartContainer.querySelector(`#${yAxisRightID}`);
+      const yRightTitleHeight = this.getAxisTitleHeight(yRightFontSize);
       if (!yAxisRightLabel && show_y_axis_right_label) {
         const div = document.createElement('div');
         div.id = yAxisRightID;
         div.className = 'chart-axis-label text-truncate';
-        if (y_axis_right_summary_type === _constants.CHART_SUMMARY_TYPE.COUNT) {
-          div.innerHTML = _intl.default.get('Amount');
+        if (y_axis_right_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+          div.innerHTML = intl.get('Amount');
         } else {
-          const column = (0, _dtableUtils.getTableColumnByKey)(table, y_axis_right_summary_column) || {};
+          const column = getTableColumnByKey(table, y_axis_right_summary_column) || {};
           div.innerHTML = column.name || '';
         }
         const containerHeight = chartContainer.offsetHeight;
         let textAlign = 'center';
-        if (y_axis_right_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (y_axis_right_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        div.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; right: 0; transform: translate(${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (y_axis_right_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (y_axis_right_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        div.setAttribute('style', `color:${yRightColor}; font-size:${yRightFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yRightTitleHeight}px; line-height: ${yRightTitleHeight}px; text-align: ${textAlign}; top: 0; right: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yRightTitleHeight, 'right')}`);
         chartContainer.appendChild(div);
       }
       if (yAxisRightLabel && show_y_axis_right_label) {
@@ -365,11 +451,16 @@ class ChartComponent extends _react.Component {
         let textAlign = 'center';
         if (y_axis_right_label_position === 'bottom') textAlign = 'left';
         if (y_axis_right_label_position === 'top') textAlign = 'right';
-        yAxisRightLabel.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; right: 0; transform: translate(${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        yAxisRightLabel.setAttribute('style', `color:${yRightColor}; font-size:${yRightFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yRightTitleHeight}px; line-height: ${yRightTitleHeight}px; text-align: ${textAlign}; top: 0; right: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yRightTitleHeight, 'right')}`);
       }
       if (yAxisRightLabel && !show_y_axis_right_label) {
         yAxisRightLabel.parentNode.removeChild(yAxisRightLabel);
       }
+      this.setAxisTitlePadding(chartContainer, {
+        left: y_axis_show_label ? yTitleHeight : show_y_axis_left_label ? yLeftTitleHeight : null,
+        right: show_y_axis_right_label ? yRightTitleHeight : null,
+        bottom: x_axis_show_label ? xTitleHeight : null
+      });
     };
     this.renderHorizontalLabel = (chart, tables, chartContainer) => {
       if (!this.chart || !chart) return;
@@ -381,85 +472,97 @@ class ChartComponent extends _react.Component {
         horizontal_axis_label_position,
         vertical_axis_label_position,
         show_vertical_axis_label,
-        show_horizontal_axis_label
+        show_horizontal_axis_label,
+        horizontal_axis_label_font_size,
+        horizontal_axis_label_font_color,
+        vertical_axis_label_font_size,
+        vertical_axis_label_font_color
       } = chart.config;
-      const table = (0, _dtableUtils.getTableById)(tables, table_id);
-      const textColor = '#999999';
+      const table = getTableById(tables, table_id);
+      const defaultTextColor = this.globalTheme === THEME_NAME_MAP.DARK ? DEFAULT_AXIS_LABEL_FONT_COLOR_DARK : DEFAULT_AXIS_LABEL_FONT_COLOR;
+      const xColor = horizontal_axis_label_font_color || defaultTextColor;
+      const xFontSize = horizontal_axis_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
+      const yColor = vertical_axis_label_font_color || defaultTextColor;
+      const yFontSize = vertical_axis_label_font_size || DEFAULT_AXIS_LABEL_FONT_SIZE;
       const xAxisID = `chart-x-axis-label_${chart.id}`;
       const xLabel = chartContainer.querySelector(`#${xAxisID}`);
       const {
         width: containerWidth
       } = this.chartBoundingClientRect;
+      const xTitleHeight = this.getAxisTitleHeight(xFontSize);
       if (!xLabel && show_horizontal_axis_label) {
         const div = document.createElement('div');
         div.id = xAxisID;
         div.className = 'chart-axis-label';
-        if (horizontal_axis_summary_type === _constants.CHART_SUMMARY_TYPE.COUNT) {
-          div.innerHTML = _intl.default.get('Amount');
+        if (horizontal_axis_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+          div.innerHTML = intl.get('Amount');
         } else {
-          const column = (0, _dtableUtils.getTableColumnByKey)(table, horizontal_axis_column_key);
+          const column = getTableColumnByKey(table, horizontal_axis_column_key);
           div.innerHTML = `${column ? column.name : ''}`;
         }
-        div.setAttribute('style', `color:${textColor}; width: ${containerWidth}px; text-align: ${horizontal_axis_label_position}; position: absolute`);
+        div.setAttribute('style', `color:${xColor}; font-size:${xFontSize}px; width: ${containerWidth}px; height: ${xTitleHeight}px; line-height: ${xTitleHeight}px; text-align: ${horizontal_axis_label_position}; position: absolute`);
         chartContainer.appendChild(div);
       }
       if (xLabel && show_horizontal_axis_label) {
-        xLabel.setAttribute('style', `color:${textColor}; width: ${containerWidth}px; text-align: ${horizontal_axis_label_position}; position: absolute`);
+        xLabel.setAttribute('style', `color:${xColor}; font-size:${xFontSize}px; width: ${containerWidth}px; height: ${xTitleHeight}px; line-height: ${xTitleHeight}px; text-align: ${horizontal_axis_label_position}; position: absolute`);
       }
       if (xLabel && !show_horizontal_axis_label) {
         xLabel.parentNode.removeChild(xLabel);
       }
       const yAxisID = `chart-y-axis-label_${chart.id}`;
       const yLabel = chartContainer.querySelector(`#${yAxisID}`);
-      const divHeight = 20;
+      const yTitleHeight = this.getAxisTitleHeight(yFontSize);
       if (!yLabel && show_vertical_axis_label) {
         const div = document.createElement('div');
         div.id = yAxisID;
         div.className = 'chart-axis-label';
-        const column = (0, _dtableUtils.getTableColumnByKey)(table, vertical_axis_column_key) || {};
+        const column = getTableColumnByKey(table, vertical_axis_column_key) || {};
         div.innerHTML = column.name || '';
         const {
           height: containerHeight
         } = this.chartBoundingClientRect;
         let textAlign = 'center';
-        if (vertical_axis_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (vertical_axis_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        div.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (vertical_axis_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (vertical_axis_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        div.setAttribute('style', `color:${yColor}; font-size:${yFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yTitleHeight}px; line-height: ${yTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yTitleHeight)}`);
         chartContainer.appendChild(div);
       }
-      if (yLabel && show_horizontal_axis_label) {
+      if (yLabel && show_vertical_axis_label) {
         const {
           height: containerHeight
         } = this.chartBoundingClientRect;
         let textAlign = 'center';
-        if (vertical_axis_label_position === _constants.LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
-        if (vertical_axis_label_position === _constants.LABEL_POSITION_TYPE.TOP) textAlign = 'right';
-        yLabel.setAttribute('style', `color:${textColor}; position: absolute; width: ${containerHeight}px; height: ${divHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: translate(-${containerHeight / 2 - divHeight / 2}px, ${containerHeight / 2 - divHeight / 2}px) rotate(-90deg)`);
+        if (vertical_axis_label_position === LABEL_POSITION_TYPE.BOTTOM) textAlign = 'left';
+        if (vertical_axis_label_position === LABEL_POSITION_TYPE.TOP) textAlign = 'right';
+        yLabel.setAttribute('style', `color:${yColor}; font-size:${yFontSize}px; position: absolute; width: ${containerHeight}px; height: ${yTitleHeight}px; line-height: ${yTitleHeight}px; text-align: ${textAlign}; top: 0; left: 0; transform: ${this.getRotatedAxisTitleTransform(containerHeight, yTitleHeight)}`);
       }
-      if (yLabel && !show_horizontal_axis_label) {
+      if (yLabel && !show_vertical_axis_label) {
         yLabel.parentNode.removeChild(yLabel);
       }
-    };
-    this.isShowVerticalAxisLabel = chart => {
-      return !!(chart && chart.config && chart.config.show_vertical_axis_label);
-    };
-    this.isShowHorizontalAxisLabel = chart => {
-      return !!(chart && chart.config && chart.config.show_horizontal_axis_label);
+      this.setAxisTitlePadding(chartContainer, {
+        left: show_vertical_axis_label ? yTitleHeight : null,
+        bottom: show_horizontal_axis_label ? xTitleHeight : null,
+        right: null
+      });
     };
     this.formatterLegendName = name => {
-      if (!name && typeof name !== 'number' || name.trim() === 'undefined' || name.trim() === 'null') {
-        return _intl.default.get(_constants.EMPTY_NAME);
+      if (typeof name !== 'string') {
+        if (!name && typeof name !== 'number') return intl.get(EMPTY_NAME);
+        return intl.get(String(name)) || String(name);
+      }
+      if (name.trim() === 'undefined' || name.trim() === 'null' || name.trim() === '') {
+        return intl.get(EMPTY_NAME);
       } else if (name === '_Others') {
-        return _intl.default.get('Others');
+        return intl.get('Others');
       } else {
-        return _intl.default.get(name) || name;
+        return intl.get(name) || name;
       }
     };
     this.setLegend = _ref => {
       var _chart$config, _chart$config2;
       let {
         legendName,
-        theme = _constants.CHART_THEME_COLOR['light'],
+        theme = CHART_THEME_COLOR['light'],
         legendPosition = 'top-left',
         data,
         colorScale,
@@ -468,23 +571,32 @@ class ChartComponent extends _react.Component {
       } = _ref;
       if (!this.chart) return;
       this.legendConfig = {
-        legendRectWidth: [_constants.CHART_TYPE.SCATTER, _constants.CHART_TYPE.MIRROR].includes(chart === null || chart === void 0 ? void 0 : (_chart$config = chart.config) === null || _chart$config === void 0 ? void 0 : _chart$config.type) ? 8 : 20,
-        legendRectHeight: [_constants.CHART_TYPE.SCATTER, _constants.CHART_TYPE.MIRROR].includes(chart === null || chart === void 0 ? void 0 : (_chart$config2 = chart.config) === null || _chart$config2 === void 0 ? void 0 : _chart$config2.type) ? 8 : 6,
+        legendRectWidth: [CHART_TYPE.SCATTER, CHART_TYPE.MIRROR].includes(chart === null || chart === void 0 ? void 0 : (_chart$config = chart.config) === null || _chart$config === void 0 ? void 0 : _chart$config.type) ? 8 : 20,
+        legendRectHeight: [CHART_TYPE.SCATTER, CHART_TYPE.MIRROR].includes(chart === null || chart === void 0 ? void 0 : (_chart$config2 = chart.config) === null || _chart$config2 === void 0 ? void 0 : _chart$config2.type) ? 8 : 6,
         r: this.getLegendR(chart),
         legendItemPaddingTop: 5,
         legendItemTextPaddingTop: 13,
         legendItemMargin: 20,
         legendRecTextGap: 8,
-        legendPageNavWrapperWidth: 100,
-        legendPageNavWrapperHeight: 18,
+        // Space reserved for the page navigator. Start at 0 and only reserve it when
+        // pagination is actually needed, so a legend that fits is not pushed onto a
+        // hidden page (which made the legend look incomplete/clipped).
+        legendPageNavWrapperWidth: 0,
+        legendPageNavWrapperHeight: 0,
+        legendPageNavMaxWidth: 100,
+        legendPageNavMaxHeight: 18,
         legendPosition,
         legendName,
         theme
       };
 
       // sort legend data and format data
-      data.forEach(item => item[legendName] = String(item[legendName]));
-      const legendData = _utils.BaseUtils.sortDataByGroupName((0, _lodashEs.cloneDeep)(data), legendName, groupColumn, chart);
+      const clonedData = cloneDeep(data);
+      clonedData.forEach(item => item[legendName] = String(item[legendName]));
+      const legendData = BaseUtils.sortDataByGroupName(clonedData, legendName, groupColumn, chart);
+
+      // Record every legend group name so legend click can keep at least one visible.
+      this.legendGroupNames = new Set(legendData.map(item => String(item[legendName])));
       const {
         width: chartWidth,
         height: chartHeight,
@@ -492,7 +604,14 @@ class ChartComponent extends _react.Component {
         rightLegendSpace,
         bottomLegendSpace
       } = this.chartBoundingClientRect;
-      const groupsData = this.getLegendDataGroups(legendData);
+      let groupsData = this.getLegendDataGroups(legendData);
+      // If more than one page is required, reserve room for the page navigator and
+      // re-paginate against the reduced space.
+      if (groupsData.length > 1) {
+        this.legendConfig.legendPageNavWrapperWidth = this.legendConfig.legendPageNavMaxWidth;
+        this.legendConfig.legendPageNavWrapperHeight = this.legendConfig.legendPageNavMaxHeight;
+        groupsData = this.getLegendDataGroups(legendData);
+      }
       if (groupsData.length === 0) return;
       const legendWrapper = this.chart.append('g').attr('class', 'legend-wrapper');
 
@@ -625,7 +744,7 @@ class ChartComponent extends _react.Component {
       }).append('rect').attr('width', legendRectWidth).attr('height', legendRectHeight).attr('y', legendItemPaddingTop).attr('rx', r).attr('fill', _ref4 => {
         let [groupName] = _ref4;
         if (colorScale) return colorScale(groupName);
-        return this.colorMap[groupName] || _constants.CHART_STYLE_COLORS[0];
+        return this.colorMap[groupName] || CHART_STYLE_COLORS[0];
       }).attr('data-text', _ref5 => {
         let [groupName] = _ref5;
         return groupName;
@@ -655,6 +774,7 @@ class ChartComponent extends _react.Component {
               translateY = prevTranslateY + height + legendItemMargin;
             }
             d3.select(item).attr('transform', `translate(${start},${translateY})`).attr('data-translateY', translateY);
+            this.bindLegendItemInteraction(item);
           });
         } else {
           // update g translateX
@@ -669,6 +789,7 @@ class ChartComponent extends _react.Component {
               translateX = prevTranslateX + width + legendItemMargin;
             }
             d3.select(item).attr('transform', `translate(${translateX},0)`).attr('data-translateX', translateX);
+            this.bindLegendItemInteraction(item);
 
             // legend items add offset 
             if (legendPosition === 'top-right') {
@@ -707,7 +828,7 @@ class ChartComponent extends _react.Component {
       if (top && bottom) {
         let allHeight = top;
         const groupsData = [];
-        const newLegendData = (0, _lodashEs.cloneDeep)(legendData);
+        const newLegendData = cloneDeep(legendData);
         let lastIndex = 0;
         legendData.forEach((item, index) => {
           const virtualLegend = this.chart.append('g').attr('opacity', 0);
@@ -732,7 +853,7 @@ class ChartComponent extends _react.Component {
       } else {
         let allWidth = start;
         const groupsData = [];
-        const newLegendData = (0, _lodashEs.cloneDeep)(legendData);
+        const newLegendData = cloneDeep(legendData);
         let lastIndex = 0;
         legendData.forEach((item, index) => {
           const virtualLegend = this.chart.append('g').attr('opacity', 0);
@@ -816,19 +937,26 @@ class ChartComponent extends _react.Component {
       legendItems.forEach(legendItem => {
         const curTranslateX = Number(legendItem.getAttribute('data-translateX')) + offset;
         d3.select(legendItem).attr('transform', `translate(${curTranslateX}, 0)`).attr('data-translateX', curTranslateX);
-        d3.select(legendItem).attr('opacity', 1);
+        const isHidden = this.hiddenLegendGroups && this.hiddenLegendGroups.has(String(legendItem.getAttribute('data-groupName')));
+        d3.select(legendItem).attr('opacity', isHidden ? 0.35 : 1);
       });
     };
+    this.bindLegendItemInteraction = item => {
+      if (!item) return;
+      const groupName = item.getAttribute('data-groupName');
+      const isHidden = this.hiddenLegendGroups && this.hiddenLegendGroups.has(String(groupName));
+      d3.select(item).style('cursor', 'pointer').attr('opacity', isHidden ? 0.35 : 1).on('click', () => this.handleLegendClick(groupName));
+    };
     this.sortLegend = (result, groupColumn, legendName) => {
       result.forEach(item => {
         const option = groupColumn.data.options.find(option => option.name === item[legendName]);
-        if (option !== null && option !== void 0 && option.id) {
+        if (option === null || option === void 0 ? void 0 : option.id) {
           item['group_name_id'] = option.id;
           item['oldName'] = item.name;
           item.name = item['group_name_id'];
         }
       });
-      _utils.BaseUtils.sortCharts(result, groupColumn, 'name');
+      BaseUtils.sortCharts(result, groupColumn, 'name');
       result.forEach(item => {
         item.name = item['oldName'];
       });
@@ -841,8 +969,8 @@ class ChartComponent extends _react.Component {
       const {
         type
       } = config;
-      if (type === _constants.CHART_TYPE.SCATTER) return 4;
-      if (type === _constants.CHART_TYPE.MIRROR) return 0;
+      if (type === CHART_TYPE.SCATTER) return 4;
+      if (type === CHART_TYPE.MIRROR) return 0;
       return 3;
     };
     this.calcEquilateralTriangle = (cx, cy, size, direction) => {
@@ -856,12 +984,12 @@ class ChartComponent extends _react.Component {
       let groupName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'group_name';
       let groupColumn = arguments.length > 3 ? arguments[3] : undefined;
       let chart = arguments.length > 4 ? arguments[4] : undefined;
-      const newData = _utils.BaseUtils.sortDataByGroupName((0, _lodashEs.cloneDeep)(data), groupName, groupColumn, chart);
+      const newData = BaseUtils.sortDataByGroupName(cloneDeep(data), groupName, groupColumn, chart);
       let currentIdx = 0;
-      const defaultColors = _constants.CHART_STYLE_COLORS;
+      const defaultColors = CHART_STYLE_COLORS;
       let colors = defaultColors;
       if (chartColorTheme) {
-        colors = _utils.BaseUtils.getCurrentTheme(chartColorTheme).colors;
+        colors = BaseUtils.getCurrentTheme(chartColorTheme).colors;
       }
       const colorMap = newData.reduce((acc, cur) => {
         const key = cur[groupName] || cur[groupName] === 0 ? cur[groupName] : '';
@@ -961,37 +1089,25 @@ class ChartComponent extends _react.Component {
                 formatted_value: item.formatted_value + ''
               });
             }
-            if (type === _constants.CHART_TYPE.WORLD_MAP_BUBBLE) {
+            if (type === CHART_TYPE.WORLD_MAP_BUBBLE) {
               sum += item.value;
             }
           }
         }
       });
-      if (type === _constants.CHART_TYPE.WORLD_MAP_BUBBLE) {
+      if (type === CHART_TYPE.WORLD_MAP_BUBBLE) {
         statisticNewData.sum = sum;
       }
       return statisticNewData;
     };
-    this.isShowXAxisLabel = chart => {
-      return !!(chart && chart.config && chart.config.x_axis_show_label);
-    };
-    this.isShowYAxisLabel = chart => {
-      return !!(chart && chart.config && chart.config.y_axis_show_label);
-    };
-    this.isShowYAxisLeftLabel = chart => {
-      return !!(chart && chart.config && chart.config.show_y_axis_left_label);
-    };
-    this.isShowYAxisRightLabel = chart => {
-      return !!(chart && chart.config && chart.config.show_y_axis_right_label);
-    };
     this.getThemeColors = function () {
       let themeColors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
       let theme = arguments.length > 1 ? arguments[1] : undefined;
       // dark->custom->light
-      if (theme === _constants.THEME_NAME_MAP.DARK) {
-        themeColors = _constants.CHART_THEME_COLOR.dark;
+      if (theme === THEME_NAME_MAP.DARK) {
+        themeColors = CHART_THEME_COLOR.dark;
       }
-      return themeColors || _constants.CHART_THEME_COLOR[_constants.THEME_NAME_MAP.LIGHT];
+      return themeColors || CHART_THEME_COLOR[THEME_NAME_MAP.LIGHT];
     };
     this.setDispalyGoalLine = (goal_label, goal_value, insertPadding, yScale) => {
       const {
@@ -1012,7 +1128,7 @@ class ChartComponent extends _react.Component {
         label_font_size,
         text
       } = _ref6;
-      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('y', Number(y) - 10).attr('fill', theme.labelColor).attr('font-size', _utils.BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
+      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('y', Number(y) - 10).attr('fill', theme.labelColor).attr('font-size', BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
         if (!g.node()) return;
         const {
           width
@@ -1031,7 +1147,7 @@ class ChartComponent extends _react.Component {
         label_font_size,
         text
       } = _ref7;
-      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('x', Number(x) + Number(xWidth) + 10).attr('y', Number(y)).attr('fill', theme.labelColor).attr('dominant-baseline', 'hanging').attr('font-size', _utils.BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
+      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('x', Number(x) + Number(xWidth) + 10).attr('y', Number(y)).attr('fill', theme.labelColor).attr('dominant-baseline', 'hanging').attr('font-size', BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
         if (g.node()) {
           var _g$node;
           const {
@@ -1053,7 +1169,7 @@ class ChartComponent extends _react.Component {
         label_font_size,
         text
       } = _ref8;
-      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('fill', theme.labelColor).attr('font-size', _utils.BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
+      d3.select(container).append('text').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('fill', theme.labelColor).attr('font-size', BaseUtils.getLabelFontSize(label_font_size)).text(text).call(g => {
         if (!g.node()) return;
         const {
           width,
@@ -1061,7 +1177,7 @@ class ChartComponent extends _react.Component {
         } = g.node().getBoundingClientRect();
         const translateX = Number(x) + xWidth / 2 - width / 2;
         let translateY = Number(y) + Number(yheight / 2) + height / 2;
-        if (chartType === _constants.CHART_TYPE.BAR_STACK) {
+        if (chartType === CHART_TYPE.BAR_STACK) {
           translateY = translateY;
         }
         g.attr('transform', `translate(${translateX}, ${translateY})`);
@@ -1072,8 +1188,8 @@ class ChartComponent extends _react.Component {
         allGroup.forEach(g => {
           const rects = Array.from(g.children).filter(item => item.tagName !== 'text');
           rects.forEach(item => {
-            d3.select(item).transition().duration(this.transitionDuration).attr('opacity', 1);
-            if ([_constants.CHART_TYPE.PIE, _constants.CHART_TYPE.RING].includes(chartType)) {
+            d3.select(item).transition().duration(this.interactionDuration).attr('opacity', 1);
+            if ([CHART_TYPE.PIE, CHART_TYPE.RING].includes(chartType)) {
               d3.select(item).attr('stroke-width', 2);
             }
           });
@@ -1084,9 +1200,9 @@ class ChartComponent extends _react.Component {
           const rects = Array.from(g.children).filter(item => item.tagName !== 'text');
           rects.forEach(item => {
             if (item.getAttribute('data-groupName') !== curGroupName) {
-              d3.selectAll([item]).transition().duration(this.transitionDuration).attr('opacity', 0.3);
+              d3.selectAll([item]).transition().duration(this.interactionDuration).attr('opacity', 0.3);
             } else {
-              if ([_constants.CHART_TYPE.PIE, _constants.CHART_TYPE.RING].includes(chartType)) {
+              if ([CHART_TYPE.PIE, CHART_TYPE.RING].includes(chartType)) {
                 d3.select(item).attr('stroke-width', 0.5);
               }
             }
@@ -1094,37 +1210,222 @@ class ChartComponent extends _react.Component {
         });
       }
     };
-    // Use clipPath to make rectangle rounded corners
     this.addClipPath = _ref9 => {
       let {
         rect,
-        parentNode,
         attr,
-        rectId,
         borderRadiusVal
       } = _ref9;
+      return this.addRoundedClip(rect, attr === 'x' ? 'x' : 'y', null, borderRadiusVal);
+    };
+    this.addRoundedClip = function (rect, orient) {
+      let width = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      let radiusOverride = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
       const {
         borderRadius
-      } = this.chartBoundingClientRect;
-      const clipRect = d3.select(rect.cloneNode());
-      if (attr === 'x') {
-        const rectHeight = Number(rect.getAttribute('height'));
-        const rectWidth = Number(rect.getAttribute('width'));
-        const computedBorderRadius = Math.min(rectHeight * borderRadius, rectWidth / 2);
-        const safeBorderRadius = Math.min(borderRadiusVal !== null && borderRadiusVal !== void 0 ? borderRadiusVal : computedBorderRadius, rectWidth / 2, rectHeight / 2);
-        clipRect.attr('rx', safeBorderRadius);
-        clipRect.attr('x', Number(rect.getAttribute('x')) - safeBorderRadius).attr('width', rectWidth + safeBorderRadius);
+      } = _this.chartBoundingClientRect;
+      const x = Number(rect.getAttribute('x'));
+      const y = Number(rect.getAttribute('y'));
+      const w = width != null ? width : Number(rect.getAttribute('width'));
+      const h = Number(rect.getAttribute('height'));
+      const computedRadius = orient === 'x' ? Math.min(h * borderRadius, h / 2, w / 2) : Math.min(w * borderRadius, w / 2, h / 2);
+      const radius = radiusOverride != null ? Math.min(radiusOverride, w / 2, h / 2) : computedRadius;
+      const d = orient === 'x' ? _this.getRightRoundedRectPath(x, y, w, h, radius) : _this.getTopRoundedRectPath(x, y, w, h, radius);
+      const clipId = `rounded-clip-${Math.random().toString(36).slice(2)}`;
+      const path = _this.getDefs().append('clipPath').attr('id', clipId).append('path').attr('class', 'rounded-clip-path').attr('data-x', x).attr('data-y', y).attr('data-width', w).attr('data-height', h).attr('data-radius', radius).attr('data-orient', orient).attr('d', d);
+      d3.select(rect).attr('clip-path', `url(#${clipId})`);
+      _this._clipMaskByRect.set(rect, path.node());
+      return path.node();
+    };
+    this.animateMaskForRect = (rect, orient, baseline, t) => {
+      const path = this._clipMaskByRect && this._clipMaskByRect.get(rect);
+      if (!path) return;
+      const x = Number(path.getAttribute('data-x'));
+      const y = Number(path.getAttribute('data-y'));
+      const width = Number(path.getAttribute('data-width'));
+      const height = Number(path.getAttribute('data-height'));
+      const radius = Number(path.getAttribute('data-radius'));
+      const el = d3.select(path);
+      if (orient === 'x') {
+        const interpX = d3.interpolateNumber(baseline, x);
+        const interpW = d3.interpolateNumber(0, width);
+        el.attr('d', this.getRightRoundedRectPath(baseline, y, 0, height, radius)).transition(t).attrTween('d', () => tt => this.getRightRoundedRectPath(interpX(tt), y, interpW(tt), height, radius));
       } else {
-        const rectWidth = Number(rect.getAttribute('width'));
-        const rectHeight = Number(rect.getAttribute('height'));
-        const computedBorderRadius = Math.min(rectWidth * borderRadius, rectHeight / 2);
-        const safeBorderRadius = Math.min(borderRadiusVal !== null && borderRadiusVal !== void 0 ? borderRadiusVal : computedBorderRadius, rectWidth / 2, rectHeight / 2);
-        clipRect.attr('rx', safeBorderRadius);
-        clipRect.attr('height', rectHeight + safeBorderRadius);
+        const interpY = d3.interpolateNumber(baseline, y);
+        const interpH = d3.interpolateNumber(0, height);
+        el.attr('d', this.getTopRoundedRectPath(x, baseline, width, 0, radius)).transition(t).attrTween('d', () => tt => this.getTopRoundedRectPath(x, interpY(tt), width, interpH(tt), radius));
       }
-      const clipPath = d3.select(parentNode).append('clipPath').attr('opacity', 1).attr('id', rectId);
-      clipPath.node().appendChild(clipRect.node());
-      d3.select(rect).attr('clip-path', `url(#${rectId})`);
+    };
+    this.getTopRoundedRectPath = (x, y, width, height, radius) => {
+      const r = Math.min(radius, width / 2, height / 2);
+      if (height <= 0) return `M${x},${y} L${x + width},${y} L${x + width},${y} L${x},${y} Z`;
+      return `M${x},${y + r} Q${x},${y} ${x + r},${y} L${x + width - r},${y} Q${x + width},${y} ${x + width},${y + r} L${x + width},${y + height} L${x},${y + height} Z`;
+    };
+    this.getRightRoundedRectPath = (x, y, width, height, radius) => {
+      const r = Math.min(radius, width / 2, height / 2);
+      if (width <= 0) return `M${x},${y} L${x},${y + height} L${x},${y + height} L${x},${y} Z`;
+      return `M${x},${y} L${x + width - r},${y} Q${x + width},${y} ${x + width},${y + r} L${x + width},${y + height - r} Q${x + width},${y + height} ${x + width - r},${y + height} L${x},${y + height} Z`;
+    };
+    this.animateRectGrowInY = function (selection) {
+      let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const self = _this;
+      selection.each(function () {
+        const finalY = Number(this.getAttribute('y'));
+        const finalHeight = Number(this.getAttribute('height'));
+        if (!(finalHeight > 0)) return;
+        const baseline = finalY + finalHeight;
+        const t = d3.transition(self.enterTransitionName).duration(duration).ease(d3.easeCubicOut);
+        d3.select(this).attr('y', baseline).attr('height', 0).transition(t).attr('y', finalY).attr('height', finalHeight);
+        self.animateMaskForRect(this, 'y', baseline, t);
+      });
+    };
+    this.animateStackGrowInY = function (selection) {
+      let groupKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node => node.getAttribute('x');
+      let duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this.transitionDuration;
+      if (!selection || selection.empty()) return null;
+      const columns = new Map();
+      selection.each(function () {
+        if (!(Number(this.getAttribute('height')) > 0)) return;
+        const key = groupKey(this);
+        if (!columns.has(key)) columns.set(key, []);
+        columns.get(key).push(this);
+      });
+      if (columns.size === 0) return null;
+      const t = d3.transition(_this.enterTransitionName).duration(duration).ease(d3.easeCubicOut);
+      columns.forEach(rects => {
+        let baselineY = -Infinity;
+        rects.forEach(rect => {
+          baselineY = Math.max(baselineY, Number(rect.getAttribute('y')) + Number(rect.getAttribute('height')));
+        });
+        rects.forEach(rect => {
+          const finalY = Number(rect.getAttribute('y'));
+          const finalHeight = Number(rect.getAttribute('height'));
+          d3.select(rect).attr('y', baselineY).attr('height', 0).transition(t).attr('y', finalY).attr('height', finalHeight);
+          _this.animateMaskForRect(rect, 'y', baselineY, t);
+        });
+      });
+      return t;
+    };
+    this.animateRectGrowInX = function (selection) {
+      let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const self = _this;
+      selection.each(function () {
+        const finalX = Number(this.getAttribute('x'));
+        const finalWidth = Number(this.getAttribute('width'));
+        if (!(finalWidth > 0)) return;
+        const t = d3.transition(self.enterTransitionName).duration(duration).ease(d3.easeCubicOut);
+        d3.select(this).attr('width', 0).transition(t).attr('width', finalWidth);
+        self.animateMaskForRect(this, 'x', finalX, t);
+      });
+    };
+    this.animateStackGrowInX = function (selection) {
+      let groupKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node => node.getAttribute('y');
+      let duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this.transitionDuration;
+      if (!selection || selection.empty()) return null;
+      const rows = new Map();
+      selection.each(function () {
+        if (!(Number(this.getAttribute('width')) > 0)) return;
+        const key = groupKey(this);
+        if (!rows.has(key)) rows.set(key, []);
+        rows.get(key).push(this);
+      });
+      if (rows.size === 0) return null;
+      const t = d3.transition(_this.enterTransitionName).duration(duration).ease(d3.easeCubicOut);
+      rows.forEach(rects => {
+        let baselineX = Infinity;
+        rects.forEach(rect => {
+          baselineX = Math.min(baselineX, Number(rect.getAttribute('x')));
+        });
+        rects.forEach(rect => {
+          const finalX = Number(rect.getAttribute('x'));
+          const finalWidth = Number(rect.getAttribute('width'));
+          d3.select(rect).attr('x', baselineX).attr('width', 0).transition(t).attr('x', finalX).attr('width', finalWidth);
+          _this.animateMaskForRect(rect, 'x', baselineX, t);
+        });
+      });
+      return t;
+    };
+    this.animateArcGrowIn = function (selection, arc) {
+      let duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const transitionName = _this.enterTransitionName;
+      selection.each(function (d) {
+        const path = d3.select(this);
+        const interpolate = d3.interpolate({
+          startAngle: d.startAngle,
+          endAngle: d.startAngle,
+          padAngle: d.padAngle
+        }, {
+          startAngle: d.startAngle,
+          endAngle: d.endAngle,
+          padAngle: d.padAngle
+        });
+        path.attr('d', arc(interpolate(0))).transition(transitionName).duration(duration).ease(d3.easeCubicOut).attrTween('d', () => t => arc(interpolate(t)));
+      });
+    };
+    this.animatePathDrawIn = function (selection) {
+      let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const transitionName = _this.enterTransitionName;
+      selection.each(function () {
+        const path = d3.select(this);
+        let totalLength = 0;
+        try {
+          totalLength = this.getTotalLength();
+        } catch (e) {
+          totalLength = 0;
+        }
+        if (!(totalLength > 0)) return;
+        path.attr('stroke-dasharray', `${totalLength} ${totalLength}`).attr('stroke-dashoffset', totalLength).transition(transitionName).duration(duration).ease(d3.easeLinear).attr('stroke-dashoffset', 0).on('end', function () {
+          d3.select(this).attr('stroke-dasharray', null).attr('stroke-dashoffset', null);
+        });
+      });
+    };
+    this.animateRevealInX = function (selection, width) {
+      let duration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const {
+        height: chartHeight
+      } = _this.chartBoundingClientRect;
+      const clipId = `reveal-clip-${Math.random().toString(36).slice(2)}`;
+      const clipPath = _this.getDefs().append('clipPath').attr('id', clipId);
+      const clipRect = clipPath.append('rect').attr('x', 0).attr('y', 0).attr('width', 0).attr('height', chartHeight);
+      selection.attr('clip-path', `url(#${clipId})`);
+      clipRect.transition(_this.enterTransitionName).duration(duration).ease(d3.easeLinear).attr('width', width).on('end', () => {
+        selection.attr('clip-path', null);
+        clipPath.remove();
+      });
+    };
+    this.animateFadeIn = function (selection) {
+      let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.transitionDuration;
+      let delay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      let finalOpacity = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+      if (!selection || selection.empty()) return;
+      const transitionName = _this.enterTransitionName;
+      selection.each(function () {
+        const el = d3.select(this);
+        let target = finalOpacity;
+        if (target == null) {
+          const orig = this.getAttribute('opacity');
+          const parsed = orig === null || orig === '' ? 1 : Number(orig);
+          target = Number.isNaN(parsed) ? 1 : parsed;
+        }
+        if (!(target > 0)) return;
+        el.attr('opacity', 0).transition(transitionName).duration(duration).delay(delay).ease(d3.easeLinear).attr('opacity', target);
+      });
+    };
+    this.animateCircleZoomIn = function (selection) {
+      let duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _this.transitionDuration;
+      if (!selection || selection.empty()) return;
+      const transitionName = _this.enterTransitionName;
+      selection.each(function () {
+        const circle = d3.select(this);
+        const finalR = Number(this.getAttribute('r')) || 0;
+        if (!(finalR > 0)) return;
+        circle.attr('r', 0).transition(transitionName).duration(duration).ease(d3.easeCubicOut).attr('r', finalR);
+      });
     };
     this.drawYaxis = function (g, theme) {
       let rightAxisOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
@@ -1138,33 +1439,92 @@ class ChartComponent extends _react.Component {
       // add text
       g.selectAll('text').attr('font-size', theme.fontSize);
       g.selectAll('text').attr('fill', theme.textColor);
+      _this.thinYAxisTicks(g);
       _this.checkTextOverflow(g.selectAll('text').nodes());
 
       // line
       g.selectAll('line').node() && g.selectAll('line').node().remove(); // delete the first line
-      g.selectAll('.tick line').clone().attr('x2', chartWidth - insertPadding * 2 - _this.horizontalOverflowOffset - rightAxisOffset).attr('stroke', theme.gridColor).attr('stroke-dasharray', '8,3');
+      g.selectAll('.tick line').clone().attr('x2', chartWidth - _this.getYAxisTranslateX() - insertPadding - rightAxisOffset).attr('stroke', theme.gridColor).attr('stroke-dasharray', '8,3');
 
       // update g translateX
-      g.attr('transform', `translate(${insertPadding + _this.horizontalOverflowOffset}, 0)`);
+      g.attr('transform', `translate(${_this.getYAxisTranslateX()}, 0)`);
+    };
+    this.thinYAxisTicks = g => {
+      const ticks = g.selectAll('.tick').nodes();
+      if (ticks.length <= 2) return;
+      const visibleTicks = ticks.map((tick, index) => {
+        const text = d3.select(tick).select('text').node();
+        if (!text) return null;
+        const {
+          top,
+          bottom
+        } = text.getBoundingClientRect();
+        return {
+          tick,
+          index,
+          top,
+          bottom
+        };
+      }).filter(Boolean).sort((a, b) => a.top - b.top);
+      const keptTicks = [];
+      let prevBottom = -Infinity;
+      visibleTicks.forEach(_ref10 => {
+        let {
+          tick,
+          index,
+          top,
+          bottom
+        } = _ref10;
+        const shouldKeepFirstTick = index === 0;
+        const shouldKeepLastTick = index === ticks.length - 1;
+        const hasEnoughSpace = top > prevBottom + this.yAxisTickLabelGap;
+        if (shouldKeepLastTick) {
+          keptTicks.forEach(keptTick => {
+            if (keptTick.bottom + this.yAxisTickLabelGap >= top) {
+              d3.select(keptTick.tick).attr('opacity', 0);
+            }
+          });
+          d3.select(tick).attr('opacity', 1);
+          return;
+        }
+        if (shouldKeepFirstTick || hasEnoughSpace) {
+          d3.select(tick).attr('opacity', 1);
+          keptTicks.push({
+            tick,
+            bottom
+          });
+          prevBottom = bottom;
+          return;
+        }
+        d3.select(tick).attr('opacity', 0);
+      });
     };
     this.checkTextOverflow = allTextEl => {
       const {
         insertPadding
       } = this.chartBoundingClientRect;
       const allTextWidth = allTextEl.map(item => {
+        const tick = item.parentNode;
+        if (tick && Number(tick.getAttribute('opacity')) === 0) return 0;
         const {
           width
         } = item.getBoundingClientRect();
         return width;
       });
-      const maxTextWidth = Math.max(...allTextWidth);
+      const maxTextWidth = Math.max(...allTextWidth, 0);
       this.horizontalOverflowOffset = 0;
-      if (maxTextWidth + 3 > insertPadding) {
-        // horizontal overflow
-        const offset = maxTextWidth + 3 - insertPadding; // 3 is text and line default spacing
+      const requiredLeftSpace = maxTextWidth + 3;
+      if (requiredLeftSpace > insertPadding) {
+        const offset = requiredLeftSpace - insertPadding;
         this.horizontalOverflowOffset = offset;
       }
     };
+    this.getYAxisTranslateX = () => {
+      const {
+        insertPadding
+      } = this.chartBoundingClientRect;
+      return insertPadding + this.horizontalOverflowOffset;
+    };
     this.checkTickOverlap = (g, axis) => {
       const allTicks = g.selectAll('.tick').nodes();
       if (axis === 'yAxis') {
@@ -1316,10 +1676,85 @@ class ChartComponent extends _react.Component {
       const annotationWrapper = contentWrapper.insert('g', ':first-child').attr('class', 'vertical-annotation-wrapper');
       annotationWrapper.append('line').attr('x1', x).attr('y1', insertPadding + marginTop).attr('x2', x).attr('y2', chartHeight - insertPadding).attr('stroke', theme.XAxisColor);
     };
+    this.setLegendForHeatMap = _ref11 => {
+      let {
+        exampleColors,
+        themeColors
+      } = _ref11;
+      const legendOffsetY = 3;
+      const legendItemTextWidth = 32;
+      const legendItemWidth = 12;
+      const legendItemHeight = 12;
+      const legendItemGap = 3;
+      const legendItemRadius = 2;
+      const legendWrapper = this.chart.append('g').attr('class', 'legend-heat-map-wrapper').attr('transform', `translate(0, ${legendOffsetY})`);
+      legendWrapper.append('text').attr('y', 10).attr('fill', themeColors.textColor).attr('font-size', 12).attr('font-weight', 'bold').text(intl.get('Less'));
+      exampleColors.forEach((color, index) => {
+        legendWrapper.append('rect').attr('x', legendItemTextWidth + index * legendItemWidth + index * legendItemGap).attr('width', legendItemWidth).attr('height', legendItemHeight).attr('rx', legendItemRadius).attr('fill', color).attr('stroke', FILL_BORDER_COLOR_MAP[color]).attr('stroke-width', 1);
+      });
+      legendWrapper.append('text').attr('x', 182).attr('y', 10).attr('fill', themeColors.textColor).attr('font-size', 12).attr('font-weight', 'bold').text(intl.get('More'));
+    };
+    this.setContinuousLegend = _ref12 => {
+      var _this$chart$node2;
+      let {
+        previewType,
+        theme,
+        colorRange = [],
+        legendDirection,
+        legendSize,
+        legendTextRange,
+        bubbleColor,
+        type
+      } = _ref12;
+      const {
+        width: chartWidth,
+        height: chartHeight,
+        insertPadding
+      } = this.chartBoundingClientRect;
+      const legendRectWidth = legendDirection === 'vertical' ? 12 : Math.min(legendSize * 100, chartWidth - insertPadding * 2);
+      const legendRectHeight = legendDirection === 'vertical' ? Math.min(legendSize * 100, chartHeight - insertPadding * 2) : 12;
+      const legendTextOffset = 2;
+      const legendTextHeightSpace = legendDirection === 'vertical' ? 0 : 14 + legendTextOffset;
+      if (![CHART_TYPE.MAP_BUBBLE, CHART_TYPE.WORLD_MAP_BUBBLE].includes(type)) {
+        var _this$chart$node;
+        const gradient = this.chart.append('defs').attr('class', 'linear-gradient-wrapper').append('linearGradient').attr("id", `gradient-${(_this$chart$node = this.chart.node()) === null || _this$chart$node === void 0 ? void 0 : _this$chart$node.id}-${previewType}`).attr("x1", '0%').attr("y1", '0%').attr("x2", legendDirection === 'vertical' ? '0%' : '100%').attr("y2", legendDirection === 'vertical' ? '100%' : '0%');
+        gradient.append('stop').attr('offset', '0%').attr('stop-color', `${colorRange[0]}`);
+        gradient.append('stop').attr('offset', '50%').attr('stop-color', `${colorRange[4]}`);
+        gradient.append('stop').attr('offset', '100%').attr('stop-color', `${colorRange[8]}`);
+      }
+      const continuousLegendWrapper = this.chart.append('g').attr('class', 'legend-continuous-wrapper').attr('transform', `translate(0, ${chartHeight - legendRectHeight - legendTextHeightSpace})`);
+      continuousLegendWrapper.append('rect').attr('width', legendRectWidth).attr('height', legendRectHeight).attr('fill', [CHART_TYPE.MAP_BUBBLE, CHART_TYPE.WORLD_MAP_BUBBLE].includes(type) ? bubbleColor : `url(#gradient-${(_this$chart$node2 = this.chart.node()) === null || _this$chart$node2 === void 0 ? void 0 : _this$chart$node2.id}-${previewType})`).call(g => {
+        if ([CHART_TYPE.MAP_BUBBLE, CHART_TYPE.WORLD_MAP_BUBBLE].includes(type)) {
+          continuousLegendWrapper.append('polygon').attr('points', `0,0  ${legendRectWidth - 0.5},0  0,${legendRectHeight - 0.5}`).attr('fill', '#fff').attr('stroke', '#fff');
+        }
+      });
+      continuousLegendWrapper.append('text').attr('class', 'range-start').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('fill', theme.labelColor).text(legendTextRange[0]).call(g => {
+        const {
+          height
+        } = g.node().getBoundingClientRect();
+        g.attr('x', legendDirection === 'vertical' ? legendRectWidth + legendTextOffset : legendTextOffset);
+        g.attr('y', legendDirection === 'vertical' ? height : height + legendRectHeight);
+      });
+      continuousLegendWrapper.append('text').attr('class', 'range-end').attr('stroke', '#fff').attr('stroke-width', 1).attr('paint-order', 'stroke').attr('fill', theme.labelColor).text(legendTextRange[1]).call(g => {
+        const {
+          width,
+          height
+        } = g.node().getBoundingClientRect();
+        g.attr('x', legendDirection === 'vertical' ? legendRectWidth + legendTextOffset : legendRectWidth - width);
+        g.attr('y', legendDirection === 'vertical' ? legendRectHeight - legendTextOffset : height + legendRectHeight);
+      });
+    };
     this.initLabelStroke(props === null || props === void 0 ? void 0 : props.globalTheme);
     this.chartBoundingClientRect = {};
-    this.transitionDuration = 500;
+    this.transitionDuration = 450;
+    this.interactionDuration = 150;
     this.areaTransitionDuration = 200;
+    this.yAxisTickLabelGap = 4;
+    this.axisTitleMinHeight = 20;
+    this.enterTransitionName = 'enter';
+    this._defs = null;
+    this._clipMaskByRect = new Map();
+    this.hiddenLegendGroups = new Set();
   }
   componentDidMount() {
     window.addEventListener('resize', this.handleResize);
@@ -1332,5 +1767,4 @@ class ChartComponent extends _react.Component {
   componentWillUnmount() {
     window.removeEventListener('resize', this.handleResize);
   }
-}
-exports.default = ChartComponent;
+}