victory-core 30.6.1 → 31.2.0

package/src/victory-util/events.js

@@ -1,6 +1,4 @@
-import {
-  assign, isEmpty, isFunction, without, pickBy, uniq, includes
-} from "lodash";
+import { assign, isEmpty, isFunction, without, pickBy, uniq, includes } from "lodash";
 
 export default {
   /* Returns all own and shared events that should be attached to a single target element,
@@ -16,8 +14,9 @@ export default {
       const getSelectedEvents = () => {
         const targetEvents = events.reduce((memo, event) => {
           if (event.target !== undefined) {
-            const matchesTarget = Array.isArray(event.target) ?
-              includes(event.target, target) : `${event.target}` === `${target}`;
+            const matchesTarget = Array.isArray(event.target)
+              ? includes(event.target, target)
+              : `${event.target}` === `${target}`;
             return matchesTarget ? memo.concat(event) : memo;
           }
           return memo.concat(event);
@@ -26,18 +25,22 @@ export default {
         if (eventKey !== undefined && target !== "parent") {
           return targetEvents.filter((obj) => {
             const targetKeys = obj.eventKey;
-            const useKey = (key) => key ? `${key}` === `${eventKey}` : true;
-            return Array.isArray(targetKeys) ?
-              targetKeys.some((k) => useKey(k)) : useKey(targetKeys);
+            const useKey = (key) => (key ? `${key}` === `${eventKey}` : true);
+            return Array.isArray(targetKeys)
+              ? targetKeys.some((k) => useKey(k))
+              : useKey(targetKeys);
           });
         }
         return targetEvents;
       };
 
       const selectedEvents = getSelectedEvents();
-      return Array.isArray(selectedEvents) && selectedEvents.reduce((memo, event) => {
-        return event ? assign(memo, event.eventHandlers) : memo;
-      }, {});
+      return (
+        Array.isArray(selectedEvents) &&
+        selectedEvents.reduce((memo, event) => {
+          return event ? assign(memo, event.eventHandlers) : memo;
+        }, {})
+      );
     };
 
     /* Returns all events from props and defaultEvents from components. Events handlers
@@ -46,20 +49,24 @@ export default {
      */
     const getAllEvents = () => {
       if (Array.isArray(this.componentEvents)) {
-        return Array.isArray(props.events) ?
-          this.componentEvents.concat(...props.events) : this.componentEvents;
+        return Array.isArray(props.events)
+          ? this.componentEvents.concat(...props.events)
+          : this.componentEvents;
       }
       return props.events;
     };
 
     const allEvents = getAllEvents();
-    const ownEvents = allEvents && isFunction(getScopedEvents) ?
-      getScopedEvents(getEventsByTarget(allEvents), target) : undefined;
+    const ownEvents =
+      allEvents && isFunction(getScopedEvents)
+        ? getScopedEvents(getEventsByTarget(allEvents), target)
+        : undefined;
     if (!props.sharedEvents) {
       return ownEvents;
     }
     const getSharedEvents = props.sharedEvents.getEvents;
-    const sharedEvents = props.sharedEvents.events &&
+    const sharedEvents =
+      props.sharedEvents.events &&
       getSharedEvents(getEventsByTarget(props.sharedEvents.events), target);
     return assign({}, sharedEvents, ownEvents);
   },
