@rio-cloud/rio-uikit 0.16.4-beta.1 → 0.16.4-beta.2

package/components/carousel/CarouselCaption.js

@@ -1,42 +1,18 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-var _excluded = ["componentClass", "className"];
-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 _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; } }
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
 // https://github.com/react-bootstrap/react-bootstrap/blob/v0.32.0/src/CarouselCaption.js
-
 import classNames from 'classnames';
 import React from 'react';
-var CarouselCaption = /*#__PURE__*/function (_React$Component) {
-  _inherits(CarouselCaption, _React$Component);
-  var _super = _createSuper(CarouselCaption);
-  function CarouselCaption() {
-    _classCallCheck(this, CarouselCaption);
-    return _super.apply(this, arguments);
-  }
-  _createClass(CarouselCaption, [{
-    key: "render",
-    value: function render() {
-      var _this$props = this.props,
-        Component = _this$props.componentClass,
-        className = _this$props.className,
-        remainingProps = _objectWithoutProperties(_this$props, _excluded);
-      return /*#__PURE__*/React.createElement(Component, _extends({}, remainingProps, {
-        className: classNames('carousel-caption', className)
-      }));
+class CarouselCaption extends React.Component {
+    render() {
+        const _a = this.props, { componentClass: Component, className } = _a, remainingProps = __rest(_a, ["componentClass", "className"]);
+        return _jsx(Component, Object.assign({}, remainingProps, { className: classNames('carousel-caption', className) }));
     }
-  }]);
-  return CarouselCaption;
-}(React.Component);
+}
 CarouselCaption.defaultProps = {
-  componentClass: 'div'
+    componentClass: 'div',
 };
 CarouselCaption.propTypes = {
-  // componentClass: elementType,
+// componentClass: elementType,
 };
-export default CarouselCaption;
+export default CarouselCaption;

package/components/carousel/CarouselItem.d.ts

@@ -0,0 +1,36 @@
+export default CarouselItem;
+declare class CarouselItem extends React.Component<any, any, any> {
+    constructor(props: any, context: any);
+    handleAnimateOutEnd(): void;
+    state: {
+        direction: null;
+    };
+    isUnmounted: boolean;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    startAnimation(): void;
+    render(): JSX.Element;
+}
+declare namespace CarouselItem {
+    export { propTypes };
+    export { defaultProps };
+}
+import React from "react";
+declare namespace propTypes {
+    const direction: PropTypes.Requireable<string>;
+    const onAnimateOutEnd: PropTypes.Requireable<(...args: any[]) => any>;
+    const active: PropTypes.Requireable<boolean>;
+    const animateIn: PropTypes.Requireable<boolean>;
+    const animateOut: PropTypes.Requireable<boolean>;
+    const index: PropTypes.Requireable<number>;
+}
+declare namespace defaultProps {
+    const active_1: boolean;
+    export { active_1 as active };
+    const animateIn_1: boolean;
+    export { animateIn_1 as animateIn };
+    const animateOut_1: boolean;
+    export { animateOut_1 as animateOut };
+}
+import PropTypes from "prop-types";

package/components/carousel/CarouselItem.js

@@ -1,128 +1,85 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-var _excluded = ["direction", "active", "animateIn", "animateOut", "className"];
-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 _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; } }
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
 // https://github.com/react-bootstrap/react-bootstrap/blob/v0.32.0/src/CarouselItem.js
-
 import classNames from 'classnames';
 import React from 'react';
 import PropTypes from 'prop-types';
 import ReactDOM from 'react-dom';
 import transitionEnd from 'dom-helpers/transitionEnd';
