@widergy/energy-ui 3.158.0 → 3.159.0

package/dist/esm/deprecated/UTDialog/types.js

@@ -0,0 +1,7 @@
+import { bool, func, string, shape, objectOf } from 'prop-types';
+export const dialogButtonPropTypes = shape({
+  classNames: objectOf(string),
+  disabled: bool,
+  text: string,
+  onClick: func
+});

package/dist/esm/deprecated/UTIconButton/index.js

@@ -0,0 +1,75 @@
+import React, { Component } from 'react';
+import IconButton from '@material-ui/core/IconButton';
+import CircularProgress from '@material-ui/core/CircularProgress';
+import { bool, func, objectOf, string } from 'prop-types';
+import { retrieveClassNamesFromProps } from '@widergy/web-utils/lib/style';
+import UTTouchableWithoutFeedback from '../../components/UTTouchableWithoutFeedback';
+import WithTheme from '../../components/WithTheme';
+import { retrieveStyle } from './theme';
+import styles from './styles.module.scss';
+const variants = ['base', 'primary', 'secondary', 'alternative', 'gray', 'disabled'];
+class UTIconButton extends Component {
+  render() {
+    const {
+      autoFocus,
+      children,
+      className,
+      classes,
+      dataTestId,
+      disabled,
+      imgClassName,
+      imgSrc,
+      large,
+      loading,
+      loadingClassName,
+      onClick,
+      small,
+      style,
+      type
+    } = this.props;
+    const size = small ? 'small' : large ? 'large' : 'medium';
+    const classNames = retrieveClassNamesFromProps(variants, classes, this.props);
+    return loading ? /*#__PURE__*/React.createElement("div", {
+      className: "".concat(styles.loadingContainer, " ").concat(loadingClassName)
+    }, /*#__PURE__*/React.createElement(CircularProgress, {
+      size: 24,
+      className: classes.loading
+    })) : imgSrc ? /*#__PURE__*/React.createElement(UTTouchableWithoutFeedback, {
+      className: classes.imgIcon,
+      "data-testid": dataTestId,
+      onClick: onClick,
+      withRipple: true
+    }, /*#__PURE__*/React.createElement("img", {
+      src: imgSrc,
+      alt: "",
+      className: imgClassName
+    })) : /*#__PURE__*/React.createElement(IconButton, {
+      autoFocus: autoFocus,
+      classes: {
+        root: "".concat(classNames, " ").concat(small ? classes.small : large && classes.large, " ").concat(className)
+      },
+      "data-testid": dataTestId,
+      disabled: disabled || loading,
+      onClick: onClick,
+      size: size,
+      style: style,
+      type: type
+    }, children);
+  }
+}
+UTIconButton.propTypes = {
+  autoFocus: bool,
+  className: string,
+  classes: objectOf(string),
+  dataTestId: string,
+  disabled: bool,
+  imgClassName: string,
+  imgSrc: string,
+  large: bool,
+  loading: bool,
+  loadingClassName: string,
+  onClick: func,
+  small: bool,
+  type: string
+};
+export default WithTheme(retrieveStyle)(UTIconButton);

package/dist/esm/deprecated/UTIconButton/styles.module.scss

@@ -0,0 +1,8 @@
+.loadingContainer {
+  align-items: center;
+  display: flex;
+  justify-content: center;
+  min-height: 40px;
+  min-width: 40px;
+}
+

package/dist/esm/deprecated/UTIconButton/theme.js

