antd-management-fast-framework 1.1.64 → 1.1.65

package/es/customComponents/Canvas/RadarScanning/index.js

@@ -0,0 +1,247 @@
+"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 _tools = require("../../../utils/tools");
+
+var _Core2 = _interopRequireDefault(require("../Core"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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); }
+
+var rand = function rand(min, max) {
+  return ~~(Math.random() * (max - min + 1) + min);
+};
+
+var RadarScanning = /*#__PURE__*/function (_Core) {
+  _inherits(RadarScanning, _Core);
+
+  var _super = _createSuper(RadarScanning);
+
+  function RadarScanning() {
+    var _this;
+
+    _classCallCheck(this, RadarScanning);
+
+    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.orbs = [];
+
+    _this.doAfterDidMount = function (_ref) {
+      var canvasContext = _ref.canvasContext;
+
+      var _number = _objectSpread({}, _objectSpread({
+        number: 100
+      }, _this.props || {})),
+          number = _number.number;
+
+      var ctx = canvasContext;
+      ctx.lineCap = 'round';
+      var count = number;
+
+      while (count) {
+        _this.createOrb(_this.canvasWidth / 2, _this.canvasHeight / 2 + count * 2);
+
+        count -= 1;
+      }
+
+      _this.loop();
+    };
+
+    _this.getTrail = function () {
+      var _trail = _objectSpread({}, _objectSpread({
+        trail: true
+      }, _this.props || {})),
+          trail = _trail.trail;
+
+      return trail;
+    };
+
+    _this.turnOnMove = function () {
+      var c = _this.getCanvas();
+
+      c.addEventListener('mousemove', _this.orbGo, false);
+    };
+
+    _this.turnOffMove = function () {
+      var c = _this.getCanvas();
+
+      c.removeEventListener('mousemove', _this.orbGo, false);
+    };
+
+    _this.orbGo = function (e) {
+      var c = _this.getCanvas();
+
+      var mx = e.pageX - c.offsetLeft;
+      var my = e.pageY - c.offsetTop;
+
+      _this.createOrb(mx, my);
+    };
+
+    _this.clear = function () {
+      _this.orbs = [];
+    };
+
+    _this.loop = function () {
+      (0, _tools.requestAnimFrame)(_this.loop);
+
+      var ctx = _this.getCanvasContext();
+
+      if (ctx != null) {
+        var trail = _this.getTrail();
+
+        if (trail) {
+          ctx.fillStyle = 'rgba(0,0,0,.1)';
+          ctx.fillRect(0, 0, _this.canvasWidth, _this.canvasHeight);
+        } else {
+          ctx.clearRect(0, 0, _this.canvasWidth, _this.canvasHeight);
+        }
+
+        var i = _this.orbs.length;
+
+        while (i) {
+          var orb = _this.orbs[i];
+
+          if ((orb || null) != null) {
+            var updateCount = 3;
+
+            while (updateCount) {
+              var o = _this.createOrbByExist(orb);
+
+              _this.drawOrb(ctx, o);
+
+              updateCount -= 1;
+            }
+          }
+
+          i -= 1;
+        }
+      }
+    };
+
+    _this.createOrb = function (mx, my) {
+      var dx = _this.canvasWidth / 2 - mx;
+      var dy = _this.canvasHeight / 2 - my;
+      var dist = Math.sqrt(dx * dx + dy * dy);
+      var angle = Math.atan2(dy, dx);
+      var o = {
+        x: mx,
+        y: my,
+        lastX: mx,
+        lastY: my,
+        hue: 0,
+        colorAngle: 0,
+        angle: angle + Math.PI / 2,
+        // size: .5+dist/250,
+        size: rand(1, 3) / 2,
+        centerX: _this.canvasWidth / 2,
+        centerY: _this.canvasHeight / 2,
+        radius: dist,
+        speed: rand(5, 10) / 1000 * (dist / 750) + 0.015 - 0.009,
+        alpha: 1 - Math.abs(dist) / _this.canvasWidth
+      };
+
+      _this.orbs.push(o);
+    };
+
+    _this.drawOrb = function (ctx, orb) {
+      ctx.strokeStyle = "hsla(".concat(orb.colorAngle, ",100%,50%,1)");
+      ctx.lineWidth = orb.size;
+      ctx.beginPath();
+      ctx.moveTo(orb.lastX, orb.lastY);
+      ctx.lineTo(orb.x, orb.y);
+      ctx.stroke();
+    };
+
+    _this.createOrbByExist = function (o) {
+      var orb = o;
+      var mxNew = orb.x;
+      var myNew = orb.y;
+      var x1 = _this.canvasWidth / 2;
+      var y1 = _this.canvasHeight / 2;
+      var x2 = mxNew;
+      var y2 = myNew;
+      var rise = y1 - y2;
+      var run = x1 - x2;
+      var slope = -(rise / run);
+      var radian = Math.atan(slope);
+      var angleH = Math.floor(radian * (180 / Math.PI));
+
+      if (x2 < x1 && y2 < y1) {
+        angleH += 180;
+      }
+
+      if (x2 < x1 && y2 > y1) {
+        angleH += 180;
+      }
+
+      if (x2 > x1 && y2 > y1) {
+        angleH += 360;
+      }
+
+      if (y2 < y1 && slope === -Infinity) {
+        angleH = 90;
+      }
+
+      if (y2 > y1 && slope === Infinity) {
+        angleH = 270;
+      }
+
+      if (x2 < x1 && slope === 0) {
+        angleH = 180;
+      }
+
+      if (Number.isNaN(angleH)) {
+        angleH = 0;
+      }
+
+      orb.x = orb.centerX + Math.sin(orb.angle * -1) * orb.radius;
+      orb.y = orb.centerY + Math.cos(orb.angle * -1) * orb.radius;
+      orb.lastX = orb.x;
+      orb.lastY = orb.y;
+      orb.colorAngle = angleH;
+      orb.angle += orb.speed;
+      return orb;
+    };
+
+    return _this;
+  }
+
+  return RadarScanning;
+}(_Core2["default"]);
+
+RadarScanning.defaultProps = {
+  number: 100,
+  trail: true
+};
+var _default = RadarScanning;
+exports["default"] = _default;