@@ -80,16 +87,18 @@ export default {
     const getTargetProps = (identifier, type) => {
       const { childName, target, key } = identifier;
       const baseType = type === "props" ? baseProps : this.state || {};
-      const base = (childName === undefined || childName === null || !baseType[childName]) ?
-        baseType : baseType[childName];
+      const base =
+        childName === undefined || childName === null || !baseType[childName]
+          ? baseType
+          : baseType[childName];
       return key === "parent" ? base.parent : base[key] && base[key][target];
     };
 
     // Returns the state object with the mutation caused by a given eventReturn
     // applied to the appropriate property on the state object
     const parseEvent = (eventReturn, eventKey) => {
-      const childNames = namespace === "parent" ?
-        eventReturn.childName : eventReturn.childName || childType;
+      const childNames =
+        namespace === "parent" ? eventReturn.childName : eventReturn.childName || childType;
       const target = eventReturn.target || namespace;
 
       // returns all eventKeys to modify for a targeted childName
@@ -98,12 +107,11 @@ export default {
           return "parent";
         }
         if (eventReturn.eventKey === "all") {
-          return baseProps[childName] ?
-            without(Object.keys(baseProps[childName]), "parent") :
-            without(Object.keys(baseProps), "parent");
+          return baseProps[childName]
+            ? without(Object.keys(baseProps[childName]), "parent")
+            : without(Object.keys(baseProps), "parent");
         } else if (eventReturn.eventKey === undefined && eventKey === "parent") {
-          return baseProps[childName] ?
-            Object.keys(baseProps[childName]) : Object.keys(baseProps);
+          return baseProps[childName] ? Object.keys(baseProps[childName]) : Object.keys(baseProps);
         }
         return eventReturn.eventKey !== undefined ? eventReturn.eventKey : eventKey;
       };
@@ -117,7 +125,8 @@ export default {
         const mutationTargetProps = getTargetProps({ childName, key, target }, "props");
         const mutationTargetState = getTargetProps({ childName, key, target }, "state");
         const mutatedProps = eventReturn.mutation(
-          assign({}, mutationTargetProps, mutationTargetState), baseProps
+          assign({}, mutationTargetProps, mutationTargetState),
+          baseProps
         );
         const childState = baseState[childName] || {};
 
@@ -132,55 +141,59 @@ export default {
         };
 
         const extendState = (state) => {
-          return target === "parent" ?
-            assign(state, { [key]: assign(state[key], mutatedProps) }) :
-            assign(state, { [key]: assign(state[key], { [target]: mutatedProps }) });
+          return target === "parent"
+            ? assign(state, { [key]: assign(state[key], mutatedProps) })
+            : assign(state, { [key]: assign(state[key], { [target]: mutatedProps }) });
         };
 
         const updateState = (state) => {
           return mutatedProps ? extendState(state) : filterState(state);
         };
 
-        return childName !== undefined && childName !== null ?
-          assign(baseState, { [childName]: updateState(childState) }) :
-          updateState(baseState);
+        return childName !== undefined && childName !== null
+          ? assign(baseState, { [childName]: updateState(childState) })
+          : updateState(baseState);
       };
 
       // returns entire mutated state for a given childName
       const getReturnByChild = (childName) => {
         const mutationKeys = getKeys(childName);
-        return Array.isArray(mutationKeys) ?
-          mutationKeys.reduce((memo, key) => {
-            return assign(memo, getMutationObject(key, childName));
-          }, {}) :
-          getMutationObject(mutationKeys, childName);
+        return Array.isArray(mutationKeys)
+          ? mutationKeys.reduce((memo, key) => {
+              return assign(memo, getMutationObject(key, childName));
+            }, {})
+          : getMutationObject(mutationKeys, childName);
       };
 
       // returns an entire mutated state for all children
-      const allChildNames = childNames === "all" ?
-        without(Object.keys(baseProps), "parent") : childNames;
-      return Array.isArray(allChildNames) ? allChildNames.reduce((memo, childName) => {
-        return assign(memo, getReturnByChild(childName));
-      }, {}) : getReturnByChild(allChildNames);
+      const allChildNames =
+        childNames === "all" ? without(Object.keys(baseProps), "parent") : childNames;
+      return Array.isArray(allChildNames)
+        ? allChildNames.reduce((memo, childName) => {
+            return assign(memo, getReturnByChild(childName));
+          }, {})
+        : getReturnByChild(allChildNames);
     };
 
     // Parses an array of event returns into a single state mutation
     const parseEventReturn = (eventReturn, eventKey) => {
-      return Array.isArray(eventReturn) ?
-        eventReturn.reduce((memo, props) => {
-          memo = assign({}, memo, parseEvent(props, eventKey));
-          return memo;
-        }, {}) :
-        parseEvent(eventReturn, eventKey);
+      return Array.isArray(eventReturn)
+        ? eventReturn.reduce((memo, props) => {
+            memo = assign({}, memo, parseEvent(props, eventKey));
+            return memo;
+          }, {})
+        : parseEvent(eventReturn, eventKey);
     };
 
     const compileCallbacks = (eventReturn) => {
       const getCallback = (obj) => isFunction(obj.callback) && obj.callback;
-      const callbacks = Array.isArray(eventReturn) ?
-        eventReturn.map((evtObj) => getCallback(evtObj)) : [getCallback(eventReturn)];
+      const callbacks = Array.isArray(eventReturn)
+        ? eventReturn.map((evtObj) => getCallback(evtObj))
+        : [getCallback(eventReturn)];
       const callbackArray = callbacks.filter((callback) => callback !== false);
-      return callbackArray.length ?
-        () => callbackArray.forEach((callback) => callback()) : undefined;
+      return callbackArray.length
+        ? () => callbackArray.forEach((callback) => callback())
+        : undefined;
     };
 
     // A function that calls a particular event handler, parses its return