@@ -0,0 +1,60 @@
+import { getIn } from 'seamless-immutable';
+export const retrieveStyle = _ref => {
+  let {
+    theme
+  } = _ref;
+  return {
+    base: {
+      backgroundColor: getIn(theme, ['UTIconButton', 'base', 'backgroundColor']),
+      borderRadius: getIn(theme, ['UTIconButton', 'base', 'borderRadius']),
+      color: getIn(theme, ['UTIconButton', 'base', 'color']),
+      '&:hover': {
+        backgroundColor: getIn(theme, ['UTIconButton', 'base', 'hover', 'backgroundColor'])
+      }
+    },
+    secondary: {
+      backgroundColor: getIn(theme, ['UTIconButton', 'secondary', 'backgroundColor']),
+      color: getIn(theme, ['UTIconButton', 'secondary', 'color']),
+      '&:hover': {
+        backgroundColor: getIn(theme, ['UTIconButton', 'secondary', 'hover', 'backgroundColor'])
+      }
+    },
+    alternative: {
+      backgroundColor: getIn(theme, ['UTIconButton', 'alternative', 'backgroundColor']),
+      color: getIn(theme, ['UTIconButton', 'alternative', 'color']),
+      '&:hover': {
+        backgroundColor: getIn(theme, ['UTIconButton', 'alternative', 'hover', 'backgroundColor'])
+      }
+    },
+    gray: {
+      backgroundColor: getIn(theme, ['UTIconButton', 'gray', 'backgroundColor']),
+      color: getIn(theme, ['UTIconButton', 'gray', 'color']),
+      '&:hover': {
+        backgroundColor: getIn(theme, ['UTIconButton', 'gray', 'hover', 'backgroundColor'])
+      }
+    },
+    disabled: {
+      backgroundColor: getIn(theme, ['UTIconButton', 'disabled', 'backgroundColor']),
+      color: getIn(theme, ['UTIconButton', 'disabled', 'color'])
+    },
+    small: {
+      fontSize: getIn(theme, ['Fonts', 'small'])
+    },
+    large: {
+      fontSize: getIn(theme, ['Fonts', 'large'])
+    },
+    labelFullWidth: {
+      width: '100%'
+    },
+    loading: {
+      color: getIn(theme, ['UTIconButton', 'loading', 'color'])
+    },
+    imgIcon: {
+      padding: '10px',
+      '&:hover': {
+        backgroundColor: '#e2e2e2',
+        borderRadius: '50%'
+      }
+    }
+  };
+};

package/dist/esm/deprecated/UTList/index.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import { array, func, number } from 'prop-types';
+import WithTouch from '../../components/WithTouch';
+import styles from './styles.module.scss';
+const renderItem = Component => (item, i) => /*#__PURE__*/React.createElement(Component, {
+  key: "listItem".concat(i, "_").concat(Math.random()),
+  item: item
+});
+const UTList = props => {
+  const {
+    component: Component,
+    items,
+    onListEnd,
+    loadBefore,
+    onClick
+  } = props;
+  const handleScroll = e => {
+    if (!e || !e.target) return;
+    const limit = e.target.scrollHeight - e.target.offsetHeight - loadBefore;
+    if (e.target.scrollTop >= limit) {
+      return onListEnd ? onListEnd() : undefined;
+    }
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    onScroll: handleScroll,
+    className: styles.list
+  }, items && items.length > 0 && items.map(renderItem(WithTouch(onClick)(Component))));
+};
+UTList.propTypes = {
+  component: func.isRequired,
+  items: array.isRequired,
+  onListEnd: func,
+  loadBefore: number,
+  onClick: func
+};
+export default UTList;

package/dist/esm/deprecated/UTList/styles.module.scss

@@ -0,0 +1,9 @@
+.list {
+  display: flex;
+  flex-direction: column;
+  height: fit-content;
+  margin: 0;
+  overflow: auto;
+  padding: 15px;
+  width: fit-content;
+}

package/dist/esm/deprecated/UTPieChart/components/ArrowLabel/constants.js

@@ -0,0 +1,4 @@
+export const ARROW_SEPARATION = 0;
+export const SEGMENT_1_LENGTH = 15;
+export const SEGMENT_2_OFFSET = 10;
+export const TEXT_OFFSET = 7;

package/dist/esm/deprecated/UTPieChart/components/ArrowLabel/index.js