-var propTypes = {
-  direction: PropTypes.oneOf(['prev', 'next']),
-  onAnimateOutEnd: PropTypes.func,
-  active: PropTypes.bool,
-  animateIn: PropTypes.bool,
-  animateOut: PropTypes.bool,
-  index: PropTypes.number
+const propTypes = {
+    direction: PropTypes.oneOf(['prev', 'next']),
+    onAnimateOutEnd: PropTypes.func,
+    active: PropTypes.bool,
+    animateIn: PropTypes.bool,
+    animateOut: PropTypes.bool,
+    index: PropTypes.number,
 };
-var defaultProps = {
-  active: false,
-  animateIn: false,
-  animateOut: false
+const defaultProps = {
+    active: false,
+    animateIn: false,
+    animateOut: false,
 };
-var CarouselItem = /*#__PURE__*/function (_React$Component) {
-  _inherits(CarouselItem, _React$Component);
-  var _super = _createSuper(CarouselItem);
-  function CarouselItem(props, context) {
-    var _this;
-    _classCallCheck(this, CarouselItem);
-    _this = _super.call(this, props, context);
-    _this.handleAnimateOutEnd = _this.handleAnimateOutEnd.bind(_assertThisInitialized(_this));
-    _this.state = {
-      direction: null
-    };
-    _this.isUnmounted = false;
-    return _this;
-  }
-
-  // eslint-disable-next-line camelcase
-  _createClass(CarouselItem, [{
-    key: "UNSAFE_componentWillReceiveProps",
-    value: function UNSAFE_componentWillReceiveProps(nextProps) {
-      if (this.props.active !== nextProps.active) {
-        this.setState({
-          direction: null
-        });
-      }
+class CarouselItem extends React.Component {
+    constructor(props, context) {
+        super(props, context);
+        this.handleAnimateOutEnd = this.handleAnimateOutEnd.bind(this);
+        this.state = {
+            direction: null,
+        };
+        this.isUnmounted = false;
+    }
+    // eslint-disable-next-line camelcase
+    UNSAFE_componentWillReceiveProps(nextProps) {
+        if (this.props.active !== nextProps.active) {
+            this.setState({ direction: null });
+        }
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      var _this2 = this;
-      var active = this.props.active;
-      var prevActive = prevProps.active;
-      if (!active && prevActive) {
-        transitionEnd(ReactDOM.findDOMNode(this), this.handleAnimateOutEnd);
-      }
-      if (active !== prevActive) {
-        setTimeout(function () {
-          return _this2.startAnimation();
-        }, 20);
-      }
+    componentDidUpdate(prevProps) {
+        const { active } = this.props;
+        const prevActive = prevProps.active;
+        if (!active && prevActive) {
+            transitionEnd(ReactDOM.findDOMNode(this), this.handleAnimateOutEnd);
+        }
+        if (active !== prevActive) {
+            setTimeout(() => this.startAnimation(), 20);
+        }
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.isUnmounted = true;
+    componentWillUnmount() {
+        this.isUnmounted = true;
     }
-  }, {
-    key: "handleAnimateOutEnd",
-    value: function handleAnimateOutEnd() {
-      if (this.isUnmounted) {
-        return;
-      }
-      if (this.props.onAnimateOutEnd) {
-        this.props.onAnimateOutEnd(this.props.index);
-      }
+    handleAnimateOutEnd() {
+        if (this.isUnmounted) {
+            return;
+        }
+        if (this.props.onAnimateOutEnd) {
+            this.props.onAnimateOutEnd(this.props.index);
+        }
     }
-  }, {
-    key: "startAnimation",
-    value: function startAnimation() {
-      if (this.isUnmounted) {
-        return;
-      }
-      this.setState({
-        direction: this.props.direction === 'prev' ? 'right' : 'left'
-      });
+    startAnimation() {
+        if (this.isUnmounted) {
+            return;
+        }
+        this.setState({
+            direction: this.props.direction === 'prev' ? 'right' : 'left',
+        });
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props = this.props,
-        direction = _this$props.direction,
-        active = _this$props.active,
-        animateIn = _this$props.animateIn,
-        animateOut = _this$props.animateOut,
-        className = _this$props.className,
-        props = _objectWithoutProperties(_this$props, _excluded);
-      delete props.onAnimateOutEnd;
-      delete props.index;
-      var classes = {
-        item: true,
-        active: active && !animateIn || animateOut
-      };
-      if (direction && active && animateIn) {
-        classes[direction] = true;
-      }
-      if (this.state.direction && (animateIn || animateOut)) {
-        classes[this.state.direction] = true;
-      }
-      return /*#__PURE__*/React.createElement("div", _extends({}, props, {
-        className: classNames(className, classes)
-      }));
+    render() {
+        const _a = this.props, { direction, active, animateIn, animateOut, className } = _a, props = __rest(_a, ["direction", "active", "animateIn", "animateOut", "className"]);
+        delete props.onAnimateOutEnd;
+        delete props.index;
+        const classes = {
+            item: true,
+            active: (active && !animateIn) || animateOut,
+        };
+        if (direction && active && animateIn) {
+            classes[direction] = true;
+        }
+        if (this.state.direction && (animateIn || animateOut)) {
+            classes[this.state.direction] = true;
+        }
+        return _jsx("div", Object.assign({}, props, { className: classNames(className, classes) }));
     }
-  }]);
-  return CarouselItem;
-}(React.Component);
+}
 CarouselItem.propTypes = propTypes;
 CarouselItem.defaultProps = defaultProps;
-export default CarouselItem;
+export default CarouselItem;

package/components/charts/Area.d.ts

@@ -0,0 +1,13 @@
+export default Area;
+declare function Area(): null;
+declare namespace Area {
+    namespace defaultProps {
+        const dataKey: string;
+        const dataUnit: string;
+        const strokeColor: string;
+        const gradientId: string;
+        const legendType: string;
+        const type: string;
+        const isAnimationActive: boolean;
+    }
+}

package/components/charts/Area.js

@@ -1,13 +1,11 @@
-var Area = function Area() {
-  return null;
-};
+const Area = () => null;
 Area.defaultProps = {
-  dataKey: 'value',
-  dataUnit: '',
-  strokeColor: 'color-coldplay-fountain',
-  gradientId: 'areaGradient',
-  legendType: 'square',
-  type: 'monotone',
-  isAnimationActive: true
+    dataKey: 'value',
+    dataUnit: '',
+    strokeColor: 'color-coldplay-fountain',
+    gradientId: 'areaGradient',
+    legendType: 'square',
+    type: 'monotone',
+    isAnimationActive: true,
 };
-export default Area;
+export default Area;

package/components/charts/AreaChart.d.ts

@@ -0,0 +1,17 @@
+export default AreaChart;
+declare function AreaChart(props: any): JSX.Element;
+declare namespace AreaChart {
+    namespace defaultProps {
+        const width: number;
+        const height: number;
+        const data: never[];
+        const dataUnit: string;
+        const gradients: never[];
+        const areas: never[];
+        const showXAxis: boolean;
+        const showYAxis: boolean;
+        const showGrid: boolean;
+        const brush: boolean;
+        const tooltip: JSX.Element;
+    }
+}

package/components/charts/AreaChart.js

@@ -1,98 +1,40 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["width", "height", "data", "dataUnit", "dataKey", "gradients", "areas", "xAxisOptions", "yAxisOptions", "gridOptions", "showXAxis", "showYAxis", "showGrid", "legend", "brush", "tooltip"],
-  _excluded2 = ["strokeColor"];
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
 import React from 'react';
-import { AreaChart as RechartsAreaChart, Area as RechartsArea, Legend as RechartsLegend, XAxis, YAxis, Brush, Tooltip as RechartsTooltip, CartesianGrid, ResponsiveContainer } from 'recharts';
+import { AreaChart as RechartsAreaChart, Area as RechartsArea, Legend as RechartsLegend, XAxis, YAxis, Brush, Tooltip as RechartsTooltip, CartesianGrid, ResponsiveContainer, } from 'recharts';
 import { getColor, mapGridOptions } from './chartHelper';
 import AreaGradient from './AreaGradient';
 import ChartTooltip from './ChartTooltip';
-var AreaChart = function AreaChart(props) {
-  var width = props.width,
-    height = props.height,
-    data = props.data,
-    dataUnit = props.dataUnit,
-    dataKey = props.dataKey,
-    gradients = props.gradients,
-    areas = props.areas,
-    xAxisOptions = props.xAxisOptions,
-    yAxisOptions = props.yAxisOptions,
-    gridOptions = props.gridOptions,
-    showXAxis = props.showXAxis,
-    showYAxis = props.showYAxis,
-    showGrid = props.showGrid,
-    legend = props.legend,
-    brush = props.brush,
-    tooltip = props.tooltip,
-    remainingProps = _objectWithoutProperties(props, _excluded);
-  var areasWithGradient = areas.map(function (area) {
-    var _area$props = area.props,
-      strokeColor = _area$props.strokeColor,
-      remainingAreaProps = _objectWithoutProperties(_area$props, _excluded2);
-    var gradientId = area.key;
-    var stroke = getColor(strokeColor);
-    return {
-      area: /*#__PURE__*/React.createElement(RechartsArea, _extends({}, remainingAreaProps, {
-        key: area.key,
-        stroke: stroke,
-        fill: "url(#".concat(gradientId, ")")
-      })),
-      gradient: /*#__PURE__*/React.createElement(AreaGradient, {
-        key: area.key,
-        id: gradientId,
-        color: strokeColor
-      })
-    };
-  });
-  return /*#__PURE__*/React.createElement(ResponsiveContainer, {
-    width: "100%",
-    height: "100%"
-  }, /*#__PURE__*/React.createElement(RechartsAreaChart, _extends({
-    width: width,
-    height: height,
-    data: data,
-    margin: {
-      top: 15,
-      right: 15,
-      left: 15,
-      bottom: 15
-    }
-  }, remainingProps), /*#__PURE__*/React.createElement("defs", null, gradients, areasWithGradient.map(function (areaWithGradient) {
-    return areaWithGradient.gradient;
-  })), showGrid && /*#__PURE__*/React.createElement(CartesianGrid, _extends({
-    strokeDasharray: "3 3"
-  }, mapGridOptions(gridOptions))), /*#__PURE__*/React.createElement(XAxis, _extends({
-    hide: !showXAxis,
-    dataKey: dataKey
-  }, xAxisOptions)), /*#__PURE__*/React.createElement(YAxis, _extends({
-    hide: !showYAxis,
-    unit: dataUnit
-  }, yAxisOptions)), tooltip && /*#__PURE__*/React.createElement(RechartsTooltip, tooltip.props), legend && /*#__PURE__*/React.createElement(RechartsLegend, _extends({
-    wrapperStyle: legend.props.verticalAlign === 'bottom' ? {
-      bottom: 0
-    } : legend.props.wrapperStyle
-  }, legend.props)), areasWithGradient.map(function (areaWithGradient) {
-    return areaWithGradient.area;
-  }), brush && /*#__PURE__*/React.createElement(Brush, {
-    stroke: getColor('gray')
-  })));
+const AreaChart = props => {
+    const { width, height, data, dataUnit, dataKey, gradients, areas, xAxisOptions, yAxisOptions, gridOptions, showXAxis, showYAxis, showGrid, legend, brush, tooltip } = props, remainingProps = __rest(props, ["width", "height", "data", "dataUnit", "dataKey", "gradients", "areas", "xAxisOptions", "yAxisOptions", "gridOptions", "showXAxis", "showYAxis", "showGrid", "legend", "brush", "tooltip"]);
+    const areasWithGradient = areas.map(area => {
+        const _a = area.props, { strokeColor } = _a, remainingAreaProps = __rest(_a, ["strokeColor"]);
+        const gradientId = area.key;
+        const stroke = getColor(strokeColor);
+        return {
+            area: _createElement(RechartsArea, Object.assign({}, remainingAreaProps, { key: area.key, stroke: stroke, fill: `url(#${gradientId})` })),
+            gradient: _jsx(AreaGradient, { id: gradientId, color: strokeColor }, area.key),
+        };
+    });
+    return (_jsx(ResponsiveContainer, Object.assign({ width: '100%', height: '100%' }, { children: _jsxs(RechartsAreaChart, Object.assign({ width: width, height: height, data: data, margin: { top: 15, right: 15, left: 15, bottom: 15 } }, remainingProps, { children: [_jsxs("defs", { children: [gradients, areasWithGradient.map(areaWithGradient => areaWithGradient.gradient)] }), showGrid && _jsx(CartesianGrid, Object.assign({ strokeDasharray: '3 3' }, mapGridOptions(gridOptions))), _jsx(XAxis, Object.assign({ hide: !showXAxis, dataKey: dataKey }, xAxisOptions)), _jsx(YAxis, Object.assign({ hide: !showYAxis, unit: dataUnit }, yAxisOptions)), tooltip && _jsx(RechartsTooltip, Object.assign({}, tooltip.props)), legend && (_jsx(RechartsLegend, Object.assign({ wrapperStyle: legend.props.verticalAlign === 'bottom' ? { bottom: 0 } : legend.props.wrapperStyle }, legend.props))), areasWithGradient.map(areaWithGradient => areaWithGradient.area), brush && _jsx(Brush, { stroke: getColor('gray') })] })) })));
 };
 AreaChart.defaultProps = {
-  width: 480,
-  height: 200,
-  data: [],
-  dataUnit: '',
-  // dataKey,
-  gradients: [],
-  areas: [],
-  // xAxisOptions,
-  // yAxisOptions,
-  // gridOptions,
-  showXAxis: true,
-  showYAxis: false,
-  showGrid: false,
-  // legend,
-  brush: false,
-  tooltip: /*#__PURE__*/React.createElement(ChartTooltip, null)
+    width: 480,
+    height: 200,
+    data: [],
+    dataUnit: '',
+    // dataKey,
+    gradients: [],
+    areas: [],
+    // xAxisOptions,
+    // yAxisOptions,
+    // gridOptions,
+    showXAxis: true,
+    showYAxis: false,
+    showGrid: false,
+    // legend,
+    brush: false,
+    tooltip: _jsx(ChartTooltip, {}),
 };
-export default AreaChart;
+export default AreaChart;

package/components/charts/AreaGradient.d.ts

@@ -0,0 +1,11 @@
+export default AreaGradient;
+declare function AreaGradient({ id, color }: {
+    id: any;
+    color: any;
+}): JSX.Element;
+declare namespace AreaGradient {
+    namespace defaultProps {
+        const id: string;
+        const color: string;
+    }
+}

package/components/charts/AreaGradient.js

@@ -1,27 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { getColor } from './chartHelper';
-var AreaGradient = function AreaGradient(_ref) {
-  var id = _ref.id,
-    color = _ref.color;
-  return /*#__PURE__*/React.createElement("linearGradient", {
-    key: id,
-    id: id,
-    x1: "0",
-    y1: "0",
-    x2: "0",
-    y2: "1"
-  }, /*#__PURE__*/React.createElement("stop", {
-    offset: "5%",
-    stopColor: getColor(color),
-    stopOpacity: 0.8
-  }), /*#__PURE__*/React.createElement("stop", {
-    offset: "95%",
-    stopColor: getColor(color),
-    stopOpacity: 0
-  }));
-};
+const AreaGradient = ({ id, color }) => (_jsxs("linearGradient", Object.assign({ id: id, x1: '0', y1: '0', x2: '0', y2: '1' }, { children: [_jsx("stop", { offset: '5%', stopColor: getColor(color), stopOpacity: 0.8 }), _jsx("stop", { offset: '95%', stopColor: getColor(color), stopOpacity: 0 })] }), id));
 AreaGradient.defaultProps = {
-  id: 'areaGradient',
-  color: 'color-coldplay-fountain'
+    id: 'areaGradient',
+    color: 'color-coldplay-fountain',
 };
-export default AreaGradient;
+export default AreaGradient;

package/components/charts/Bar.d.ts

@@ -0,0 +1,10 @@
+export default Bar;
+declare function Bar(): null;
+declare namespace Bar {
+    namespace defaultProps {
+        const isAnimationActive: boolean;
+        const dataKey: string;
+        const dataUnit: string;
+        const color: string;
+    }
+}

package/components/charts/Bar.js

@@ -1,10 +1,8 @@
-var Bar = function Bar() {
-  return null;
-};
+const Bar = () => null;
 Bar.defaultProps = {
-  isAnimationActive: true,
-  dataKey: 'value',
-  dataUnit: '',
-  color: 'color-coldplay-fountain'
+    isAnimationActive: true,
+    dataKey: 'value',
+    dataUnit: '',
+    color: 'color-coldplay-fountain',
 };
-export default Bar;
+export default Bar;

package/components/charts/BarChart.d.ts

@@ -0,0 +1,18 @@
+export default BarChart;
+declare function BarChart(props: any): JSX.Element;
+declare namespace BarChart {
+    namespace defaultProps {
+        const width: number;
+        const height: number;
+        const data: never[];
+        const layout: string;
+        const bars: never[];
+        const showGrid: boolean;
+        const showXAxis: boolean;
+        const showYAxis: boolean;
+        const useDataColors: boolean;
+        const brush: boolean;
+        const tooltip: JSX.Element;
+        const legend: boolean;
+    }
+}