antd-management-fast-framework 1.1.64 → 1.1.65

package/es/customComponents/Charts/WaterWave/index.d.ts

@@ -0,0 +1,11 @@
+export default WaterWave;
+declare class WaterWave extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    timer: number;
+    root: null;
+    node: null;
+    resize: () => void;
+    renderChart(type: any): void;
+}
+import React from "react";

package/es/customComponents/Charts/WaterWave/index.js

@@ -0,0 +1,319 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _autoHeight = _interopRequireDefault(require("../autoHeight"));
+
+var _index = _interopRequireDefault(require("./index.less"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } 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); }
+
+/* eslint no-return-assign: 0 */
+
+/* eslint no-mixed-operators: 0 */
+// riddle: https://riddle.alibaba-inc.com/riddles/2d9a4b90
+var WaterWave = /*#__PURE__*/function (_Component) {
+  _inherits(WaterWave, _Component);
+
+  var _super = _createSuper(WaterWave);
+
+  function WaterWave() {
+    var _this;
+
+    _classCallCheck(this, WaterWave);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      radio: 1
+    };
+    _this.timer = 0;
+    _this.root = null;
+    _this.node = null;
+
+    _this.resize = function () {
+      if (_this.root) {
+        var _this$props$height = _this.props.height,
+            height = _this$props$height === void 0 ? 1 : _this$props$height;
+        var offsetWidth = _this.root.parentNode.offsetWidth;
+
+        _this.setState({
+          radio: offsetWidth < height ? offsetWidth / height : 1
+        });
+      }
+    };
+
+    return _this;
+  }
+
+  _createClass(WaterWave, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this2 = this;
+
+      this.renderChart();
+      this.resize();
+      window.addEventListener('resize', function () {
+        requestAnimationFrame(function () {
+          return _this2.resize();
+        });
+      }, {
+        passive: true
+      });
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(props) {
+      var percent = this.props.percent;
+
+      if (props.percent !== percent) {
+        // 不加这个会造成绘制缓慢
+        this.renderChart('update');
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      cancelAnimationFrame(this.timer);
+
+      if (this.node) {
+        this.node.innerHTML = '';
+      }
+
+      window.removeEventListener('resize', this.resize);
+    }
+  }, {
+    key: "renderChart",
+    value: function renderChart(type) {
+      var _this$props = this.props,
+          percent = _this$props.percent,
+          _this$props$color = _this$props.color,
+          color = _this$props$color === void 0 ? '#1890FF' : _this$props$color;
+      var data = percent / 100;
+      var self = this;
+      cancelAnimationFrame(this.timer);
+
+      if (!this.node || data !== 0 && !data) {
+        return;
+      }
+
+      var canvas = this.node;
+      var ctx = canvas.getContext('2d');
+
+      if (!ctx) {
+        return;
+      }
+
+      var canvasWidth = canvas.width;
+      var canvasHeight = canvas.height;
+      var radius = canvasWidth / 2;
+      var lineWidth = 2;
+      var cR = radius - lineWidth;
+      ctx.beginPath();
+      ctx.lineWidth = lineWidth * 2;
+      var axisLength = canvasWidth - lineWidth;
+      var unit = axisLength / 8;
+      var range = 0.2; // 振幅
+
+      var currRange = range;
+      var xOffset = lineWidth;
+      var sp = 0; // 周期偏移量
+
+      var currData = 0;
+      var waveupsp = 0.005; // 水波上涨速度
+
+      var arcStack = [];
+      var bR = radius - lineWidth;
+      var circleOffset = -(Math.PI / 2);
+      var circleLock = true;
+
+      for (var i = circleOffset; i < circleOffset + 2 * Math.PI; i += 1 / (8 * Math.PI)) {
+        arcStack.push([radius + bR * Math.cos(i), radius + bR * Math.sin(i)]);
+      }
+
+      var cStartPoint = arcStack.shift();
+      ctx.strokeStyle = color;
+      ctx.moveTo(cStartPoint[0], cStartPoint[1]);
+
+      function drawSin() {
+        if (!ctx) {
+          return;
+        }
+
+        ctx.beginPath();
+        ctx.save();
+        var sinStack = [];
+
+        for (var _i = xOffset; _i <= xOffset + axisLength; _i += 20 / axisLength) {
+          var x = sp + (xOffset + _i) / unit;
+          var y = Math.sin(x) * currRange;
+          var dx = _i;
+          var dy = 2 * cR * (1 - currData) + (radius - cR) - unit * y;
+          ctx.lineTo(dx, dy);
+          sinStack.push([dx, dy]);
+        }
+
+        var startPoint = sinStack.shift();
+        ctx.lineTo(xOffset + axisLength, canvasHeight);
+        ctx.lineTo(xOffset, canvasHeight);
+        ctx.lineTo(startPoint[0], startPoint[1]);
+        var gradient = ctx.createLinearGradient(0, 0, 0, canvasHeight);
+        gradient.addColorStop(0, '#ffffff');
+        gradient.addColorStop(1, color);
+        ctx.fillStyle = gradient;
+        ctx.fill();
+        ctx.restore();
+      }
+
+      function render() {
+        if (!ctx) {
+          return;
+        }
+
+        ctx.clearRect(0, 0, canvasWidth, canvasHeight);
+
+        if (circleLock && type !== 'update') {
+          if (arcStack.length) {
+            var temp = arcStack.shift();
+            ctx.lineTo(temp[0], temp[1]);
+            ctx.stroke();
+          } else {
+            circleLock = false;
+            ctx.lineTo(cStartPoint[0], cStartPoint[1]);
+            ctx.stroke();
+            arcStack = [];
+            ctx.globalCompositeOperation = 'destination-over';
+            ctx.beginPath();
+            ctx.lineWidth = lineWidth;
+            ctx.arc(radius, radius, bR, 0, 2 * Math.PI, true);
+            ctx.beginPath();
+            ctx.save();
+            ctx.arc(radius, radius, radius - 3 * lineWidth, 0, 2 * Math.PI, true);
+            ctx.restore();
+            ctx.clip();
+            ctx.fillStyle = color;
+          }
+        } else {
+          if (data >= 0.85) {
+            if (currRange > range / 4) {
+              var t = range * 0.01;
+              currRange -= t;
+            }
+          } else if (data <= 0.1) {
+            if (currRange < range * 1.5) {
+              var _t = range * 0.01;
+
+              currRange += _t;
+            }
+          } else {
+            if (currRange <= range) {
+              var _t2 = range * 0.01;
+
+              currRange += _t2;
+            }
+
+            if (currRange >= range) {
+              var _t3 = range * 0.01;
+
+              currRange -= _t3;
+            }
+          }
+
+          if (data - currData > 0) {
+            currData += waveupsp;
+          }
+
+          if (data - currData < 0) {
+            currData -= waveupsp;
+          }
+
+          sp += 0.07;
+          drawSin();
+        }
+
+        self.timer = requestAnimationFrame(render);
+      }
+
+      render();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+
+      var radio = this.state.radio;
+      var _this$props2 = this.props,
+          percent = _this$props2.percent,
+          title = _this$props2.title,
+          _this$props2$height = _this$props2.height,
+          height = _this$props2$height === void 0 ? 1 : _this$props2$height;
+      return /*#__PURE__*/_react["default"].createElement(_autoHeight["default"], null, /*#__PURE__*/_react["default"].createElement("div", {
+        className: _index["default"].waterWave,
+        ref: function ref(n) {
+          return _this3.root = n;
+        },
+        style: {
+          transform: "scale(".concat(radio, ")"),
+          height: "100%"
+        }
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        style: {
+          width: height,
+          height: height,
+          overflow: 'hidden'
+        }
+      }, /*#__PURE__*/_react["default"].createElement("canvas", {
+        className: _index["default"].waterWaveCanvasWrapper,
+        ref: function ref(n) {
+          return _this3.node = n;
+        },
+        width: height * 2,
+        height: height * 2
+      })), /*#__PURE__*/_react["default"].createElement("div", {
+        className: _index["default"].text,
+        style: {
+          width: height
+        }
+      }, title && /*#__PURE__*/_react["default"].createElement("span", null, title), /*#__PURE__*/_react["default"].createElement("h4", null, percent, "%"))));
+    }
+  }]);
+
+  return WaterWave;
+}(_react.Component);
+
+var _default = WaterWave;
+exports["default"] = _default;