@@ -0,0 +1,56 @@
+import React from 'react';
+import { number, string } from 'prop-types';
+import { SEGMENT_1_LENGTH, SEGMENT_2_OFFSET, ARROW_SEPARATION, TEXT_OFFSET } from './constants';
+const ArrowLabel = _ref => {
+  let {
+    midAngle,
+    outerRadius,
+    color,
+    label,
+    value
+  } = _ref;
+  const angle = midAngle - Math.PI / 2;
+  const sin = Math.sin(angle);
+  const cos = Math.cos(angle);
+  const startX = (outerRadius + ARROW_SEPARATION) * cos;
+  const startY = (outerRadius + ARROW_SEPARATION) * sin;
+  const sign = cos >= 0 ? 1 : -1;
+  const segment1X = (outerRadius + ARROW_SEPARATION + SEGMENT_1_LENGTH) * cos;
+  const segment1Y = (outerRadius + ARROW_SEPARATION + SEGMENT_1_LENGTH) * sin;
+  const segment2X = segment1X + sign * SEGMENT_2_OFFSET;
+  const segment2Y = segment1Y;
+  const textAnchor = cos >= 0 ? 'start' : 'end';
+  const labelX = segment2X + sign * TEXT_OFFSET;
+  const labelY = segment2Y + -TEXT_OFFSET;
+  const valueX = segment2X + sign * TEXT_OFFSET;
+  const valueY = segment2Y + TEXT_OFFSET;
+  return /*#__PURE__*/React.createElement("g", null, /*#__PURE__*/React.createElement("path", {
+    d: "M".concat(startX, ",").concat(startY, "L").concat(segment1X, ",").concat(segment1Y, "L").concat(segment2X, ",").concat(segment2Y),
+    stroke: color,
+    fill: "none"
+  }), /*#__PURE__*/React.createElement("circle", {
+    cx: segment2X,
+    cy: segment2Y,
+    r: 2,
+    fill: color,
+    stroke: "none"
+  }), label && /*#__PURE__*/React.createElement("text", {
+    x: labelX,
+    y: labelY,
+    fontSize: "12px",
+    textAnchor: textAnchor
+  }, label), value && /*#__PURE__*/React.createElement("text", {
+    x: valueX,
+    y: valueY,
+    fontSize: "12px",
+    textAnchor: textAnchor
+  }, "".concat((value * 100).toFixed(2), "%")));
+};
+ArrowLabel.propTypes = {
+  midAngle: number,
+  outerRadius: number,
+  color: string,
+  label: string,
+  value: number
+};
+export default ArrowLabel;

package/dist/esm/deprecated/UTPieChart/components/Legend/contants.js

@@ -0,0 +1,3 @@
+export const DEFAULT_POSITION = 'top-left';
+export const DEFAULT_INDICATOR_SIZE = 10;
+export const DEFAULT_TYPE = 'circle';

package/dist/esm/deprecated/UTPieChart/components/Legend/index.js

@@ -0,0 +1,75 @@
+import React from 'react';
+import { arrayOf, shape, string, number, bool } from 'prop-types';
+import UTLabel from '../../../../components/UTLabel';
+import { classesType } from '../../../../types/commonTypes';
+import { DEFAULT_INDICATOR_SIZE, DEFAULT_POSITION, DEFAULT_TYPE } from './contants';
+import styles from './styles.module.scss';
+const Legend = _ref => {
+  let {
+    classes,
+    data,
+    legend,
+    showPercentage,
+    showValue = false,
+    totalConsumption
+  } = _ref;
+  const {
+    indicatorWidth = DEFAULT_INDICATOR_SIZE,
+    indicatorHeight = DEFAULT_INDICATOR_SIZE,
+    type = DEFAULT_TYPE,
+    position = DEFAULT_POSITION
+  } = legend;
+  const {
+    legendLabel,
+    legendValueLabel,
+    legendsContainer,
+    legendItem
+  } = classes;
+  const legendItemRender = (label, color, value) => /*#__PURE__*/React.createElement("div", {
+    className: "".concat(styles.item, " ").concat(legendItem)
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(styles.indicator, " ").concat(styles[type]),
+    style: {
+      backgroundColor: color,
+      width: indicatorWidth,
+      height: indicatorHeight
+    }
+  }), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement(UTLabel, {
+    className: legendLabel
+  }, label), showPercentage && /*#__PURE__*/React.createElement(UTLabel, {
+    className: legendValueLabel
+  }, "".concat((value / totalConsumption * 100).toFixed(2), "%"))));
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(styles.container, " ").concat(styles[position], " ").concat(legendsContainer)
+  }, data.map(_ref2 => {
+    let {
+      label,
+      color,
+      value
+    } = _ref2;
+    return showValue ? /*#__PURE__*/React.createElement("div", {
+      className: styles.innerContainer
+    }, legendItemRender(label, color, value), /*#__PURE__*/React.createElement(UTLabel, {
+      className: legendValueLabel,
+      variant: "title3",
+      weight: "medium"
+    }, value)) : legendItemRender(label, color, value);
+  }));
+};
+Legend.propTypes = {
+  classes: classesType,
+  data: arrayOf(shape({
+    label: string,
+    color: string
+  })),
+  legend: shape({
+    indicatorHeight: number,
+    indicatorWidth: number,
+    position: string,
+    type: string
+  }),
+  showPercentage: bool,
+  showValue: bool,
+  totalConsumption: number
+};
+export default Legend;