package/es/customComponents/Canvas/Spirit/index.d.ts

@@ -0,0 +1,19 @@
+export default Spirit;
+declare class Spirit extends Core {
+    circles: any[];
+    animate: () => void;
+    createCircle: () => {
+        pos: {
+            x: number;
+            y: number;
+        };
+        alpha: number;
+        scale: number;
+        velocity: number;
+    };
+    drawCircle: (ctx: any, circle: any) => void;
+}
+declare namespace Spirit {
+    const defaultProps: {};
+}
+import Core from "../Core";

package/es/customComponents/Canvas/Spirit/index.js

@@ -0,0 +1,115 @@
+"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 _tools = require("../../../utils/tools");
+
+var _Core2 = _interopRequireDefault(require("../Core"));
+
+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 _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); }
+
+var Spirit = /*#__PURE__*/function (_Core) {
+  _inherits(Spirit, _Core);
+
+  var _super = _createSuper(Spirit);
+
+  function Spirit() {
+    var _this;
+
+    _classCallCheck(this, Spirit);
+
+    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.circles = [];
+
+    _this.doAfterDidMount = function () {
+      var x = 0;
+
+      while (x < _this.canvasWidth * 0.5) {
+        _this.circles.push(_this.createCircle());
+
+        x += 1;
+      }
+
+      _this.animate();
+    };
+
+    _this.animate = function () {
+      var ctx = _this.getCanvasContext();
+
+      ctx.clearRect(0, 0, _this.canvasWidth, _this.canvasHeight);
+      _this.circles = (_this.circles || []).map(function (o) {
+        if (o.alpha <= 0) {
+          return _this.createCircle();
+        }
+
+        return o;
+      });
+      (_this.circles || []).forEach(function (o) {
+        _this.drawCircle(ctx, o);
+      });
+      (0, _tools.requestAnimFrame)(_this.animate);
+    };
+
+    _this.createCircle = function () {
+      var o = {
+        pos: {
+          x: Math.random() * _this.canvasWidth,
+          y: _this.canvasHeight + Math.random() * 100
+        },
+        alpha: 0.1 + Math.random() * 0.3,
+        scale: 0.1 + Math.random() * 0.3,
+        velocity: Math.random()
+      };
+      return o;
+    };
+
+    _this.drawCircle = function (ctx, circle) {
+      var o = circle;
+      o.pos.y -= o.velocity;
+      o.alpha -= 0.0005;
+      ctx.beginPath();
+      ctx.arc(o.pos.x, o.pos.y, o.scale * 10, 0, 2 * Math.PI, false);
+      ctx.fillStyle = "rgba(255,255,255,".concat(o.alpha, ")");
+      ctx.fill();
+    };
+
+    _this.buildContainorStyle = function () {
+      return {
+        backgroundColor: '#000'
+      };
+    };
+
+    return _this;
+  }
+
+  return Spirit;
+}(_Core2["default"]);
+
+Spirit.defaultProps = {};
+var _default = Spirit;
+exports["default"] = _default;

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

@@ -0,0 +1,12 @@
+export const Bubbly: typeof BubblySource;
+export const RadarScanning: typeof RadarScanningSource;
+export const Spirit: typeof SpiritSource;
+declare namespace _default {
+    export { Bubbly };
+    export { RadarScanning };
+    export { Spirit };
+}
+export default _default;
+import BubblySource from "./Bubbly";
+import RadarScanningSource from "./RadarScanning";
+import SpiritSource from "./Spirit";

