victory-pie 36.8.2 → 36.8.3

package/es/victory-pie.js

@@ -1,3 +1,17 @@
+import _isNil from "lodash/isNil";
+
+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); } }
@@ -18,12 +32,10 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-/* eslint no-magic-numbers: ["error", { "ignore": [-1, 0, 1, 2] }]*/
 import React from "react";
-import PropTypes from "prop-types";
-import { addEvents, Helpers, Data, PropTypes as CustomPropTypes, VictoryContainer, VictoryLabel, VictoryTheme, UserProps } from "victory-core";
-import Slice from "./slice";
+import { addEvents, Helpers, Data, LineSegment, VictoryContainer, VictoryLabel, VictoryTheme, UserProps } from "victory-core";
 import { getBaseProps } from "./helper-methods";
+import { Slice } from "./slice";
 var fallbackProps = {
   endAngle: 360,
   height: 400,
@@ -34,26 +46,98 @@ var fallbackProps = {
   width: 400,
   startAngle: 0,
   colorScale: ["#ffffff", "#f0f0f0", "#d9d9d9", "#bdbdbd", "#969696", "#737373", "#525252", "#252525", "#000000"],
-  labelPosition: "centroid"
+  labelPosition: "centroid",
+  labelIndicatorInnerOffset: 15,
+  labelIndicatorOuterOffset: 5
 };
 
-var VictoryPie = /*#__PURE__*/function (_React$Component) {
-  _inherits(VictoryPie, _React$Component);
+var datumHasXandY = function (datum) {
+  return !_isNil(datum._x) && !_isNil(datum._y);
+}; // eslint-disable-next-line @typescript-eslint/no-empty-interface
 
-  var _super = _createSuper(VictoryPie);
 
-  function VictoryPie() {
-    _classCallCheck(this, VictoryPie);
+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(VictoryPie, [{
+  _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() {
@@ -65,19 +149,19 @@ var VictoryPie = /*#__PURE__*/function (_React$Component) {
         return this.animateComponent(props, animationWhitelist);
       }
 
-      var children = this.renderData(props);
+      var children = this.renderComponents(props);
       var component = props.standalone ? this.renderContainer(props.containerComponent, children) : children;
       return UserProps.withSafeUserProps(component, props);
     }
   }]);
 
-  return VictoryPie;
+  return VictoryPieBase;
 }(React.Component);
 
-VictoryPie.animationWhitelist = ["data", "endAngle", "height", "innerRadius", "cornerRadius", "padAngle", "padding", "colorScale", "startAngle", "style", "width"];
-VictoryPie.displayName = "VictoryPie";
-VictoryPie.role = "pie";
-VictoryPie.defaultTransitions = {
+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 () {
@@ -103,68 +187,7 @@ VictoryPie.defaultTransitions = {
     }
   }
 };
-VictoryPie.propTypes = {
-  animate: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
-  colorScale: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.oneOf(["grayscale", "qualitative", "heatmap", "warm", "cool", "red", "green", "blue"])]),
-  containerComponent: PropTypes.element,
-  cornerRadius: PropTypes.oneOfType([CustomPropTypes.nonNegative, PropTypes.func]),
-  data: PropTypes.array,
-  dataComponent: PropTypes.element,
-  disableInlineStyes: PropTypes.bool,
-  endAngle: PropTypes.number,
-  eventKey: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string]),
-  events: PropTypes.arrayOf(PropTypes.shape({
-    target: PropTypes.oneOf(["data", "labels", "parent"]),
-    eventKey: PropTypes.oneOfType([PropTypes.array, PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string]),
-    eventHandlers: PropTypes.object
-  })),
-  externalEventMutations: PropTypes.arrayOf(PropTypes.shape({
-    callback: PropTypes.func,
-    childName: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
-    eventKey: PropTypes.oneOfType([PropTypes.array, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string]),
-    mutation: PropTypes.func,
-    target: PropTypes.oneOfType([PropTypes.string, PropTypes.array])
-  })),
-  groupComponent: PropTypes.element,
-  height: CustomPropTypes.nonNegative,
-  innerRadius: PropTypes.oneOfType([CustomPropTypes.nonNegative, PropTypes.func]),
-  labelComponent: PropTypes.element,
-  labelPlacement: PropTypes.oneOfType([PropTypes.func, PropTypes.oneOf(["parallel", "perpendicular", "vertical"])]),
-  labelPosition: PropTypes.oneOfType([PropTypes.func, PropTypes.oneOf(["startAngle", "centroid", "endAngle"])]),
-  labelRadius: PropTypes.oneOfType([CustomPropTypes.nonNegative, PropTypes.func]),
-  labels: PropTypes.oneOfType([PropTypes.func, PropTypes.array]),
-  name: PropTypes.string,
-  origin: PropTypes.shape({
-    x: CustomPropTypes.nonNegative,
-    y: CustomPropTypes.nonNegative
-  }),
-  padAngle: PropTypes.oneOfType([CustomPropTypes.nonNegative, PropTypes.func]),
-  padding: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
-    top: PropTypes.number,
-    bottom: PropTypes.number,
-    left: PropTypes.number,
-    right: PropTypes.number
-  })]),
-  radius: PropTypes.oneOfType([CustomPropTypes.nonNegative, PropTypes.func]),
-  sharedEvents: PropTypes.shape({
-    events: PropTypes.array,
-    getEventState: PropTypes.func
-  }),
-  sortKey: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
-  sortOrder: PropTypes.oneOf(["ascending", "descending"]),
-  standalone: PropTypes.bool,
-  startAngle: PropTypes.number,
-  style: PropTypes.shape({
-    parent: PropTypes.object,
-    data: PropTypes.object,
-    labels: PropTypes.object
-  }),
-  theme: PropTypes.object,
-  width: CustomPropTypes.nonNegative,
-  x: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
-  y: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)])
-};
-VictoryPie.defaultProps = {
+VictoryPieBase.defaultProps = {
   data: [{
     x: "A",
     y: 1
@@ -190,10 +213,10 @@ VictoryPie.defaultProps = {
   theme: VictoryTheme.grayscale
 };
 
-VictoryPie.getBaseProps = function (props) {
+VictoryPieBase.getBaseProps = function (props) {
   return getBaseProps(props, fallbackProps);
 };
 
-VictoryPie.getData = Data.getData;
-VictoryPie.expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent"];
-export default addEvents(VictoryPie);
+VictoryPieBase.getData = Data.getData;
+VictoryPieBase.expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent", "labelIndicatorComponent"];
+export var VictoryPie = addEvents(VictoryPieBase);

package/lib/helper-methods.d.ts

@@ -0,0 +1,14 @@
+export declare const getXOffsetMultiplayerByAngle: (angle: any) => number;
+export declare const getYOffsetMultiplayerByAngle: (angle: any) => number;
+export declare const getXOffset: (offset: any, angle: any) => number;
+export declare const getYOffset: (offset: any, angle: any) => number;
+export declare const getAverage: (array: any) => number;
+export declare const getLabelIndicatorPropsForLineSegment: (props: any, calculatedValues: any, labelProps: any) => {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    index: any;
+};
+export declare const getBaseProps: (initialProps: any, fallbackProps: any) => any;
+//# sourceMappingURL=helper-methods.d.ts.map

package/lib/helper-methods.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getBaseProps = void 0;
+exports.getYOffsetMultiplayerByAngle = exports.getYOffset = exports.getXOffsetMultiplayerByAngle = exports.getXOffset = exports.getLabelIndicatorPropsForLineSegment = exports.getBaseProps = exports.getAverage = void 0;
 
 var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
 
@@ -72,7 +72,7 @@ var getCalculatedValues = function (props) {
 
   var styleObject = _victoryCore.Helpers.getDefaultStyles(props, "pie");
 
-  var style = _victoryCore.Helpers.getStyles(props.style, styleObject, "auto", "100%");
+  var style = _victoryCore.Helpers.getStyles(props.style, styleObject);
 
   var colors = Array.isArray(colorScale) ? colorScale : _victoryCore.Style.getColorScale(colorScale);
 
@@ -118,10 +118,13 @@ var getLabelText = function (props, datum, index) {
   return checkForValidText(text);
 };
 
-var getLabelArc = function (radius, labelRadius, style) {
+var getLabelArc = function (labelRadius) {
+  return d3Shape.arc().outerRadius(labelRadius).innerRadius(labelRadius);
+};
+
+var getCalculatedLabelRadius = function (radius, labelRadius, style) {
   var padding = style && style.padding || 0;
-  var arcRadius = labelRadius || radius + padding;
-  return d3Shape.arc().outerRadius(arcRadius).innerRadius(arcRadius);
+  return labelRadius || radius + padding;
 };
 
 var getLabelPosition = function (arc, slice, position) {
@@ -226,7 +229,8 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
     text: text
   }, dataProps));
 
-  var labelArc = getLabelArc(defaultRadius, labelRadius, evaluatedStyle);
+  var calculatedLabelRadius = getCalculatedLabelRadius(defaultRadius, labelRadius, evaluatedStyle);
+  var labelArc = getLabelArc(calculatedLabelRadius);
   var position = getLabelPosition(labelArc, slice, labelPosition);
   var baseAngle = getBaseLabelAngle(slice, labelPosition, labelStyle);
   var labelAngle = getLabelAngle(baseAngle, labelPlacement);
@@ -247,7 +251,8 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
     y: Math.round(position[1]) + origin.y,
     textAnchor: textAnchor,
     verticalAnchor: verticalAnchor,
-    angle: labelAngle
+    angle: labelAngle,
+    calculatedLabelRadius: calculatedLabelRadius
   };
 
   if (!_victoryCore.Helpers.isTooltip(labelComponent)) {
@@ -258,8 +263,76 @@ var getLabelProps = function (text, dataProps, calculatedValues) {
   return (0, _defaults2.default)({}, labelProps, _victoryCore.Helpers.omit(tooltipTheme, ["style"]));
 };
 
-var getBaseProps = function (props, fallbackProps) {
-  props = _victoryCore.Helpers.modifyProps(props, fallbackProps, "pie");
+var getXOffsetMultiplayerByAngle = function (angle) {
+  return Math.cos(angle - _victoryCore.Helpers.degreesToRadians(90));
+};
+
+exports.getXOffsetMultiplayerByAngle = getXOffsetMultiplayerByAngle;
+
+var getYOffsetMultiplayerByAngle = function (angle) {
+  return Math.sin(angle - _victoryCore.Helpers.degreesToRadians(90));
+};
+
+exports.getYOffsetMultiplayerByAngle = getYOffsetMultiplayerByAngle;
+
+var getXOffset = function (offset, angle) {
+  return offset * getXOffsetMultiplayerByAngle(angle);
+};
+
+exports.getXOffset = getXOffset;
+
+var getYOffset = function (offset, angle) {
+  return offset * getYOffsetMultiplayerByAngle(angle);
+};
+
+exports.getYOffset = getYOffset;
+
+var getAverage = function (array) {
+  return array.reduce(function (acc, cur) {
+    return acc + cur;
+  }, 0) / array.length;
+};
+
+exports.getAverage = getAverage;
+
+var getLabelIndicatorPropsForLineSegment = function (props, calculatedValues, labelProps) {
+  var innerRadius = props.innerRadius,
+      radius = props.radius,
+      _props$slice = props.slice,
+      startAngle = _props$slice.startAngle,
+      endAngle = _props$slice.endAngle,
+      labelIndicatorInnerOffset = props.labelIndicatorInnerOffset,
+      labelIndicatorOuterOffset = props.labelIndicatorOuterOffset,
+      index = props.index;
+  var height = calculatedValues.height,
+      width = calculatedValues.width;
+  var calculatedLabelRadius = labelProps.calculatedLabelRadius; // calculation
+
+  var middleRadius = getAverage([innerRadius, radius]);
+  var midAngle = getAverage([endAngle, startAngle]);
+  var centerX = width / 2;
+  var centerY = height / 2;
+  var innerOffset = middleRadius + labelIndicatorInnerOffset;
+  var outerOffset = calculatedLabelRadius - labelIndicatorOuterOffset;
+  var x1 = centerX + getXOffset(innerOffset, midAngle);
+  var y1 = centerY + getYOffset(innerOffset, midAngle);
+  var x2 = centerX + getXOffset(outerOffset, midAngle);
+  var y2 = centerY + getYOffset(outerOffset, midAngle);
+  var labelIndicatorProps = {
+    x1: x1,
+    y1: y1,
+    x2: x2,
+    y2: y2,
+    index: index
+  };
+  return (0, _defaults2.default)({}, labelIndicatorProps);
+};
+
+exports.getLabelIndicatorPropsForLineSegment = getLabelIndicatorPropsForLineSegment;
+
+var getBaseProps = function (initialProps, fallbackProps) {
+  var props = _victoryCore.Helpers.modifyProps(initialProps, fallbackProps, "pie");
+
   var calculatedValues = getCalculatedValues(props);
   var slices = calculatedValues.slices,
       style = calculatedValues.style,
@@ -276,7 +349,8 @@ var getBaseProps = function (props, fallbackProps) {
       innerRadius = calculatedValues.innerRadius,
       cornerRadius = calculatedValues.cornerRadius,
       padAngle = calculatedValues.padAngle,
-      disableInlineStyles = calculatedValues.disableInlineStyles;
+      disableInlineStyles = calculatedValues.disableInlineStyles,
+      labelIndicator = calculatedValues.labelIndicator;
   var radius = props.radius || defaultRadius;
   var initialChildProps = {
     parent: {
@@ -317,6 +391,14 @@ var getBaseProps = function (props, fallbackProps) {
       var evaluatedText = _victoryCore.Helpers.evaluateProp(text, dataProps);
 
       childProps[eventKey].labels = getLabelProps(evaluatedText, (0, _assign2.default)({}, props, dataProps), calculatedValues);
+
+      if (labelIndicator) {
+        var labelProps = childProps[eventKey].labels;
+
+        if (labelProps.calculatedLabelRadius > radius) {
+          childProps[eventKey].labelIndicators = getLabelIndicatorPropsForLineSegment((0, _assign2.default)({}, props, dataProps), calculatedValues, labelProps);
+        }
+      }
     }
 
     return childProps;

package/lib/index.d.ts

@@ -1,83 +1,3 @@
-import * as React from "react";
-import {
-  CategoryPropType,
-  ColorScalePropType,
-  DataGetterPropType,
-  EventPropTypeInterface,
-  StringOrCallback,
-  NumberOrCallback,
-  OriginType,
-  SliceNumberOrCallback,
-  StringOrNumberOrCallback,
-  VictoryCommonProps,
-  VictoryLabelableProps,
-  VictoryMultiLabelableProps,
-  VictoryStyleInterface,
-} from "victory-core";
-
-export type VictorySliceLabelPositionType =
-  | "startAngle"
-  | "centroid"
-  | "endAngle";
-export type VictorySliceLabelPlacementType =
-  | "vertical"
-  | "parallel"
-  | "perpendicular";
-export type VictorySliceTTargetType = "data" | "labels" | "parent";
-
-export interface SliceProps extends VictoryCommonProps {
-  ariaLabel?: StringOrCallback;
-  cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
-  datum?: any;
-  innerRadius?: NumberOrCallback;
-  padAngle?: SliceNumberOrCallback<SliceProps, "padAngle">;
-  pathComponent?: React.ReactElement;
-  pathFunction?: (props: SliceProps) => string;
-  radius?: SliceNumberOrCallback<SliceProps, "radius">;
-  slice?: {
-    startAngle?: number;
-    endAngle?: number;
-    padAngle?: number;
-    data?: any[];
-  };
-  sliceEndAngle?: SliceNumberOrCallback<SliceProps, "sliceEndAngle">;
-  sliceStartAngle?: SliceNumberOrCallback<SliceProps, "sliceStartAngle">;
-  style?: VictoryStyleInterface;
-  tabIndex?: NumberOrCallback;
-}
-
-export class Slice extends React.Component<SliceProps, any> {}
-
-export interface VictoryPieProps
-  extends Omit<VictoryCommonProps, "polar">,
-    VictoryLabelableProps,
-    VictoryMultiLabelableProps {
-  categories?: CategoryPropType;
-  colorScale?: ColorScalePropType;
-  cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
-  data?: any[];
-  dataComponent?: React.ReactElement;
-  endAngle?: number;
-  events?: EventPropTypeInterface<
-    VictorySliceTTargetType,
-    StringOrNumberOrCallback | string[] | number[]
-  >[];
-  eventKey?: StringOrNumberOrCallback;
-  innerRadius?: NumberOrCallback;
-  labelPlacement?:
-    | VictorySliceLabelPlacementType
-    | ((props: SliceProps) => VictorySliceLabelPlacementType);
-  labelPosition?:
-    | VictorySliceLabelPositionType
-    | ((props: SliceProps) => VictorySliceLabelPositionType);
-  labelRadius?: number | ((props: SliceProps) => number);
-  origin?: OriginType;
-  padAngle?: NumberOrCallback;
-  radius?: NumberOrCallback;
-  startAngle?: number;
-  style?: VictoryStyleInterface;
-  x?: DataGetterPropType;
-  y?: DataGetterPropType;
-}
-
-export class VictoryPie extends React.Component<VictoryPieProps, any> {}
+export * from "./victory-pie";
+export * from "./slice";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -3,21 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "Slice", {
-  enumerable: true,
-  get: function () {
-    return _slice.default;
-  }
-});
-Object.defineProperty(exports, "VictoryPie", {
-  enumerable: true,
-  get: function () {
-    return _victoryPie.default;
-  }
-});
 
-var _victoryPie = _interopRequireDefault(require("./victory-pie"));
+var _victoryPie = require("./victory-pie");
+
+Object.keys(_victoryPie).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _victoryPie[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _victoryPie[key];
+    }
+  });
+});
 
-var _slice = _interopRequireDefault(require("./slice"));
+var _slice = require("./slice");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+Object.keys(_slice).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _slice[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _slice[key];
+    }
+  });
+});

package/lib/slice.d.ts

@@ -0,0 +1,62 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { NumberOrCallback, SliceNumberOrCallback, StringOrCallback, VictoryCommonProps, VictoryStyleInterface } from "victory-core";
+export declare type VictorySliceLabelPositionType = "startAngle" | "centroid" | "endAngle";
+export declare type VictorySliceLabelPlacementType = "vertical" | "parallel" | "perpendicular";
+export declare type VictorySliceTTargetType = "data" | "labels" | "parent";
+export interface SliceProps extends VictoryCommonProps {
+    ariaLabel?: StringOrCallback;
+    cornerRadius?: SliceNumberOrCallback<SliceProps, "cornerRadius">;
+    datum?: any;
+    innerRadius?: NumberOrCallback;
+    padAngle?: SliceNumberOrCallback<SliceProps, "padAngle">;
+    pathComponent?: React.ReactElement;
+    pathFunction?: (props: SliceProps) => string;
+    radius?: SliceNumberOrCallback<SliceProps, "radius">;
+    slice?: {
+        startAngle?: number;
+        endAngle?: number;
+        padAngle?: number;
+        data?: any[];
+    };
+    sliceEndAngle?: SliceNumberOrCallback<SliceProps, "sliceEndAngle">;
+    sliceStartAngle?: SliceNumberOrCallback<SliceProps, "sliceStartAngle">;
+    style?: VictoryStyleInterface;
+    tabIndex?: NumberOrCallback;
+    role?: string;
+    shapeRendering?: string;
+}
+export declare const Slice: {
+    (initialProps: SliceProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+    propTypes: {
+        cornerRadius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        datum: PropTypes.Requireable<object>;
+        innerRadius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        padAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        pathComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        pathFunction: PropTypes.Requireable<(...args: any[]) => any>;
+        radius: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        slice: PropTypes.Requireable<object>;
+        sliceEndAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        sliceStartAngle: PropTypes.Requireable<number | ((...args: any[]) => any)>;
+        active?: React.Validator<boolean | null | undefined> | undefined;
+        ariaLabel?: React.Validator<StringOrCallback | null | undefined> | undefined;
+        className?: React.Validator<string | null | undefined> | undefined;
+        clipPath?: React.Validator<string | null | undefined> | undefined;
+        data?: React.Validator<any> | undefined;
+        desc?: React.Validator<string | Function | null | undefined> | undefined;
+        disableInlineStyles?: React.Validator<boolean | null | undefined> | undefined;
+        events?: React.Validator<object | null | undefined> | undefined;
+        id?: React.Validator<string | number | Function | null | undefined> | undefined;
+        index?: React.Validator<string | number | null | undefined> | undefined;
+        origin?: React.Validator<import("victory-core").OriginType | null | undefined> | undefined;
+        polar?: React.Validator<boolean | null | undefined> | undefined;
+        role?: React.Validator<string | null | undefined> | undefined;
+        scale?: React.Validator<any> | undefined;
+        shapeRendering?: React.Validator<string | null | undefined> | undefined;
+        style?: React.Validator<any> | undefined;
+        tabIndex?: React.Validator<NumberOrCallback | null | undefined> | undefined;
+        transform?: React.Validator<string | null | undefined> | undefined;
+    };
+};
+//# sourceMappingURL=slice.d.ts.map

package/lib/slice.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.Slice = void 0;
 
 var _assign2 = _interopRequireDefault(require("lodash/assign"));
 
@@ -116,8 +116,8 @@ var defaultProps = {
   shapeRendering: "auto"
 };
 
-var Slice = function (props) {
-  props = evaluateProps(_objectSpread(_objectSpread({}, defaultProps), props));
+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.default.cloneElement(props.pathComponent, _objectSpread(_objectSpread({}, props.events), {}, {
     "aria-label": props.ariaLabel,
@@ -132,6 +132,7 @@ var Slice = function (props) {
   }));
 };
 
+exports.Slice = Slice;
 Slice.propTypes = _objectSpread(_objectSpread({}, _victoryCore.CommonProps.primitiveProps), {}, {
   cornerRadius: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.func]),
   datum: _propTypes.default.object,
@@ -143,6 +144,4 @@ Slice.propTypes = _objectSpread(_objectSpread({}, _victoryCore.CommonProps.primi
   slice: _propTypes.default.object,
   sliceEndAngle: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.func]),
   sliceStartAngle: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.func])
-});
-var _default = Slice;
-exports.default = _default;
+});