package/dist/esm/deprecated/UTPieChart/components/Legend/styles.module.scss

@@ -0,0 +1,34 @@
+.container {
+  margin: auto;
+  width: fit-content;
+}
+
+.item {
+  align-items: center;
+  display: flex;
+
+  & + div {
+    margin-top: 10px;
+  }
+}
+
+.indicator {
+  flex-shrink: 0;
+  margin-right: 10px;
+}
+
+.square {
+  border-radius: 2px;
+}
+
+.circle {
+  border-radius: 50%;
+}
+
+.innerContainer {
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  grid-gap: 24px;
+  justify-content: center;
+}

package/dist/esm/deprecated/UTPieChart/constants.js

@@ -0,0 +1,13 @@
+export const DEFAULT_DATA = [];
+export const DEFAULT_INNER_RADIUS = 0;
+export const DEFAULT_OUTER_RADIUS = 100;
+export const DEFAULT_ANIMATION_LENGTH = 1500;
+export const DEFAULT_LEGEND = {};
+export const TRANSPARENT = '#00000000';
+export const ANIMATION_ID = 'animation';
+export const DEFAULT_TRANSITION = 'ease-out';
+export const OUTLINE_SEPARATION = 5;
+export const OUTLINE_WIDTH = 5;
+export const DEFAULT_PADDING_ANGLE = 0;
+export const DEFAULT_INITIAL_ANGLE = 0;
+export const DEFAULT_MIN_ANGLE = 0.1;

package/dist/esm/deprecated/UTPieChart/index.js