package/es/customComponents/Canvas/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.Spirit = exports.RadarScanning = exports.Bubbly = void 0;
+
+var _Bubbly = _interopRequireDefault(require("./Bubbly"));
+
+var _RadarScanning = _interopRequireDefault(require("./RadarScanning"));
+
+var _Spirit = _interopRequireDefault(require("./Spirit"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var Bubbly = _Bubbly["default"];
+exports.Bubbly = Bubbly;
+var RadarScanning = _RadarScanning["default"];
+exports.RadarScanning = RadarScanning;
+var Spirit = _Spirit["default"];
+exports.Spirit = Spirit;
+var _default = {
+  Bubbly: Bubbly,
+  RadarScanning: RadarScanning,
+  Spirit: Spirit
+};
+exports["default"] = _default;

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

@@ -0,0 +1,6 @@
+export default CenterBox;
+declare class CenterBox extends React.PureComponent<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+}
+import React from "react";

package/es/customComponents/CenterBox/index.js

@@ -0,0 +1,70 @@
+"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 _VerticalBox = _interopRequireDefault(require("../VerticalBox"));
+
+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); }
+
+var CenterBox = /*#__PURE__*/function (_PureComponent) {
+  _inherits(CenterBox, _PureComponent);
+
+  var _super = _createSuper(CenterBox);
+
+  function CenterBox() {
+    _classCallCheck(this, CenterBox);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(CenterBox, [{
+    key: "render",
+    value: function render() {
+      var children = this.props.children;
+      return /*#__PURE__*/_react["default"].createElement(_VerticalBox["default"], {
+        style: {
+          height: '100%',
+          width: '100%'
+        },
+        align: "center",
+        alignJustify: "center"
+      }, children);
+    }
+  }]);
+
+  return CenterBox;
+}(_react.PureComponent);
+
+var _default = CenterBox;
+exports["default"] = _default;

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

@@ -0,0 +1,6 @@
+export default Bar;
+declare class Bar extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+}
+import React from "react";

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

@@ -0,0 +1,129 @@
+"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 _bizcharts = require("bizcharts");
+
+var _react = _interopRequireWildcard(require("react"));
+
+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); }
+
+var Bar = /*#__PURE__*/function (_Component) {
+  _inherits(Bar, _Component);
+
+  var _super = _createSuper(Bar);
+
+  function Bar() {
+    var _this;
+
+    _classCallCheck(this, Bar);
+
+    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 = {
+      autoHideXLabels: false
+    };
+    return _this;
+  }
+
+  _createClass(Bar, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          title = _this$props.title,
+          _this$props$autoFit = _this$props.autoFit,
+          autoFit = _this$props$autoFit === void 0 ? true : _this$props$autoFit,
+          data = _this$props.data,
+          _this$props$color = _this$props.color,
+          color = _this$props$color === void 0 ? 'rgba(24, 144, 255, 0.85)' : _this$props$color,
+          _this$props$animate = _this$props.animate,
+          animate = _this$props$animate === void 0 ? true : _this$props$animate;
+      var autoHideXLabels = this.state.autoHideXLabels;
+      var scale = {
+        x: {
+          type: 'cat'
+        },
+        y: {
+          min: 0,
+          alias: title
+        }
+      };
+      var tooltip = ['x*y', function (x, y) {
+        return {
+          name: x,
+          value: y
+        };
+      }];
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: _index["default"].chart,
+        style: {
+          height: '100%'
+        }
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        style: {
+          height: '100%'
+        }
+      }, /*#__PURE__*/_react["default"].createElement(_bizcharts.Chart, {
+        animate: animate,
+        scale: scale,
+        autoFit: autoFit,
+        data: data
+      }, /*#__PURE__*/_react["default"].createElement(_bizcharts.Axis, {
+        name: "x",
+        title: false,
+        label: autoHideXLabels ? undefined : {},
+        tickLine: autoHideXLabels ? undefined : {}
+      }), /*#__PURE__*/_react["default"].createElement(_bizcharts.Axis, {
+        title: true,
+        name: "y",
+        min: 0
+      }), /*#__PURE__*/_react["default"].createElement(_bizcharts.Tooltip, {
+        showTitle: false,
+        showCrosshairs: false
+      }), /*#__PURE__*/_react["default"].createElement(_bizcharts.Interval, {
+        position: "x*y",
+        color: color,
+        tooltip: tooltip
+      }))));
+    }
+  }]);
+
+  return Bar;
+}(_react.Component);
+
+var _default = Bar;
+exports["default"] = _default;

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

@@ -0,0 +1,7 @@
+export default ChartCard;
+declare class ChartCard extends React.Component<any, any, any> {
+    constructor(props: any);
+    constructor(props: any, context: any);
+    renderContent: () => false | JSX.Element;
+}
+import React from "react";