victory-pie 36.9.2 → 37.0.0

package/es/helper-methods.js

@@ -1,83 +1,78 @@
 import _isPlainObject from "lodash/isPlainObject";
 import _defaults from "lodash/defaults";
+/* eslint no-magic-numbers: ["error", { "ignore": [-1, 0, 1, 2, 45, 90, 135, 180, 225, 270, 315, 360] }]*/
 import * as d3Shape from "victory-vendor/d3-shape";
 import { Helpers, Data, Style } from "victory-core";
-
-var checkForValidText = function (text) {
+const checkForValidText = text => {
   if (text === undefined || text === null || Helpers.isFunction(text)) {
     return text;
   }
-
-  return "".concat(text);
+  return `${text}`;
 };
-
-var getColor = function (style, colors, index) {
+const getColor = (style, colors, index) => {
   if (style && style.data && style.data.fill) {
     return style.data.fill;
   }
-
   return colors && colors[index % colors.length];
 };
-
-var getRadius = function (props, padding) {
+const getRadius = (props, padding) => {
   if (typeof props.radius === "number") {
     return props.radius;
   }
-
   return Math.min(props.width - padding.left - padding.right, props.height - padding.top - padding.bottom) / 2;
 };
-
-var getOrigin = function (props, padding) {
-  var width = props.width,
-      height = props.height;
-  var origin = _isPlainObject(props.origin) ? props.origin : {};
+const getOrigin = (props, padding) => {
+  const {
+    width,
+    height
+  } = props;
+  const origin = _isPlainObject(props.origin) ? props.origin : {};
   return {
     x: origin.x !== undefined ? origin.x : (padding.left - padding.right + width) / 2,
     y: origin.y !== undefined ? origin.y : (padding.top - padding.bottom + height) / 2
   };
 };
-
-var getSlices = function (props, data) {
-  var padAngle = Helpers.isFunction(props.padAngle) ? 0 : props.padAngle;
-  var layoutFunction = d3Shape.pie().sort(null).startAngle(Helpers.degreesToRadians(props.startAngle)).endAngle(Helpers.degreesToRadians(props.endAngle)).padAngle(Helpers.degreesToRadians(padAngle)).value(function (datum) {
+const getSlices = (props, data) => {
+  const padAngle = Helpers.isFunction(props.padAngle) ? 0 : props.padAngle;
+  const layoutFunction = d3Shape.pie().sort(null).startAngle(Helpers.degreesToRadians(props.startAngle)).endAngle(Helpers.degreesToRadians(props.endAngle)).padAngle(Helpers.degreesToRadians(padAngle)).value(datum => {
     return datum._y;
   });
   return layoutFunction(data);
 };
-
-var getCalculatedValues = function (props) {
-  var colorScale = props.colorScale;
-  var styleObject = Helpers.getDefaultStyles(props, "pie");
-  var style = Helpers.getStyles(props.style, styleObject);
-  var colors = Array.isArray(colorScale) ? colorScale : Style.getColorScale(colorScale);
-  var padding = Helpers.getPadding(props);
-  var defaultRadius = getRadius(props, padding);
-  var origin = getOrigin(props, padding);
-  var data = Data.getData(props);
-  var slices = getSlices(props, data);
+const getCalculatedValues = props => {
+  const {
+    colorScale
+  } = props;
+  const styleObject = Helpers.getDefaultStyles(props, "pie");
+  const style = Helpers.getStyles(props.style, styleObject);
+  const colors = Array.isArray(colorScale) ? colorScale : Style.getColorScale(colorScale);
+  const padding = Helpers.getPadding(props);
+  const defaultRadius = getRadius(props, padding);
+  const origin = getOrigin(props, padding);
+  const data = Data.getData(props);
+  const slices = getSlices(props, data);
   return Object.assign({}, props, {
-    style: style,
-    colors: colors,
-    padding: padding,
-    defaultRadius: defaultRadius,
-    data: data,
-    slices: slices,
-    origin: origin
+    style,
+    colors,
+    padding,
+    defaultRadius,
+    data,
+    slices,
+    origin
   });
 };
-
-var getSliceStyle = function (index, calculatedValues) {
-  var style = calculatedValues.style,
-      colors = calculatedValues.colors;
-  var fill = getColor(style, colors, index);
+const getSliceStyle = (index, calculatedValues) => {
+  const {
+    style,
+    colors
+  } = calculatedValues;
+  const fill = getColor(style, colors, index);
   return Object.assign({
-    fill: fill
+    fill
   }, style.data);
 };
-
-var getLabelText = function (props, datum, index) {
-  var text;
-
+const getLabelText = (props, datum, index) => {
+  let text;
   if (datum.label) {
     text = datum.label;
   } else if (Array.isArray(props.labels)) {
@@ -85,35 +80,29 @@ var getLabelText = function (props, datum, index) {
   } else {
     text = Helpers.isFunction(props.labels) ? props.labels : datum.xName || datum._x;
   }
-
   return checkForValidText(text);
 };
-
-var getLabelArc = function (labelRadius) {
+const getLabelArc = labelRadius => {
   return d3Shape.arc().outerRadius(labelRadius).innerRadius(labelRadius);
 };
-
-var getCalculatedLabelRadius = function (radius, labelRadius, style) {
-  var padding = style && style.padding || 0;
+const getCalculatedLabelRadius = (radius, labelRadius, style) => {
+  const padding = style && style.padding || 0;
   return labelRadius || radius + padding;
 };
-
-var getLabelPosition = function (arc, slice, position) {
-  var construct = {
+const getLabelPosition = (arc, slice, position) => {
+  const construct = {
     startAngle: position === "startAngle" ? slice.startAngle : slice.endAngle,
     endAngle: position === "endAngle" ? slice.endAngle : slice.startAngle
   };
-  var clonedArc = Object.assign({}, slice, construct);
+  const clonedArc = Object.assign({}, slice, construct);
   return arc.centroid(clonedArc);
 };
-
-var getLabelOrientation = function (degree, labelPlacement) {
+const getLabelOrientation = (degree, labelPlacement) => {
   if (labelPlacement === "perpendicular") {
     return degree > 90 && degree < 270 ? "bottom" : "top";
   } else if (labelPlacement === "parallel") {
     return degree >= 0 && degree <= 180 ? "right" : "left";
   }
-
   if (degree < 45 || degree > 315) {
     return "top";
   } else if (degree >= 45 && degree < 135) {
@@ -121,29 +110,22 @@ var getLabelOrientation = function (degree, labelPlacement) {
   } else if (degree >= 135 && degree < 225) {
     return "bottom";
   }
-
   return "left";
 };
-
-var getTextAnchor = function (orientation) {
+const getTextAnchor = orientation => {
   if (orientation === "top" || orientation === "bottom") {
     return "middle";
   }
-
   return orientation === "right" ? "start" : "end";
 };
-
-var getVerticalAnchor = function (orientation) {
+const getVerticalAnchor = orientation => {
   if (orientation === "left" || orientation === "right") {
     return "middle";
   }
-
   return orientation === "bottom" ? "start" : "end";
 };
-
-var getBaseLabelAngle = function (slice, labelPosition, labelStyle) {
-  var baseAngle = 0;
-
+const getBaseLabelAngle = (slice, labelPosition, labelStyle) => {
+  let baseAngle = 0;
   if (labelPosition.angle !== undefined) {
     baseAngle = labelStyle.angle;
   } else if (labelPosition === "centroid") {
@@ -151,204 +133,192 @@ var getBaseLabelAngle = function (slice, labelPosition, labelStyle) {
   } else {
     baseAngle = labelPosition === "startAngle" ? Helpers.radiansToDegrees(slice.startAngle) : Helpers.radiansToDegrees(slice.endAngle);
   }
-
-  var positiveAngle = baseAngle < 0 ? 360 - baseAngle : baseAngle;
+  const positiveAngle = baseAngle < 0 ? 360 - baseAngle : baseAngle;
   return positiveAngle % 360;
 };
-
-var getLabelAngle = function (baseAngle, labelPlacement) {
+const getLabelAngle = (baseAngle, labelPlacement) => {
   if (labelPlacement === "vertical") {
     return 0;
   }
-
   if (labelPlacement === "parallel") {
     return baseAngle > 180 && baseAngle < 360 ? baseAngle + 90 : baseAngle - 90;
   }
-
   return baseAngle > 90 && baseAngle < 270 ? baseAngle - 180 : baseAngle;
 };
-
-var getLabelProps = function (text, dataProps, calculatedValues) {
-  var index = dataProps.index,
-      datum = dataProps.datum,
-      data = dataProps.data,
-      slice = dataProps.slice,
-      labelComponent = dataProps.labelComponent,
-      theme = dataProps.theme;
-  var style = calculatedValues.style,
-      defaultRadius = calculatedValues.defaultRadius,
-      origin = calculatedValues.origin,
-      width = calculatedValues.width,
-      height = calculatedValues.height;
-  var labelRadius = Helpers.evaluateProp(calculatedValues.labelRadius, Object.assign({
-    text: text
+const getLabelProps = (text, dataProps, calculatedValues) => {
+  const {
+    index,
+    datum,
+    data,
+    slice,
+    labelComponent,
+    theme
+  } = dataProps;
+  const {
+    style,
+    defaultRadius,
+    origin,
+    width,
+    height
+  } = calculatedValues;
+  const labelRadius = Helpers.evaluateProp(calculatedValues.labelRadius, Object.assign({
+    text
   }, dataProps));
-  var labelPosition = Helpers.evaluateProp(calculatedValues.labelPosition, Object.assign({
-    text: text
+  const labelPosition = Helpers.evaluateProp(calculatedValues.labelPosition, Object.assign({
+    text
   }, dataProps)) || "centroid";
-  var labelPlacement = Helpers.evaluateProp(calculatedValues.labelPlacement, Object.assign({
-    text: text
+  const labelPlacement = Helpers.evaluateProp(calculatedValues.labelPlacement, Object.assign({
+    text
   }, dataProps)) || "vertical";
-  var labelStyle = Object.assign({
+  const labelStyle = Object.assign({
     padding: 0
   }, style.labels);
-  var evaluatedStyle = Helpers.evaluateStyle(labelStyle, Object.assign({
-    labelRadius: labelRadius,
-    text: text
+  const evaluatedStyle = Helpers.evaluateStyle(labelStyle, Object.assign({
+    labelRadius,
+    text
   }, dataProps));
-  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);
-  var orientation = getLabelOrientation(baseAngle, labelPlacement);
-  var textAnchor = labelStyle.textAnchor || getTextAnchor(orientation);
-  var verticalAnchor = labelStyle.verticalAnchor || getVerticalAnchor(orientation);
-  var labelProps = {
-    width: width,
-    height: height,
-    index: index,
-    datum: datum,
-    data: data,
-    slice: slice,
-    orientation: orientation,
-    text: text,
+  const calculatedLabelRadius = getCalculatedLabelRadius(defaultRadius, labelRadius, evaluatedStyle);
+  const labelArc = getLabelArc(calculatedLabelRadius);
+  const position = getLabelPosition(labelArc, slice, labelPosition);
+  const baseAngle = getBaseLabelAngle(slice, labelPosition, labelStyle);
+  const labelAngle = getLabelAngle(baseAngle, labelPlacement);
+  const orientation = getLabelOrientation(baseAngle, labelPlacement);
+  const textAnchor = labelStyle.textAnchor || getTextAnchor(orientation);
+  const verticalAnchor = labelStyle.verticalAnchor || getVerticalAnchor(orientation);
+  const labelProps = {
+    width,
+    height,
+    index,
+    datum,
+    data,
+    slice,
+    orientation,
+    text,
     style: labelStyle,
     x: Math.round(position[0]) + origin.x,
     y: Math.round(position[1]) + origin.y,
-    textAnchor: textAnchor,
-    verticalAnchor: verticalAnchor,
+    textAnchor,
+    verticalAnchor,
     angle: labelAngle,
-    calculatedLabelRadius: calculatedLabelRadius
+    calculatedLabelRadius
   };
-
   if (!Helpers.isTooltip(labelComponent)) {
     return labelProps;
   }
-
-  var tooltipTheme = theme && theme.tooltip || {};
+  const tooltipTheme = theme && theme.tooltip || {};
   return _defaults({}, labelProps, Helpers.omit(tooltipTheme, ["style"]));
 };
-
-export var getXOffsetMultiplayerByAngle = function (angle) {
-  return Math.cos(angle - Helpers.degreesToRadians(90));
-};
-export var getYOffsetMultiplayerByAngle = function (angle) {
-  return Math.sin(angle - Helpers.degreesToRadians(90));
-};
-export var getXOffset = function (offset, angle) {
-  return offset * getXOffsetMultiplayerByAngle(angle);
-};
-export var getYOffset = function (offset, angle) {
-  return offset * getYOffsetMultiplayerByAngle(angle);
-};
-export var getAverage = function (array) {
-  return array.reduce(function (acc, cur) {
-    return acc + cur;
-  }, 0) / array.length;
-};
-export 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
+export const getXOffsetMultiplayerByAngle = angle => Math.cos(angle - Helpers.degreesToRadians(90));
+export const getYOffsetMultiplayerByAngle = angle => Math.sin(angle - Helpers.degreesToRadians(90));
+export const getXOffset = (offset, angle) => offset * getXOffsetMultiplayerByAngle(angle);
+export const getYOffset = (offset, angle) => offset * getYOffsetMultiplayerByAngle(angle);
+export const getAverage = array => array.reduce((acc, cur) => acc + cur, 0) / array.length;
+export const getLabelIndicatorPropsForLineSegment = (props, calculatedValues, labelProps) => {
+  const {
+    innerRadius,
+    radius,
+    slice: {
+      startAngle,
+      endAngle
+    },
+    labelIndicatorInnerOffset,
+    labelIndicatorOuterOffset,
+    index
+  } = props;
+  const {
+    height,
+    width
+  } = calculatedValues;
+  const {
+    calculatedLabelRadius
+  } = labelProps;
+  // calculation
+  const middleRadius = getAverage([innerRadius, radius]);
+  const midAngle = getAverage([endAngle, startAngle]);
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const innerOffset = middleRadius + labelIndicatorInnerOffset;
+  const outerOffset = calculatedLabelRadius - labelIndicatorOuterOffset;
+  const x1 = centerX + getXOffset(innerOffset, midAngle);
+  const y1 = centerY + getYOffset(innerOffset, midAngle);
+  const x2 = centerX + getXOffset(outerOffset, midAngle);
+  const y2 = centerY + getYOffset(outerOffset, midAngle);
+  const labelIndicatorProps = {
+    x1,
+    y1,
+    x2,
+    y2,
+    index
   };
   return _defaults({}, labelIndicatorProps);
 };
-export var getBaseProps = function (initialProps, fallbackProps) {
-  var props = Helpers.modifyProps(initialProps, fallbackProps, "pie");
-  var calculatedValues = getCalculatedValues(props);
-  var slices = calculatedValues.slices,
-      style = calculatedValues.style,
-      data = calculatedValues.data,
-      origin = calculatedValues.origin,
-      defaultRadius = calculatedValues.defaultRadius,
-      labels = calculatedValues.labels,
-      events = calculatedValues.events,
-      sharedEvents = calculatedValues.sharedEvents,
-      height = calculatedValues.height,
-      width = calculatedValues.width,
-      standalone = calculatedValues.standalone,
-      name = calculatedValues.name,
-      innerRadius = calculatedValues.innerRadius,
-      cornerRadius = calculatedValues.cornerRadius,
-      padAngle = calculatedValues.padAngle,
-      disableInlineStyles = calculatedValues.disableInlineStyles,
-      labelIndicator = calculatedValues.labelIndicator;
-  var radius = props.radius || defaultRadius;
-  var initialChildProps = {
+export const getBaseProps = (initialProps, fallbackProps) => {
+  const props = Helpers.modifyProps(initialProps, fallbackProps, "pie");
+  const calculatedValues = getCalculatedValues(props);
+  const {
+    slices,
+    style,
+    data,
+    origin,
+    defaultRadius,
+    labels,
+    events,
+    sharedEvents,
+    height,
+    width,
+    standalone,
+    name,
+    innerRadius,
+    cornerRadius,
+    padAngle,
+    disableInlineStyles,
+    labelIndicator
+  } = calculatedValues;
+  const radius = props.radius || defaultRadius;
+  const initialChildProps = {
     parent: {
-      standalone: standalone,
-      height: height,
-      width: width,
-      slices: slices,
-      name: name,
+      standalone,
+      height,
+      width,
+      slices,
+      name,
       style: style.parent
     }
   };
-  return slices.reduce(function (childProps, slice, index) {
-    var datum = _defaults({}, data[index], {
+  return slices.reduce((childProps, slice, index) => {
+    const datum = _defaults({}, data[index], {
       startAngle: Helpers.radiansToDegrees(slice.startAngle),
       endAngle: Helpers.radiansToDegrees(slice.endAngle),
       padAngle: Helpers.radiansToDegrees(slice.padAngle)
     });
-
-    var eventKey = !Helpers.isNil(datum.eventKey) ? datum.eventKey : index;
-    var dataProps = {
-      index: index,
-      slice: slice,
-      datum: datum,
-      data: data,
-      origin: origin,
-      innerRadius: innerRadius,
-      radius: radius,
-      cornerRadius: cornerRadius,
-      padAngle: padAngle,
+    const eventKey = !Helpers.isNil(datum.eventKey) ? datum.eventKey : index;
+    const dataProps = {
+      index,
+      slice,
+      datum,
+      data,
+      origin,
+      innerRadius,
+      radius,
+      cornerRadius,
+      padAngle,
       style: disableInlineStyles ? {} : getSliceStyle(index, calculatedValues),
-      disableInlineStyles: disableInlineStyles
+      disableInlineStyles
     };
     childProps[eventKey] = {
       data: dataProps
     };
-    var text = getLabelText(props, datum, index);
-
+    const text = getLabelText(props, datum, index);
     if (text !== undefined && text !== null || labels && (events || sharedEvents)) {
-      var evaluatedText = Helpers.evaluateProp(text, dataProps);
+      const evaluatedText = Helpers.evaluateProp(text, dataProps);
       childProps[eventKey].labels = getLabelProps(evaluatedText, Object.assign({}, props, dataProps), calculatedValues);
-
       if (labelIndicator) {
-        var labelProps = childProps[eventKey].labels;
-
+        const labelProps = childProps[eventKey].labels;
         if (labelProps.calculatedLabelRadius > radius) {
           childProps[eventKey].labelIndicators = getLabelIndicatorPropsForLineSegment(Object.assign({}, props, dataProps), calculatedValues, labelProps);
         }
       }
     }
-
     return childProps;
   }, initialChildProps);
 };