@@ -0,0 +1,172 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import React, { useEffect } from 'react';
+import * as d3 from 'd3';
+import { arrayOf, shape, number, string, bool, func } from 'prop-types';
+import { useAnimatedValue, useComponentDimensions } from '@widergy/energy-hooks';
+import { classesType } from '../../types/commonTypes';
+import WithTheme from '../../components/WithTheme';
+import { retrieveStyle } from './theme';
+import Legend from './components/Legend';
+import ArrowLabel from './components/ArrowLabel';
+import styles from './styles.module.scss';
+import { animationSort } from './utils';
+import { ANIMATION_ID, DEFAULT_ANIMATION_LENGTH, DEFAULT_DATA, DEFAULT_INITIAL_ANGLE, DEFAULT_INNER_RADIUS, DEFAULT_LEGEND, DEFAULT_MIN_ANGLE, DEFAULT_OUTER_RADIUS, DEFAULT_PADDING_ANGLE, DEFAULT_TRANSITION, OUTLINE_SEPARATION, OUTLINE_WIDTH, TRANSPARENT } from './constants';
+import { DEFAULT_POSITION } from './components/Legend/contants';
+const UTPieChart = _ref => {
+  let {
+    animationLength,
+    classes,
+    className,
+    classNames = {},
+    data,
+    gradientGenerator,
+    height,
+    initialAngle,
+    innerRadius,
+    legend,
+    minAngle,
+    onClickItem,
+    outerRadius,
+    outlined,
+    paddingAngle,
+    showPercentageInLegend,
+    showValueInLegend,
+    transition,
+    width,
+    withLabels,
+    withLegend
+  } = _ref;
+  const totalSum = data.reduce((acc, _ref2) => {
+    let {
+      value
+    } = _ref2;
+    return acc + value;
+  }, 0);
+  const {
+    animatedValue: pieGrowth,
+    animate
+  } = useAnimatedValue({
+    transition
+  });
+  const {
+    width: containerWidth,
+    height: containerHeight,
+    ref
+  } = useComponentDimensions();
+  useEffect(() => {
+    animate(totalSum * 100, 0, animationLength);
+  }, []);
+  const newPieData = [...data, {
+    value: pieGrowth,
+    color: TRANSPARENT,
+    id: ANIMATION_ID
+  }];
+  const outlineGenerator = d3.arc().innerRadius(outerRadius + OUTLINE_SEPARATION).outerRadius(outerRadius + OUTLINE_SEPARATION + OUTLINE_WIDTH).padAngle(paddingAngle);
+  const arcGenerator = d3.arc().innerRadius(innerRadius).outerRadius(outerRadius).padAngle(paddingAngle);
+  const pieGenerator = d3.pie().startAngle(Math.PI / 2 + initialAngle).endAngle(2 * Math.PI + (Math.PI / 2 + initialAngle)).sort((a, b) => a.value > b.value ? 1 : -1).sort(animationSort).value(_ref3 => {
+    let {
+      value,
+      id
+    } = _ref3;
+    return id ? value : value / totalSum < minAngle ? totalSum * minAngle : value;
+  });
+  const pie = pieGenerator(newPieData);
+  const {
+    position = DEFAULT_POSITION
+  } = legend;
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      width,
+      height
+    },
+    className: "".concat(styles.container, " ").concat(className, " ").concat(styles["".concat(position.split('-')[0], "Container")])
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(styles["".concat(position.split('-')[0], "LegendWrapper")], " ").concat(styles[position])
+  }, withLegend && /*#__PURE__*/React.createElement(Legend, {
+    classes: classes,
+    data: data,
+    legend: legend,
+    showPercentage: showPercentageInLegend,
+    showValue: showValueInLegend,
+    totalConsumption: totalSum
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(styles["".concat(position.split('-')[0], "PieWrapper")], " ").concat(classNames.chartContainer),
+    ref: ref
+  }, /*#__PURE__*/React.createElement("svg", {
+    viewBox: "".concat(-containerWidth / 2, " ").concat(-containerHeight / 2, " ").concat(containerWidth, " ").concat(containerHeight),
+    width: containerWidth,
+    height: containerHeight
+  }, gradientGenerator === null || gradientGenerator === void 0 ? void 0 : gradientGenerator(), pie.map(slice => /*#__PURE__*/React.createElement("path", _extends({
+    d: arcGenerator(slice),
+    fill: slice.data.color
+  }, onClickItem && {
+    className: styles.clickableItem,
+    onClick: onClickItem(slice)
+  }))), outlined && pie.map(slice => /*#__PURE__*/React.createElement("path", {
+    d: outlineGenerator(slice),
+    fill: slice.data.color
+  })), withLabels && /*#__PURE__*/React.createElement("g", null, pie.map(slice => {
+    const {
+      endAngle,
+      startAngle
+    } = slice;
+    const {
+      label,
+      color,
+      value,
+      id
+    } = slice.data;
+    return !id && (label || value) && /*#__PURE__*/React.createElement(ArrowLabel, {
+      color: color,
+      label: label,
+      midAngle: (endAngle - startAngle) / 2 + startAngle,
+      outerRadius: outerRadius + (outlined ? OUTLINE_SEPARATION + OUTLINE_WIDTH : 0),
+      value: value / totalSum
+    });
+  })))));
+};
+UTPieChart.propTypes = {
+  animationLength: number,
+  classes: classesType,
+  className: string,
+  classNames: shape({
+    chartContainer: string
+  }),
+  data: arrayOf(shape({
+    color: string,
+    label: string,
+    value: number
+  })),
+  gradientGenerator: func,
+  height: number,
+  initialAngle: number,
+  innerRadius: number,
+  legend: shape({
+    position: string,
+    type: string
+  }),
+  minAngle: number,
+  onClickItem: func,
+  outerRadius: number,
+  outlined: bool,
+  paddingAngle: number,
+  showPercentageInLegend: bool,
+  showValueInLegend: bool,
+  transition: string,
+  width: number,
+  withLabels: bool,
+  withLegend: bool
+};
+UTPieChart.defaultProps = {
+  animationLength: DEFAULT_ANIMATION_LENGTH,
+  classes: {},
+  data: DEFAULT_DATA,
+  initialAngle: DEFAULT_INITIAL_ANGLE,
+  innerRadius: DEFAULT_INNER_RADIUS,
+  legend: DEFAULT_LEGEND,
+  minAngle: DEFAULT_MIN_ANGLE,
+  outerRadius: DEFAULT_OUTER_RADIUS,
+  paddingAngle: DEFAULT_PADDING_ANGLE,
+  transition: DEFAULT_TRANSITION
+};
+export default WithTheme(retrieveStyle)(UTPieChart);