@@ -205,13 +218,13 @@ export default {
    * This allows event handlers to have access to props controlling each element
    */
   getPartialEvents(events, eventKey, childProps) {
-    return events ?
-      Object.keys(events).reduce((memo, eventName) => {
-        const appliedEvent = (evt) => events[eventName](evt, childProps, eventKey, eventName);
-        memo[eventName] = appliedEvent;
-        return memo;
-      }, {}) :
-      {};
+    return events
+      ? Object.keys(events).reduce((memo, eventName) => {
+          const appliedEvent = (evt) => events[eventName](evt, childProps, eventKey, eventName);
+          memo[eventName] = appliedEvent;
+          return memo;
+        }, {})
+      : {};
   },
 
   /* Returns the property of the state object corresponding to event changes for
@@ -220,25 +233,23 @@ export default {
   getEventState(eventKey, namespace, childType) {
     const state = this.state || {};
     if (!childType) {
-      return eventKey === "parent" ?
-        state[eventKey] && state[eventKey][namespace] || state[eventKey] :
-        state[eventKey] && state[eventKey][namespace];
+      return eventKey === "parent"
+        ? (state[eventKey] && state[eventKey][namespace]) || state[eventKey]
+        : state[eventKey] && state[eventKey][namespace];
     }
-    return state[childType] &&
-      state[childType][eventKey] &&
-      state[childType][eventKey][namespace];
+    return state[childType] && state[childType][eventKey] && state[childType][eventKey][namespace];
   },
 
-/**
- * Returns a set of all mutations for shared events
- *
- * @param  {Array} mutations an array of mutations objects
- * @param  {Object} baseProps an object that describes all props for children of VictorySharedEvents
- * @param  {Object} baseState an object that describes state for children of VictorySharedEvents
- * @param  {Array} childNames an array of childNames
- *
- * @return {Object} a object describing all mutations for VictorySharedEvents
- */
+  /**
+   * Returns a set of all mutations for shared events
+   *
+   * @param  {Array} mutations an array of mutations objects
+   * @param  {Object} baseProps an object that describes all props for children of VictorySharedEvents
+   * @param  {Object} baseState an object that describes state for children of VictorySharedEvents
+   * @param  {Array} childNames an array of childNames
+   *
+   * @return {Object} a object describing all mutations for VictorySharedEvents
+   */
   // eslint-disable-next-line max-params
   getExternalMutationsWithChildren(mutations, baseProps, baseState, childNames) {
     baseProps = baseProps || {};
@@ -247,24 +258,26 @@ export default {
     return childNames.reduce((memo, childName) => {
       const childState = baseState[childName];
       const mutation = this.getExternalMutations(
-        mutations, baseProps[childName], baseState[childName], childName
+        mutations,
+        baseProps[childName],
+        baseState[childName],
+        childName
       );
       memo[childName] = mutation ? mutation : childState;
       return pickBy(memo, (v) => !isEmpty(v));
     }, {});
-
   },
 
-/**
- * Returns a set of all mutations for a component
- *
- * @param  {Array} mutations an array of mutations objects
- * @param  {Object} baseProps a props object (scoped to a childName when used by shared events)
- * @param  {Object} baseState a state object (scoped to a childName when used by shared events)
- * @param  {String} childName an optional childName
- *
- * @return {Object} a object describing mutations for a given component
- */
+  /**
+   * Returns a set of all mutations for a component
+   *
+   * @param  {Array} mutations an array of mutations objects
+   * @param  {Object} baseProps a props object (scoped to a childName when used by shared events)
+   * @param  {Object} baseState a state object (scoped to a childName when used by shared events)
+   * @param  {String} childName an optional childName
+   *
+   * @return {Object} a object describing mutations for a given component
+   */
   // eslint-disable-next-line max-params
   getExternalMutations(mutations, baseProps, baseState, childName) {
     baseProps = baseProps || {};
@@ -277,8 +290,7 @@ export default {
       if (eventKey === "parent") {
         const identifier = { eventKey, target: "parent" };
         const mutation = this.getExternalMutation(mutations, keyProps, keyState, identifier);
-        memo[eventKey] = mutation !== undefined ?
-          assign({}, keyState, mutation) : keyState;
+        memo[eventKey] = mutation !== undefined ? assign({}, keyState, mutation) : keyState;
       } else {
         // use keys from both state and props so that elements not intially included in baseProps
         // will be used. (i.e. labels)
@@ -286,10 +298,13 @@ export default {
         memo[eventKey] = targets.reduce((m, target) => {
           const identifier = { eventKey, target, childName };
           const mutation = this.getExternalMutation(
-            mutations, keyProps[target], keyState[target], identifier
+            mutations,
+            keyProps[target],
+            keyState[target],
+            identifier
           );
-          m[target] = mutation !== undefined ?
-            assign({}, keyState[target], mutation) : keyState[target];
+          m[target] =
+            mutation !== undefined ? assign({}, keyState[target], mutation) : keyState[target];
           return pickBy(m, (v) => !isEmpty(v));
         }, {});
       }
@@ -297,19 +312,18 @@ export default {
     }, {});
   },
 
-/**
- * Returns a set of mutations for a particular element given scoped baseProps and baseState
- *
- * @param  {Array} mutations an array of mutations objects
- * @param  {Object} baseProps a props object (scoped the element specified by the identifier)
- * @param  {Object} baseState a state object (scoped the element specified by the identifier)
- * @param  {Object} identifier { eventKey, target, childName }
- *
- * @return {Object | undefined} a object describing mutations for a given element, or undefined
- */
+  /**
+   * Returns a set of mutations for a particular element given scoped baseProps and baseState
+   *
+   * @param  {Array} mutations an array of mutations objects
+   * @param  {Object} baseProps a props object (scoped the element specified by the identifier)
+   * @param  {Object} baseState a state object (scoped the element specified by the identifier)
+   * @param  {Object} identifier { eventKey, target, childName }
+   *
+   * @return {Object | undefined} a object describing mutations for a given element, or undefined
+   */
   // eslint-disable-next-line max-params
   getExternalMutation(mutations, baseProps, baseState, identifier) {
-
     const filterMutations = (mutation, type) => {
       if (typeof mutation[type] === "string") {
         return mutation[type] === "all" || mutation[type] === identifier[type];
@@ -345,16 +359,19 @@ export default {
 
   /* Returns an array of defaultEvents from sub-components of a given component.
    * i.e. any static `defaultEvents` on `labelComponent` will be returned
-  */
+   */
   getComponentEvents(props, components) {
-    const events = Array.isArray(components) && components.reduce((memo, componentName) => {
-      const component = props[componentName];
-      const defaultEvents = component && component.type && component.type.defaultEvents;
-      const componentEvents = isFunction(defaultEvents) ?
-        defaultEvents(component.props) : defaultEvents;
-      memo = Array.isArray(componentEvents) ? memo.concat(...componentEvents) : memo;
-      return memo;
-    }, []);
+    const events =
+      Array.isArray(components) &&
+      components.reduce((memo, componentName) => {
+        const component = props[componentName];
+        const defaultEvents = component && component.type && component.type.defaultEvents;
+        const componentEvents = isFunction(defaultEvents)
+          ? defaultEvents(component.props)
+          : defaultEvents;
+        memo = Array.isArray(componentEvents) ? memo.concat(...componentEvents) : memo;
+        return memo;
+      }, []);
     return events && events.length ? events : undefined;
   }
 };

package/src/victory-util/helpers.js

@@ -97,9 +97,9 @@ function getStyles(style, defaultStyles) {
     return defaults({ parent: { height, width } }, defaultStyles);
   }
   const { data, labels, parent } = style;
-  const defaultParent = defaultStyles && defaultStyles.parent || {};
-  const defaultLabels = defaultStyles && defaultStyles.labels || {};
-  const defaultData = defaultStyles && defaultStyles.data || {};
+  const defaultParent = (defaultStyles && defaultStyles.parent) || {};
+  const defaultLabels = (defaultStyles && defaultStyles.labels) || {};
+  const defaultData = (defaultStyles && defaultStyles.data) || {};
   return {
     parent: defaults({}, parent, defaultParent, { width, height }),
     labels: defaults({}, labels, defaultLabels),
@@ -122,11 +122,11 @@ function evaluateStyle(style, data, active) {
 }
 
 function degreesToRadians(degrees) {
-  return degrees * (Math.PI / 180);
+  return typeof degrees === "number" ? degrees * (Math.PI / 180) : degrees;
 }
 
 function radiansToDegrees(radians) {
-  return radians / (Math.PI / 180);
+  return typeof radians === "number" ? radians / (Math.PI / 180) : radians;
 }
 
 function getRadius(props) {
@@ -190,11 +190,28 @@ function getCurrentAxis(axis, horizontal) {
  * @param {Array} children: an array of child components
  * @param {Function} iteratee: a function with arguments "child", "childName", and "parent"
  * @param {Object} parentProps: props from the parent that are applied to children
+ * @param {any}  initialMemo: The object in which the iteration results are combined.
+ * @param {Function} combine: Combines the result of the iteratee with the current memo
+ *   to the memo for the next iteration step
  * @returns {Array} returns an array of results from calling the iteratee on all nested children
  */
-function reduceChildren(children, iteratee, parentProps = {}) {
+/* eslint-disable max-params */
+function reduceChildren(
+  children,
+  iteratee,
+  parentProps = {},
+  initialMemo = [],
+  combine = (memo, item) => memo.concat(item)
+) {
   const sharedProps = [
-    "data", "domain", "categories", "polar", "startAngle", "endAngle", "minDomain", "maxDomain"
+    "data",
+    "domain",
+    "categories",
+    "polar",
+    "startAngle",
+    "endAngle",
+    "minDomain",
+    "maxDomain"
   ];
   const traverseChildren = (childArray, names, parent) => {
     return childArray.reduce((memo, child, index) => {
@@ -202,21 +219,24 @@ function reduceChildren(children, iteratee, parentProps = {}) {
       const childName = child.props.name || `${childRole}-${names[index]}`;
       if (child.props && child.props.children) {
         const childProps = assign({}, child.props, pick(parentProps, sharedProps));
-        const nestedChildren = child.type && isFunction(child.type.getChildren) ?
-          child.type.getChildren(childProps) :
-          React.Children.toArray(child.props.children).map((c) => {
-            const nestedChildProps = assign({}, c.props, pick(childProps, sharedProps));
-            return React.cloneElement(c, nestedChildProps);
-          });
+        const nestedChildren =
+          child.type && isFunction(child.type.getChildren)
+            ? child.type.getChildren(childProps)
+            : React.Children.toArray(child.props.children).map((c) => {
+                const nestedChildProps = assign({}, c.props, pick(childProps, sharedProps));
+                return React.cloneElement(c, nestedChildProps);
+              });
         const childNames = nestedChildren.map((c, i) => `${childName}-${i}`);
         const nestedResults = traverseChildren(nestedChildren, childNames, child);
-        memo = memo.concat(nestedResults);
+        memo = combine(memo, nestedResults);
       } else {
         const result = iteratee(child, childName, parent);
-        memo = result ? memo.concat(result) : memo;
+        if (result) {
+          memo = combine(memo, result);
+        }
       }
       return memo;
-    }, []);
+    }, initialMemo);
   };
   const childNames = children.map((c, i) => i);
   return traverseChildren(children, childNames);

package/src/victory-util/immutable.js

@@ -25,12 +25,17 @@ export default {
   },
 
   shallowToJS(x, whitelist) {
-    return this.isIterable(x) ? x.reduce((prev, curr, key) => {
-      if (whitelist && whitelist[key]) {
-        curr = this.shallowToJS(curr);
-      }
-      prev[key] = curr;
-      return prev;
-    }, this.isList(x) ? [] : {}) : x;
+    return this.isIterable(x)
+      ? x.reduce(
+          (prev, curr, key) => {
+            if (whitelist && whitelist[key]) {
+              curr = this.shallowToJS(curr);
+            }
+            prev[key] = curr;
+            return prev;
+          },
+          this.isList(x) ? [] : {}
+        )
+      : x;
   }
 };

package/src/victory-util/label-helpers.js

@@ -7,7 +7,7 @@ import Helpers from "./helpers";
 function getVerticalAnchor(props, datum) {
   datum = datum || {};
   const sign = datum._y >= 0 ? 1 : -1;
-  const labelStyle = props.style && props.style.labels || {};
+  const labelStyle = (props.style && props.style.labels) || {};
   if (datum.verticalAnchor || labelStyle.verticalAnchor) {
     return datum.verticalAnchor || labelStyle.verticalAnchor;
   } else if (!props.horizontal) {
@@ -21,7 +21,7 @@ function getTextAnchor(props, datum) {
   datum = datum || {};
   const { style, horizontal } = props;
   const sign = datum._y >= 0 ? 1 : -1;
-  const labelStyle = style && style.labels || {};
+  const labelStyle = (style && style.labels) || {};
   if (datum.verticalAnchor || labelStyle.verticalAnchor) {
     return datum.verticalAnchor || labelStyle.verticalAnchor;
   } else if (!horizontal) {
@@ -33,7 +33,7 @@ function getTextAnchor(props, datum) {
 
 function getAngle(props, datum) {
   datum = datum || {};
-  const labelStyle = props.style && props.style.labels || {};
+  const labelStyle = (props.style && props.style.labels) || {};
   return datum.angle === undefined ? labelStyle.angle : datum.angle;
 }
 
@@ -74,24 +74,28 @@ function getPolarPadding(props, datum) {
   const padding = Helpers.evaluateProp(labelStyle.padding, datum, active) || 0;
   const angle = Helpers.degreesToRadians(degrees);
   return {
-    x: padding * Math.cos(angle), y: -padding * Math.sin(angle)
+    x: padding * Math.cos(angle),
+    y: -padding * Math.sin(angle)
   };
 }
 
 function getLabelPlacement(props) {
   const { labelComponent, labelPlacement, polar } = props;
   const defaultLabelPlacement = polar ? "perpendicular" : "vertical";
-  return labelPlacement ?
-    labelPlacement :
-    labelComponent.props && labelComponent.props.labelPlacement || defaultLabelPlacement;
+  return labelPlacement
+    ? labelPlacement
+    : (labelComponent.props && labelComponent.props.labelPlacement) || defaultLabelPlacement;
 }
 
 function getPolarOrientation(degrees) {
-  if (degrees < 45 || degrees > 315) { // eslint-disable-line no-magic-numbers
+  // eslint-disable-next-line no-magic-numbers
+  if (degrees < 45 || degrees > 315) {
     return "right";
-  } else if (degrees >= 45 && degrees <= 135) { // eslint-disable-line no-magic-numbers
+    // eslint-disable-next-line no-magic-numbers
+  } else if (degrees >= 45 && degrees <= 135) {
     return "top";
-  } else if (degrees > 135 && degrees < 225) { // eslint-disable-line no-magic-numbers
+    // eslint-disable-next-line no-magic-numbers
+  } else if (degrees > 135 && degrees < 225) {
     return "left";
   } else {
     return "bottom";
@@ -112,7 +116,7 @@ function getPolarTextAnchor(props, degrees) {
   const labelPlacement = getLabelPlacement(props);
   if (
     labelPlacement === "perpendicular" ||
-    labelPlacement === "vertical" && (degrees === 90 || degrees === 270)
+    (labelPlacement === "vertical" && (degrees === 90 || degrees === 270))
   ) {
     return "middle";
   }
@@ -134,7 +138,7 @@ function getPolarAngle(props, baseAngle) {
     return 0;
   }
   const degrees = baseAngle !== undefined ? baseAngle : getDegrees(props, datum);
-  const sign = (degrees > 90 && degrees < 180 || degrees > 270) ? 1 : -1;
+  const sign = (degrees > 90 && degrees < 180) || degrees > 270 ? 1 : -1;
   let angle;
   if (degrees === 0 || degrees === 180) {
     angle = 90;
@@ -156,17 +160,29 @@ function getProps(props, index) {
   const { scale, data, style, horizontal, polar } = props;
   const datum = data[index];
   const degrees = getDegrees(props, datum);
-  const textAnchor = polar ?
-    getPolarTextAnchor(props, degrees) : getTextAnchor(props, datum);
-  const verticalAnchor = polar ?
-     getPolarVerticalAnchor(props, degrees) : getVerticalAnchor(props, datum);
+  const textAnchor = polar ? getPolarTextAnchor(props, degrees) : getTextAnchor(props, datum);
+  const verticalAnchor = polar
+    ? getPolarVerticalAnchor(props, degrees)
+    : getVerticalAnchor(props, datum);
   const angle = getAngle(props, datum);
   const text = getText(props, datum, index);
   const labelPlacement = getLabelPlacement(props);
   const { x, y } = getPosition(props, datum);
   return {
-    angle, data, datum, horizontal, index, polar, scale, labelPlacement,
-    text, textAnchor, verticalAnchor, x, y, style: style.labels
+    angle,
+    data,
+    datum,
+    horizontal,
+    index,
+    polar,
+    scale,
+    labelPlacement,
+    text,
+    textAnchor,
+    verticalAnchor,
+    x,
+    y,
+    style: style.labels
   };
 }