victory-pie 36.9.2 → 37.0.0

package/es/slice.js

@@ -1,37 +1,28 @@
 import _defaults from "lodash/defaults";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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; }
-
 import React from "react";
 import { Helpers, Path } from "victory-core";
 import * as d3Shape from "victory-vendor/d3-shape";
-
-var getPath = function (props) {
-  var slice = props.slice,
-      radius = props.radius,
-      innerRadius = props.innerRadius,
-      cornerRadius = props.cornerRadius;
-
+const getPath = props => {
+  const {
+    slice,
+    radius,
+    innerRadius,
+    cornerRadius
+  } = props;
   if (Helpers.isFunction(props.pathFunction)) {
     return props.pathFunction(slice);
   }
-
-  var padAngle = Helpers.degreesToRadians(props.padAngle);
-  var startAngle = Helpers.degreesToRadians(props.sliceStartAngle);
-  var endAngle = Helpers.degreesToRadians(props.sliceEndAngle);
-  var pathFunction = d3Shape.arc().cornerRadius(cornerRadius).outerRadius(radius).innerRadius(innerRadius || 0);
+  const padAngle = Helpers.degreesToRadians(props.padAngle);
+  const startAngle = Helpers.degreesToRadians(props.sliceStartAngle);
+  const endAngle = Helpers.degreesToRadians(props.sliceEndAngle);
+  const pathFunction = d3Shape.arc().cornerRadius(cornerRadius).outerRadius(radius).innerRadius(innerRadius || 0);
   return pathFunction(_defaults({
-    startAngle: startAngle,
-    endAngle: endAngle,
-    padAngle: padAngle
+    startAngle,
+    endAngle,
+    padAngle
   }, slice));
 };
-
-var evaluateProps = function (props) {
+const evaluateProps = props => {
   /**
    * * Potential evaluated props of following must be evaluated in this order:
    * 1) `style`
@@ -47,44 +38,47 @@ var evaluateProps = function (props) {
    * `sliceEndAngle`
    * `tabIndex`
    */
-  var style = Helpers.evaluateStyle(props.style, props);
-  var radius = Helpers.evaluateProp(props.radius, Object.assign({}, props, {
-    style: style
+  const style = Helpers.evaluateStyle(props.style, props);
+  const radius = Helpers.evaluateProp(props.radius, Object.assign({}, props, {
+    style
   }));
-  var innerRadius = Helpers.evaluateProp(props.innerRadius, Object.assign({}, props, {
-    style: style,
-    radius: radius
+  const innerRadius = Helpers.evaluateProp(props.innerRadius, Object.assign({}, props, {
+    style,
+    radius
   }));
-  var ariaLabel = Helpers.evaluateProp(props.ariaLabel, props);
-  var id = Helpers.evaluateProp(props.id, props);
-  var cornerRadius = Helpers.evaluateProp(props.cornerRadius, props);
-  var padAngle = Helpers.evaluateProp(props.padAngle, props);
-  var sliceStartAngle = Helpers.evaluateProp(props.sliceStartAngle, props);
-  var sliceEndAngle = Helpers.evaluateProp(props.sliceEndAngle, props);
-  var tabIndex = Helpers.evaluateProp(props.tabIndex, props);
+  const ariaLabel = Helpers.evaluateProp(props.ariaLabel, props);
+  const id = Helpers.evaluateProp(props.id, props);
+  const cornerRadius = Helpers.evaluateProp(props.cornerRadius, props);
+  const padAngle = Helpers.evaluateProp(props.padAngle, props);
+  const sliceStartAngle = Helpers.evaluateProp(props.sliceStartAngle, props);
+  const sliceEndAngle = Helpers.evaluateProp(props.sliceEndAngle, props);
+  const tabIndex = Helpers.evaluateProp(props.tabIndex, props);
   return Object.assign({}, props, {
-    ariaLabel: ariaLabel,
-    style: style,
-    radius: radius,
-    innerRadius: innerRadius,
-    id: id,
-    cornerRadius: cornerRadius,
-    padAngle: padAngle,
-    sliceStartAngle: sliceStartAngle,
-    sliceEndAngle: sliceEndAngle,
-    tabIndex: tabIndex
+    ariaLabel,
+    style,
+    radius,
+    innerRadius,
+    id,
+    cornerRadius,
+    padAngle,
+    sliceStartAngle,
+    sliceEndAngle,
+    tabIndex
   });
 };
-
-var defaultProps = {
+const defaultProps = {
   pathComponent: /*#__PURE__*/React.createElement(Path, null),
   role: "presentation",
   shapeRendering: "auto"
 };
-export var Slice = function (initialProps) {
-  var props = evaluateProps(_objectSpread(_objectSpread({}, defaultProps), initialProps));
-  var defaultTransform = props.origin ? "translate(".concat(props.origin.x, ", ").concat(props.origin.y, ")") : undefined;
-  return /*#__PURE__*/React.cloneElement(props.pathComponent, _objectSpread(_objectSpread({}, props.events), {}, {
+export const Slice = initialProps => {
+  const props = evaluateProps({
+    ...defaultProps,
+    ...initialProps
+  });
+  const defaultTransform = props.origin ? `translate(${props.origin.x}, ${props.origin.y})` : undefined;
+  return /*#__PURE__*/React.cloneElement(props.pathComponent, {
+    ...props.events,
     "aria-label": props.ariaLabel,
     d: getPath(props),
     style: props.style,
@@ -94,5 +88,5 @@ export var Slice = function (initialProps) {
     shapeRendering: props.shapeRendering,
     clipPath: props.clipPath,
     tabIndex: props.tabIndex
-  }));
+  });
 };

package/es/victory-pie.js

@@ -1,40 +1,8 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _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); Object.defineProperty(Constructor, "prototype", { writable: false }); 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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : 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.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 import React from "react";
 import { addEvents, Helpers, Data, LineSegment, VictoryContainer, VictoryLabel, VictoryTheme, UserProps } from "victory-core";
 import { getBaseProps } from "./helper-methods";
 import { Slice } from "./slice";
-var fallbackProps = {
+const fallbackProps = {
   endAngle: 360,
   height: 400,
   innerRadius: 0,
@@ -48,173 +16,131 @@ var fallbackProps = {
   labelIndicatorInnerOffset: 15,
   labelIndicatorOuterOffset: 5
 };
-
-var datumHasXandY = function (datum) {
+const datumHasXandY = datum => {
   return !Helpers.isNil(datum._x) && !Helpers.isNil(datum._y);
-}; // eslint-disable-next-line @typescript-eslint/no-empty-interface
-
-
-var VictoryPieBase = /*#__PURE__*/function (_React$Component) {
-  _inherits(VictoryPieBase, _React$Component);
-
-  var _super = _createSuper(VictoryPieBase);
-
-  function VictoryPieBase() {
-    _classCallCheck(this, VictoryPieBase);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(VictoryPieBase, [{
-    key: "shouldAnimate",
-    value: // Overridden in victory-native
-    function shouldAnimate() {
-      return Boolean(this.props.animate);
-    }
-  }, {
-    key: "renderComponents",
-    value: function renderComponents(props) {
-      var _this = this;
-
-      var shouldRenderDatum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : datumHasXandY;
-      var dataComponent = props.dataComponent,
-          labelComponent = props.labelComponent,
-          groupComponent = props.groupComponent,
-          labelIndicator = props.labelIndicator,
-          labelPosition = props.labelPosition;
-
-      if (!groupComponent) {
-        throw new Error("VictoryPie expects a groupComponent prop");
-      }
-
-      var showIndicator = labelIndicator && labelPosition === "centroid";
-      var children = [];
-
-      if (dataComponent) {
-        var dataComponents = this.dataKeys.reduce(function (validDataComponents, _dataKey, index) {
-          var dataProps = _this.getComponentProps(dataComponent, "data", index);
-
-          if (shouldRenderDatum(dataProps.datum)) {
-            validDataComponents.push( /*#__PURE__*/React.cloneElement(dataComponent, dataProps));
-          }
-
-          return validDataComponents;
-        }, []);
-        children.push.apply(children, _toConsumableArray(dataComponents));
-      }
-
-      if (labelComponent) {
-        var labelComponents = this.dataKeys.map(function (_dataKey, index) {
-          var labelProps = _this.getComponentProps(labelComponent, "labels", index);
-
-          if (labelProps.text !== undefined && labelProps.text !== null) {
-            return /*#__PURE__*/React.cloneElement(labelComponent, labelProps);
-          }
-
-          return undefined;
-        }).filter(function (comp) {
-          return comp !== undefined;
-        });
-        children.push.apply(children, _toConsumableArray(labelComponents));
-      }
-
-      if (showIndicator && labelIndicator) {
-        var labelIndicatorComponent = /*#__PURE__*/React.createElement(LineSegment, null);
-
-        if (typeof labelIndicator === "object") {
-          // pass user provided react component
-          labelIndicatorComponent = labelIndicator;
-        }
-
-        var labelIndicatorComponents = this.dataKeys.map(function (_dataKey, index) {
-          var labelIndicatorProps = _this.getComponentProps(labelIndicatorComponent, "labelIndicators", index);
-
-          return /*#__PURE__*/React.cloneElement(labelIndicatorComponent, labelIndicatorProps);
-        });
-        children.push.apply(children, _toConsumableArray(labelIndicatorComponents));
-      }
-
-      return this.renderContainer(groupComponent, children);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var animationWhitelist = VictoryPie.animationWhitelist,
-          role = VictoryPie.role;
-      var props = Helpers.modifyProps(this.props, fallbackProps, role);
-
-      if (this.shouldAnimate()) {
-        return this.animateComponent(props, animationWhitelist);
-      }
-
-      var children = this.renderComponents(props);
-      var component = props.standalone ? this.renderContainer(props.containerComponent, children) : children;
-      return UserProps.withSafeUserProps(component, props);
-    }
-  }]);
+};
 
-  return VictoryPieBase;
-}(React.Component);
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
 
-VictoryPieBase.animationWhitelist = ["data", "endAngle", "height", "innerRadius", "cornerRadius", "padAngle", "padding", "colorScale", "startAngle", "style", "width"];
-VictoryPieBase.displayName = "VictoryPie";
-VictoryPieBase.role = "pie";
-VictoryPieBase.defaultTransitions = {
-  onExit: {
-    duration: 500,
-    before: function () {
-      return {
+class VictoryPieBase extends React.Component {
+  static animationWhitelist = ["data", "endAngle", "height", "innerRadius", "cornerRadius", "padAngle", "padding", "colorScale", "startAngle", "style", "width"];
+  static displayName = "VictoryPie";
+  static role = "pie";
+  static defaultTransitions = {
+    onExit: {
+      duration: 500,
+      before: () => ({
         _y: 0,
         label: " "
-      };
-    }
-  },
-  onEnter: {
-    duration: 500,
-    before: function () {
-      return {
+      })
+    },
+    onEnter: {
+      duration: 500,
+      before: () => ({
         _y: 0,
         label: " "
-      };
-    },
-    after: function (datum) {
-      return {
+      }),
+      after: datum => ({
         y_: datum._y,
         label: datum.label
-      };
+      })
     }
+  };
+  static defaultProps = {
+    data: [{
+      x: "A",
+      y: 1
+    }, {
+      x: "B",
+      y: 2
+    }, {
+      x: "C",
+      y: 3
+    }, {
+      x: "D",
+      y: 1
+    }, {
+      x: "E",
+      y: 2
+    }],
+    standalone: true,
+    dataComponent: /*#__PURE__*/React.createElement(Slice, null),
+    labelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
+    containerComponent: /*#__PURE__*/React.createElement(VictoryContainer, null),
+    groupComponent: /*#__PURE__*/React.createElement("g", null),
+    sortOrder: "ascending",
+    theme: VictoryTheme.grayscale
+  };
+  static getBaseProps = props => getBaseProps(props, fallbackProps);
+  static getData = Data.getData;
+  static expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent", "labelIndicatorComponent"];
+
+  // Overridden in victory-native
+  shouldAnimate() {
+    return Boolean(this.props.animate);
   }
-};
-VictoryPieBase.defaultProps = {
-  data: [{
-    x: "A",
-    y: 1
-  }, {
-    x: "B",
-    y: 2
-  }, {
-    x: "C",
-    y: 3
-  }, {
-    x: "D",
-    y: 1
-  }, {
-    x: "E",
-    y: 2
-  }],
-  standalone: true,
-  dataComponent: /*#__PURE__*/React.createElement(Slice, null),
-  labelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
-  containerComponent: /*#__PURE__*/React.createElement(VictoryContainer, null),
-  groupComponent: /*#__PURE__*/React.createElement("g", null),
-  sortOrder: "ascending",
-  theme: VictoryTheme.grayscale
-};
-
-VictoryPieBase.getBaseProps = function (props) {
-  return getBaseProps(props, fallbackProps);
-};
-
-VictoryPieBase.getData = Data.getData;
-VictoryPieBase.expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent", "labelIndicatorComponent"];
-export var VictoryPie = addEvents(VictoryPieBase);
+  renderComponents(props, shouldRenderDatum) {
+    if (shouldRenderDatum === void 0) {
+      shouldRenderDatum = datumHasXandY;
+    }
+    const {
+      dataComponent,
+      labelComponent,
+      groupComponent,
+      labelIndicator,
+      labelPosition
+    } = props;
+    if (!groupComponent) {
+      throw new Error("VictoryPie expects a groupComponent prop");
+    }
+    const showIndicator = labelIndicator && labelPosition === "centroid";
+    const children = [];
+    if (dataComponent) {
+      const dataComponents = this.dataKeys.reduce((validDataComponents, _dataKey, index) => {
+        const dataProps = this.getComponentProps(dataComponent, "data", index);
+        if (shouldRenderDatum(dataProps.datum)) {
+          validDataComponents.push( /*#__PURE__*/React.cloneElement(dataComponent, dataProps));
+        }
+        return validDataComponents;
+      }, []);
+      children.push(...dataComponents);
+    }
+    if (labelComponent) {
+      const labelComponents = this.dataKeys.map((_dataKey, index) => {
+        const labelProps = this.getComponentProps(labelComponent, "labels", index);
+        if (labelProps.text !== undefined && labelProps.text !== null) {
+          return /*#__PURE__*/React.cloneElement(labelComponent, labelProps);
+        }
+        return undefined;
+      }).filter(comp => comp !== undefined);
+      children.push(...labelComponents);
+    }
+    if (showIndicator && labelIndicator) {
+      let labelIndicatorComponent = /*#__PURE__*/React.createElement(LineSegment, null);
+      if (typeof labelIndicator === "object") {
+        // pass user provided react component
+        labelIndicatorComponent = labelIndicator;
+      }
+      const labelIndicatorComponents = this.dataKeys.map((_dataKey, index) => {
+        const labelIndicatorProps = this.getComponentProps(labelIndicatorComponent, "labelIndicators", index);
+        return /*#__PURE__*/React.cloneElement(labelIndicatorComponent, labelIndicatorProps);
+      });
+      children.push(...labelIndicatorComponents);
+    }
+    return this.renderContainer(groupComponent, children);
+  }
+  render() {
+    const {
+      animationWhitelist,
+      role
+    } = VictoryPie;
+    const props = Helpers.modifyProps(this.props, fallbackProps, role);
+    if (this.shouldAnimate()) {
+      return this.animateComponent(props, animationWhitelist);
+    }
+    const children = this.renderComponents(props);
+    const component = props.standalone ? this.renderContainer(props.containerComponent, children) : children;
+    return UserProps.withSafeUserProps(component, props);
+  }
+}
+export const VictoryPie = addEvents(VictoryPieBase);