nsc-react-component 2.0.14 → 2.0.17

package/lib/base/chart/index.js

@@ -0,0 +1,353 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var _excluded = ["url", "listeners"];
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import React, { PureComponent } from "react";
+import * as echarts from "echarts";
+import Store from "@bj-nsc/msn";
+import { utils } from "@bj-nsc/msn/lib/utils";
+import { px2vw } from "../../utils";
+import { isArray, isObject } from "@bj-nsc/functions";
+
+//data示例
+
+/**
+ 数组：
+ data=[{name:'1月',value:20},{name:'2月',value:10},{name:'3月',value:25}]
+ 对象
+ data={name:['1月','2月','3月'],value:[20,30,40]}
+ */
+var NscChart = /*#__PURE__*/function (_PureComponent) {
+  _inherits(NscChart, _PureComponent);
+
+  var _super = _createSuper(NscChart);
+
+  function NscChart(props) {
+    var _this2;
+
+    _classCallCheck(this, NscChart);
+
+    _this2 = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this2), "chartRef", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized(_this2), "myChart", null);
+
+    _defineProperty(_assertThisInitialized(_this2), "store", {});
+
+    _defineProperty(_assertThisInitialized(_this2), "state", {
+      dataSource: null
+    });
+
+    _defineProperty(_assertThisInitialized(_this2), "isFirst", true);
+
+    var data = props.data,
+        _props$store = props.store,
+        store = _props$store === void 0 ? {} : _props$store,
+        children = props.children,
+        options = props.option,
+        _props$autoLoad = props.autoLoad,
+        autoLoad = _props$autoLoad === void 0 ? true : _props$autoLoad;
+
+    var url = store.url,
+        _store$listeners = store.listeners,
+        listenersPops = _store$listeners === void 0 ? {} : _store$listeners,
+        stores = _objectWithoutProperties(store, _excluded);
+
+    if (!children) {
+      if (!(data || url || options)) {
+        throw new Error("url、data、option不能都为空！");
+      }
+
+      var _this = _assertThisInitialized(_this2);
+
+      var storeProps = _objectSpread({
+        model: "model",
+        component: _assertThisInitialized(_this2),
+        listeners: {
+          onBeforeLoad: function onBeforeLoad(store, options) {
+            utils.callback(listenersPops.onBeforeLoad, _this, [store, options]);
+          },
+          load: function load(data, modelData, store) {
+            _this.setState({
+              dataSource: modelData
+            }, function () {
+              if (_this.isFirst && autoLoad) {
+                _this.init();
+
+                _this.isFirst = false;
+              }
+            });
+
+            utils.callback(listenersPops.load, _this, [data, modelData, store]);
+          },
+          dataChanged: function dataChanged(data, modelData, store) {
+            _this.setState({
+              dataSource: modelData
+            }, function () {
+              if (autoLoad) {
+                _this.init();
+              }
+            });
+
+            utils.callback(listenersPops.dataChanged, _this, [data, modelData, store]);
+          }
+        }
+      }, stores);
+
+      if (url && data == null) {
+        storeProps = _objectSpread(_objectSpread({}, {
+          autoLoad: true,
+          url: url
+        }), storeProps);
+      }
+
+      _this2.store = new Store(storeProps);
+    }
+
+    return _this2;
+  }
+
+  _createClass(NscChart, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props = this.props,
+          data = _this$props.data,
+          _this$props$autoLoad = _this$props.autoLoad,
+          autoLoad = _this$props$autoLoad === void 0 ? true : _this$props$autoLoad,
+          store = _this$props.store,
+          option = _this$props.option;
+
+      if (data && autoLoad) {
+        this.init();
+      } else if (!data && !(store !== null && store !== void 0 && store.url) && option) {
+        this.init();
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState, snapshot) {
+      var _this$props$autoLoad2 = this.props.autoLoad,
+          autoLoad = _this$props$autoLoad2 === void 0 ? true : _this$props$autoLoad2;
+
+      if (autoLoad) {
+        if (JSON.stringify(prevProps.data) !== JSON.stringify(this.props.data)) {
+          this.init();
+        } else if (JSON.stringify(prevProps.option) !== JSON.stringify(this.props.option)) {
+          this.init();
+        }
+      }
+    }
+  }, {
+    key: "reSetChart",
+    value: function reSetChart() {
+      this.init();
+    }
+  }, {
+    key: "isString",
+    value: function isString(v) {
+      return typeof v === "string";
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener("resize", this.handleChartResize.bind(this));
+    }
+  }, {
+    key: "isReplace",
+    value: function isReplace(v) {
+      return /^{.*}$/gi.test(v);
+    }
+  }, {
+    key: "replace",
+    value: function replace(v) {
+      return v.substring(1, v.length - 1);
+    }
+  }, {
+    key: "dataConversion",
+    value: function dataConversion(data, datas, dataMap) {
+      var _this3 = this;
+
+      var result;
+
+      if (data) {
+        if (this.isString(data) && this.isReplace(data)) {
+          result = dataMap[this.replace(data)];
+        } else if (isArray(data)) {
+          data.map(function (item) {
+            var v = item.value;
+
+            if (v && _this3.isReplace(v)) {
+              item.value = _this3.dataConversion(v, datas, dataMap);
+            }
+          });
+          result = data;
+        } else if (isObject(data)) {
+          result = [];
+
+          if (isArray(datas)) {
+            datas.map(function (item) {
+              var tempObj = {};
+
+              for (var key in item) {
+                var v = item[key];
+
+                if (_this3.isReplace(v)) {
+                  tempObj[key] = item[_this3.replace(v)];
+                } else {
+                  tempObj[key] = v;
+                }
+              }
+
+              result.push(tempObj);
+            });
+          }
+        }
+      }
+
+      return result;
+    }
+  }, {
+    key: "objectConversion",
+    value: function objectConversion(obj, datas, dataMap) {
+      var _this4 = this;
+
+      var tempObj;
+
+      if (obj) {
+        if (isArray(obj)) {
+          tempObj = _toConsumableArray(obj);
+          tempObj.map(function (item) {
+            if (item.data) {
+              item.data = _this4.dataConversion(item.data, datas, dataMap);
+            }
+          });
+        } else if (this.isString(obj)) {
+          tempObj = obj;
+          tempObj.data = this.dataConversion(tempObj, datas, dataMap);
+        } else if (isObject(obj)) {
+          tempObj = _objectSpread({}, obj);
+          tempObj.data = this.dataConversion(tempObj.data, datas, dataMap);
+        }
+      }
+
+      return tempObj;
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      var _myChart$getZr, _myChart$getZr2;
+
+      var _this$props2 = this.props,
+          option = _this$props2.option,
+          data = _this$props2.data,
+          OnClick = _this$props2.OnClick,
+          OnZrClick = _this$props2.OnZrClick;
+      var dataSource = this.state.dataSource;
+      var dataMap = {};
+      var newDatas = data || dataSource;
+
+      var newOption = _objectSpread({}, option);
+
+      if (isArray(newDatas)) {
+        newDatas.map(function (item) {
+          for (var key in item) {
+            if (dataMap[key] == null) {
+              dataMap[key] = [];
+            }
+
+            dataMap[key].push(item[key]);
+          }
+        });
+      } else if (isObject(newDatas)) {
+        dataMap = newDatas;
+      }
+
+      newOption.xAxis = this.objectConversion(newOption.xAxis, newDatas, dataMap);
+      newOption.yAxis = this.objectConversion(newOption.yAxis, newDatas, dataMap);
+      newOption.series = this.objectConversion(newOption.series, newDatas, dataMap);
+      var myChart = this.myChart = echarts.init(this.chartRef.current); //初始化echarts，通过ref属性获取dom
+
+      myChart.clear();
+      myChart.off("click");
+      myChart === null || myChart === void 0 ? void 0 : (_myChart$getZr = myChart.getZr()) === null || _myChart$getZr === void 0 ? void 0 : _myChart$getZr.off("click");
+      myChart.setOption(newOption);
+      myChart.on("click", function (params) {
+        OnClick && OnClick(params, myChart);
+      });
+      myChart === null || myChart === void 0 ? void 0 : (_myChart$getZr2 = myChart.getZr()) === null || _myChart$getZr2 === void 0 ? void 0 : _myChart$getZr2.on("click", function (params) {
+        OnZrClick && OnZrClick(params, myChart);
+      });
+      window.addEventListener("resize", this.handleChartResize.bind(this));
+    }
+  }, {
+    key: "handleChartResize",
+    value: function handleChartResize() {
+      if (this.myChart) {
+        this.myChart.resize();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props3 = this.props,
+          width = _this$props3.width,
+          height = _this$props3.height;
+      var boxStyle = {
+        width: typeof width == "number" ? px2vw(width) : width,
+        height: typeof height == "number" ? px2vw(height) : height
+      };
+      return /*#__PURE__*/React.createElement("div", {
+        style: boxStyle,
+        ref: this.chartRef
+      });
+    }
+  }]);
+
+  return NscChart;
+}(PureComponent);
+
+export default NscChart;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/components/base/chart/index.tsx"],"names":["React","PureComponent","echarts","Store","utils","px2vw","isArray","isObject","NscChart","props","createRef","dataSource","data","store","children","options","option","autoLoad","url","listeners","listenersPops","stores","Error","_this","storeProps","model","component","onBeforeLoad","callback","load","modelData","setState","isFirst","init","dataChanged","prevProps","prevState","snapshot","JSON","stringify","v","window","removeEventListener","handleChartResize","bind","test","substring","length","datas","dataMap","result","isString","isReplace","replace","map","item","value","dataConversion","tempObj","key","push","obj","OnClick","OnZrClick","state","newDatas","newOption","xAxis","objectConversion","yAxis","series","myChart","chartRef","current","clear","off","getZr","setOption","on","params","addEventListener","resize","width","height","boxStyle"],"mappings":"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","sourcesContent":["import React, { PureComponent } from \"react\";\r\nimport * as echarts from \"echarts\";\r\nimport { ECharts } from \"echarts/lib/echarts\";\r\nimport Store, { StoreProps } from \"@bj-nsc/msn\";\r\nimport { utils } from \"@bj-nsc/msn/lib/utils\";\r\nimport { px2vw } from \"../../utils\";\r\nimport { isArray, isObject } from \"@bj-nsc/functions\";\r\ninterface ChartProps {\r\n  store?: StoreProps;\r\n  option: any;\r\n  data?: Array<Object> | Object;\r\n  width: number | string; //图表宽度\r\n  height: number | string; //图表长度\r\n  autoLoad?: boolean; //数据改变，自动刷新图表,默认true\r\n  OnClick?: (params: any, e?: any) => void; //图表点击事件\r\n  OnZrClick?: (params: any, e?: any) => void; //图表点击事件\r\n  [proNames: string]: any;\r\n}\r\n\r\n//data示例\r\n/**\r\n 数组：\r\n data=[{name:'1月',value:20},{name:'2月',value:10},{name:'3月',value:25}]\r\n 对象\r\n data={name:['1月','2月','3月'],value:[20,30,40]}\r\n */\r\nclass NscChart extends PureComponent<ChartProps> {\r\n  chartRef = React.createRef<HTMLDivElement>();\r\n  myChart: ECharts | null = null;\r\n  store = {} as StoreProps;\r\n  state = {\r\n    dataSource: null,\r\n  };\r\n  isFirst = true;\r\n  constructor(props) {\r\n    super(props);\r\n    const {\r\n      data,\r\n      store = {},\r\n      children,\r\n      option: options,\r\n      autoLoad = true,\r\n    } = props;\r\n    const { url, listeners: listenersPops = {}, ...stores } = store;\r\n    if (!children) {\r\n      if (!(data || url || options)) {\r\n        throw new Error(\"url、data、option不能都为空！\");\r\n      }\r\n      let _this = this;\r\n      let storeProps = {\r\n        model: \"model\",\r\n        component: this,\r\n        listeners: {\r\n          onBeforeLoad: function (store, options) {\r\n            utils.callback(listenersPops.onBeforeLoad, _this, [store, options]);\r\n          },\r\n          load: function (data, modelData, store) {\r\n            _this.setState({ dataSource: modelData }, () => {\r\n              if (_this.isFirst && autoLoad) {\r\n                _this.init();\r\n                _this.isFirst = false;\r\n              }\r\n            });\r\n            utils.callback(listenersPops.load, _this, [data, modelData, store]);\r\n          },\r\n          dataChanged: function (data, modelData, store) {\r\n            _this.setState({ dataSource: modelData }, () => {\r\n              if (autoLoad) {\r\n                _this.init();\r\n              }\r\n            });\r\n            utils.callback(listenersPops.dataChanged, _this, [\r\n              data,\r\n              modelData,\r\n              store,\r\n            ]);\r\n          },\r\n        },\r\n        ...stores,\r\n      };\r\n      if (url && data == null) {\r\n        storeProps = {\r\n          ...{\r\n            autoLoad: true,\r\n            url: url,\r\n          },\r\n          ...storeProps,\r\n        };\r\n      }\r\n      this.store = new Store(storeProps);\r\n    }\r\n  }\r\n\r\n  componentDidMount() {\r\n    const { data, autoLoad = true, store, option } = this.props;\r\n    if (data && autoLoad) {\r\n      this.init();\r\n    } else if (!data && !store?.url && option) {\r\n      this.init();\r\n    }\r\n  }\r\n\r\n  componentDidUpdate(\r\n    prevProps: Readonly<ChartProps>,\r\n    prevState: Readonly<{}>,\r\n    snapshot?: any\r\n  ): void {\r\n    const { autoLoad = true } = this.props;\r\n    if (autoLoad) {\r\n      if (JSON.stringify(prevProps.data) !== JSON.stringify(this.props.data)) {\r\n        this.init();\r\n      } else if (\r\n        JSON.stringify(prevProps.option) !== JSON.stringify(this.props.option)\r\n      ) {\r\n        this.init();\r\n      }\r\n    }\r\n  }\r\n\r\n  reSetChart() {\r\n    this.init();\r\n  }\r\n  isString(v) {\r\n    return typeof v === \"string\";\r\n  }\r\n  componentWillUnmount() {\r\n    window.removeEventListener(\"resize\", this.handleChartResize.bind(this));\r\n  }\r\n\r\n  isReplace(v) {\r\n    return /^{.*}$/gi.test(v);\r\n  }\r\n  replace(v) {\r\n    return v.substring(1, v.length - 1);\r\n  }\r\n\r\n  dataConversion(data, datas, dataMap) {\r\n    let result;\r\n    if (data) {\r\n      if (this.isString(data) && this.isReplace(data)) {\r\n        result = dataMap[this.replace(data)];\r\n      } else if (isArray(data)) {\r\n        data.map((item) => {\r\n          let v = item.value;\r\n          if (v && this.isReplace(v)) {\r\n            item.value = this.dataConversion(v, datas, dataMap);\r\n          }\r\n        });\r\n        result = data;\r\n      } else if (isObject(data)) {\r\n        result = [];\r\n        if (isArray(datas)) {\r\n          datas.map((item) => {\r\n            var tempObj = {};\r\n            for (let key in item) {\r\n              let v = item[key];\r\n              if (this.isReplace(v)) {\r\n                tempObj[key] = item[this.replace(v)];\r\n              } else {\r\n                tempObj[key] = v;\r\n              }\r\n            }\r\n            result.push(tempObj);\r\n          });\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n  objectConversion(obj, datas, dataMap) {\r\n    let tempObj: any;\r\n    if (obj) {\r\n      if (isArray(obj)) {\r\n        tempObj = [...obj];\r\n        tempObj.map((item) => {\r\n          if (item.data) {\r\n            item.data = this.dataConversion(item.data, datas, dataMap);\r\n          }\r\n        });\r\n      } else if (this.isString(obj)) {\r\n        tempObj = obj;\r\n        tempObj.data = this.dataConversion(tempObj, datas, dataMap);\r\n      } else if (isObject(obj)) {\r\n        tempObj = { ...obj };\r\n        tempObj.data = this.dataConversion(tempObj.data, datas, dataMap);\r\n      }\r\n    }\r\n    return tempObj;\r\n  }\r\n  init() {\r\n    const { option, data, OnClick, OnZrClick } = this.props;\r\n    const { dataSource } = this.state;\r\n    let dataMap: any = {};\r\n    const newDatas = data || dataSource;\r\n    let newOption: any = { ...option };\r\n    if (isArray(newDatas)) {\r\n      newDatas.map((item) => {\r\n        for (let key in item) {\r\n          if (dataMap[key] == null) {\r\n            dataMap[key] = [];\r\n          }\r\n          dataMap[key].push(item[key]);\r\n        }\r\n      });\r\n    } else if (isObject(newDatas)) {\r\n      dataMap = newDatas;\r\n    }\r\n    newOption.xAxis = this.objectConversion(newOption.xAxis, newDatas, dataMap);\r\n    newOption.yAxis = this.objectConversion(newOption.yAxis, newDatas, dataMap);\r\n    newOption.series = this.objectConversion(\r\n      newOption.series,\r\n      newDatas,\r\n      dataMap\r\n    );\r\n    const myChart = (this.myChart = echarts.init(\r\n      this.chartRef.current as HTMLDivElement\r\n    )); //初始化echarts，通过ref属性获取dom\r\n    myChart.clear();\r\n    myChart.off(\"click\");\r\n    myChart?.getZr()?.off(\"click\");\r\n    myChart.setOption(newOption);\r\n    myChart.on(\"click\", function (params) {\r\n      OnClick && OnClick(params, myChart);\r\n    });\r\n    myChart?.getZr()?.on(\"click\", (params) => {\r\n      OnZrClick && OnZrClick(params, myChart);\r\n    });\r\n\r\n    window.addEventListener(\"resize\", this.handleChartResize.bind(this));\r\n  }\r\n\r\n  handleChartResize() {\r\n    if (this.myChart) {\r\n      this.myChart.resize();\r\n    }\r\n  }\r\n\r\n  render() {\r\n    const { width, height } = this.props;\r\n    const boxStyle = {\r\n      width: typeof width == \"number\" ? px2vw(width) : width,\r\n      height: typeof height == \"number\" ? px2vw(height) : height,\r\n    };\r\n    return <div style={boxStyle} ref={this.chartRef}></div>;\r\n  }\r\n}\r\n\r\nexport default NscChart;\r\n"]}