package/es/customComponents/Charts/autoHeight.d.ts

@@ -0,0 +1,8 @@
+export default AutoHeightComponent;
+declare class AutoHeightComponent extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    root: undefined;
+    handleRoot: (node: any) => void;
+}
+import React from "react";

package/es/customComponents/Charts/autoHeight.js

@@ -0,0 +1,123 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } 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 computeHeight(node) {
+  var style = node.style;
+  style.height = '100%';
+  var totalHeight = parseInt("".concat(getComputedStyle(node).height), 10);
+  var padding = parseInt("".concat(getComputedStyle(node).paddingTop), 10) + parseInt("".concat(getComputedStyle(node).paddingBottom), 10);
+  return totalHeight - padding;
+}
+
+function getAutoHeight(n) {
+  if (!n) {
+    return 0;
+  }
+
+  var node = n;
+  var height = computeHeight(node);
+  var parentNode = node.parentNode;
+
+  if (parentNode) {
+    height = computeHeight(parentNode);
+  }
+
+  return height;
+}
+
+var AutoHeightComponent = /*#__PURE__*/function (_React$Component) {
+  _inherits(AutoHeightComponent, _React$Component);
+
+  var _super = _createSuper(AutoHeightComponent);
+
+  function AutoHeightComponent() {
+    var _this;
+
+    _classCallCheck(this, AutoHeightComponent);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      computedHeight: 0
+    };
+    _this.root = undefined;
+
+    _this.handleRoot = function (node) {
+      _this.root = node;
+    };
+
+    return _this;
+  }
+
+  _createClass(AutoHeightComponent, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var height = this.props.height;
+
+      if (!height) {
+        var h = getAutoHeight(this.root);
+        this.setState({
+          computedHeight: h
+        });
+
+        if (h < 1) {
+          h = getAutoHeight(this.root);
+          this.setState({
+            computedHeight: h
+          });
+        }
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var height = this.props.height;
+      var computedHeight = this.state.computedHeight;
+      var h = height || computedHeight;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        ref: this.handleRoot,
+        style: {
+          height: "".concat(h, "px")
+        }
+      }, h > 0 ? this.props.children : null);
+    }
+  }]);
+
+  return AutoHeightComponent;
+}(_react["default"].Component);
+
+var _default = AutoHeightComponent;
+exports["default"] = _default;