package/dist/esm/deprecated/UTPieChart/styles.module.scss

@@ -0,0 +1,83 @@
+.container {
+  align-items: center;
+  display: flex;
+  justify-content: center;
+  overflow: hidden;
+}
+
+.bottomLegendWrapper,
+.topLegendWrapper {
+  height: fit-content;
+  width: fit-content;
+}
+
+.bottomPieWrapper,
+.topPieWrapper {
+  flex: 1 1 auto;
+  height: 0;
+  width: 100%;
+}
+
+.rightLegendWrapper,
+.leftLegendWrapper {
+  height: fit-content;
+  width: 50%;
+}
+
+.rightPieWrapper,
+.leftPieWrapper {
+  height: 100%;
+  width: 50%;
+}
+
+.top {
+  margin: 0 auto;
+}
+
+.bottom {
+  margin: 0 auto;
+}
+
+.left {
+  margin: auto 0;
+}
+
+.right {
+  margin: auto 0;
+}
+
+.top-left {
+  margin: 0 auto 0 0;
+}
+
+.top-right {
+  margin: 0 0 0 auto;
+}
+
+.bottom-left {
+  margin: 0 auto 0 0;
+}
+
+.bottom-right {
+  margin: 0 0 0 auto;
+}
+
+.topContainer {
+  flex-direction: column;
+}
+
+.bottomContainer {
+  flex-direction: column-reverse;
+}
+
+.leftContainer {
+  flex-direction: row;
+}
+
+.rightContainer {
+  flex-direction: row-reverse;
+}
+
+.clickableItem {
+  cursor: pointer;
+}

package/dist/esm/deprecated/UTPieChart/theme.js

@@ -0,0 +1,29 @@
+import { getIn } from 'seamless-immutable';
+export const retrieveStyle = _ref => {
+  let {
+    theme
+  } = _ref;
+  return {
+    legendLabel: {
+      fontWeight: getIn(theme, ['UTPieChart', 'legendLabel', 'fontWeight']),
+      textTransform: getIn(theme, ['UTPieChart', 'legendLabel', 'textTransform']),
+      fontSize: getIn(theme, ['UTPieChart', 'legendLabel', 'fontSize']),
+      color: getIn(theme, ['UTPieChart', 'legendLabel', 'color'])
+    },
+    legendValueLabel: {
+      fontWeight: getIn(theme, ['UTPieChart', 'legendValueLabel', 'fontWeight']),
+      textTransform: getIn(theme, ['UTPieChart', 'legendValueLabel', 'textTransform']),
+      fontSize: getIn(theme, ['UTPieChart', 'legendValueLabel', 'fontSize']),
+      color: getIn(theme, ['UTPieChart', 'legendValueLabel', 'color'])
+    },
+    legendsContainer: {
+      display: getIn(theme, ['UTPieChart', 'legendsContainer', 'display']),
+      flexWrap: getIn(theme, ['UTPieChart', 'legendsContainer', 'flexWrap']),
+      justifyContent: getIn(theme, ['UTPieChart', 'legendsContainer', 'justifyContent'])
+    },
+    legendItem: {
+      margin: getIn(theme, ['UTPieChart', 'legendItem', 'margin']),
+      width: getIn(theme, ['UTPieChart', 'legendItem', 'width'])
+    }
+  };
+};

package/dist/esm/deprecated/UTPieChart/utils.js

@@ -0,0 +1,7 @@
+import { ANIMATION_ID } from './constants';
+export const animationSort = _ref => {
+  let {
+    id
+  } = _ref;
+  return id === ANIMATION_ID ? 0 : -1;
+};