package/es/customComponents/Charts/bizcharts.d.ts

@@ -0,0 +1,2 @@
+export default BizChart;
+import * as BizChart from "bizcharts";

package/es/customComponents/Charts/bizcharts.js

@@ -0,0 +1,17 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var BizChart = _interopRequireWildcard(require("bizcharts"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = BizChart;
+exports["default"] = _default;

package/es/customComponents/Charts/index.d.ts

@@ -0,0 +1,27 @@
+declare namespace Charts {
+    export { yuan };
+    export { Bar };
+    export { Pie };
+    export { Gauge };
+    export { MiniBar };
+    export { MiniArea };
+    export { MiniProgress };
+    export { ChartCard };
+    export { Field };
+    export { WaterWave };
+    export { TagCloud };
+    export { TimelineChart };
+}
+export function yuan(val: any): string;
+import Bar from "./Bar";
+import Pie from "./Pie";
+import Gauge from "./Gauge";
+import MiniBar from "./MiniBar";
+import MiniArea from "./MiniArea";
+import MiniProgress from "./MiniProgress";
+import ChartCard from "./ChartCard";
+import Field from "./Field";
+import WaterWave from "./WaterWave";
+import TagCloud from "./TagCloud";
+import TimelineChart from "./TimelineChart";
+export { Charts as default, Bar, Pie, Gauge, MiniBar, MiniArea, MiniProgress, ChartCard, Field, WaterWave, TagCloud, TimelineChart };

package/es/customComponents/Charts/index.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Bar", {
+  enumerable: true,
+  get: function get() {
+    return _Bar["default"];
+  }
+});
+Object.defineProperty(exports, "ChartCard", {
+  enumerable: true,
+  get: function get() {
+    return _ChartCard["default"];
+  }
+});
+Object.defineProperty(exports, "Field", {
+  enumerable: true,
+  get: function get() {
+    return _Field["default"];
+  }
+});
+Object.defineProperty(exports, "Gauge", {
+  enumerable: true,
+  get: function get() {
+    return _Gauge["default"];
+  }
+});
+Object.defineProperty(exports, "MiniArea", {
+  enumerable: true,
+  get: function get() {
+    return _MiniArea["default"];
+  }
+});
+Object.defineProperty(exports, "MiniBar", {
+  enumerable: true,
+  get: function get() {
+    return _MiniBar["default"];
+  }
+});
+Object.defineProperty(exports, "MiniProgress", {
+  enumerable: true,
+  get: function get() {
+    return _MiniProgress["default"];
+  }
+});
+Object.defineProperty(exports, "Pie", {
+  enumerable: true,
+  get: function get() {
+    return _Pie["default"];
+  }
+});
+Object.defineProperty(exports, "TagCloud", {
+  enumerable: true,
+  get: function get() {
+    return _TagCloud["default"];
+  }
+});
+Object.defineProperty(exports, "TimelineChart", {
+  enumerable: true,
+  get: function get() {
+    return _TimelineChart["default"];
+  }
+});
+Object.defineProperty(exports, "WaterWave", {
+  enumerable: true,
+  get: function get() {
+    return _WaterWave["default"];
+  }
+});
+exports.yuan = exports["default"] = void 0;
+
+var _numeral = _interopRequireDefault(require("numeral"));
+
+var _Bar = _interopRequireDefault(require("./Bar"));
+
+var _ChartCard = _interopRequireDefault(require("./ChartCard"));
+
+var _Field = _interopRequireDefault(require("./Field"));
+
+var _Gauge = _interopRequireDefault(require("./Gauge"));
+
+var _MiniArea = _interopRequireDefault(require("./MiniArea"));
+
+var _MiniBar = _interopRequireDefault(require("./MiniBar"));
+
+var _MiniProgress = _interopRequireDefault(require("./MiniProgress"));
+
+var _Pie = _interopRequireDefault(require("./Pie"));
+
+var _TagCloud = _interopRequireDefault(require("./TagCloud"));
+
+var _TimelineChart = _interopRequireDefault(require("./TimelineChart"));
+
+var _WaterWave = _interopRequireDefault(require("./WaterWave"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var yuan = function yuan(val) {
+  return "\xA5 ".concat((0, _numeral["default"])(val).format('0,0'));
+};
+
+exports.yuan = yuan;
+var Charts = {
+  yuan: yuan,
+  Bar: _Bar["default"],
+  Pie: _Pie["default"],
+  Gauge: _Gauge["default"],
+  MiniBar: _MiniBar["default"],
+  MiniArea: _MiniArea["default"],
+  MiniProgress: _MiniProgress["default"],
+  ChartCard: _ChartCard["default"],
+  Field: _Field["default"],
+  WaterWave: _WaterWave["default"],
+  TagCloud: _TagCloud["default"],
+  TimelineChart: _TimelineChart["default"]
+};
+exports["default"] = Charts;

package/es/customComponents/ColorText/index.d.ts

@@ -0,0 +1,18 @@
+export default ColorText;
+declare class ColorText extends React.PureComponent<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    copyText: () => void;
+}
+declare namespace ColorText {
+    namespace defaultProps {
+        const canCopy: boolean;
+        const randomSeed: number;
+        const seedOffset: number;
+        const randomColor: boolean;
+        const color: string;
+        const textPrefix: null;
+        const text: string;
+    }
+}
+import React from "react";