victory-chart 18.2.0 → 19.1.1

package/src/components/containers/victory-brush-container.js

@@ -1,3 +1,5 @@
+/*eslint no-magic-numbers: ["error", { "ignore": [0, 1, 2] }]*/
+import PropTypes from "prop-types";
 import React from "react";
 import { VictoryContainer, Selection } from "victory-core";
 import BrushHelpers from "./brush-helpers";
@@ -7,32 +9,32 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
   static displayName = "VictoryBrushContainer";
   static propTypes = {
     ...VictoryContainer.propTypes,
-    selectionStyle: React.PropTypes.object,
-    handleStyle: React.PropTypes.object,
-    dimension: React.PropTypes.oneOf(["x", "y"]),
-    selectedDomain: React.PropTypes.shape({
-      x: React.PropTypes.array,
-      y: React.PropTypes.array
+    dimension: PropTypes.oneOf(["x", "y"]),
+    handleComponent: PropTypes.element,
+    handleStyle: PropTypes.object,
+    handleWidth: PropTypes.number,
+    onDomainChange: PropTypes.func,
+    selectedDomain: PropTypes.shape({
+      x: PropTypes.array,
+      y: PropTypes.array
     }),
-    onDomainChange: React.PropTypes.func,
-    handleWidth: React.PropTypes.number,
-    selectionComponent: React.PropTypes.element,
-    handleComponent: React.PropTypes.element
+    selectionComponent: PropTypes.element,
+    selectionStyle: PropTypes.object
   };
   static defaultProps = {
     ...VictoryContainer.defaultProps,
-    selectionStyle: {
-      stroke: "transparent",
-      fill: "black",
-      fillOpacity: 0.1
-    },
+    handleComponent: <rect/>,
     handleStyle: {
       stroke: "transparent",
       fill: "transparent"
     },
     handleWidth: 8,
     selectionComponent: <rect/>,
-    handleComponent: <rect/>
+    selectionStyle: {
+      stroke: "transparent",
+      fill: "black",
+      fillOpacity: 0.1
+    }
   };
 
   static defaultEvents = [{
@@ -48,6 +50,8 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
           this.mouseMoveMutationId = mutations.id; // eslint-disable-line
           return mutations.mutations;
         }
+
+        return undefined;
       },
       onMouseUp: (evt, targetProps) => {
         return BrushHelpers.onMouseUp(evt, targetProps);
@@ -59,8 +63,8 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
   }];
 
   getSelectBox(props, coordinates) {
-    const {x, y} = coordinates;
-    const {selectionStyle, selectionComponent} = props;
+    const { x, y } = coordinates;
+    const { selectionStyle, selectionComponent } = props;
     const selectionComponentStyle = selectionComponent.props && selectionComponent.props.style;
     return x[0] !== x[1] && y[0] !== y[1] ?
       React.cloneElement(selectionComponent, {
@@ -74,25 +78,25 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
   }
 
   getHandles(props, coordinates) {
-    const {dimension, handleWidth, handleStyle, handleComponent} = props;
-    const {x, y} = coordinates;
+    const { dimension, handleWidth, handleStyle, handleComponent } = props;
+    const { x, y } = coordinates;
     const width = Math.abs(x[1] - x[0]) || 1;
     const height = Math.abs(y[1] - y[0]) || 1;
     const handleComponentStyle = handleComponent.props && handleComponent.props.style || {};
     const style = defaults({}, handleComponentStyle, handleStyle);
-    const yProps = { style, width, height: handleWidth, cursor: "ns-resize"};
-    const xProps = { style, width: handleWidth, height, cursor: "ew-resize"};
+    const yProps = { style, width, height: handleWidth, cursor: "ns-resize" };
+    const xProps = { style, width: handleWidth, height, cursor: "ew-resize" };
     const handleProps = {
-      top: dimension !== "x" && assign({x: x[0], y: y[1] - (handleWidth / 2)}, yProps),
-      bottom: dimension !== "x" && assign({x: x[0], y: y[0] - (handleWidth / 2)}, yProps),
-      left: dimension !== "y" && assign({y: y[1], x: x[0] - (handleWidth / 2)}, xProps),
-      right: dimension !== "y" && assign({y: y[1], x: x[1] - (handleWidth / 2)}, xProps)
+      top: dimension !== "x" && assign({ x: x[0], y: y[1] - (handleWidth / 2) }, yProps),
+      bottom: dimension !== "x" && assign({ x: x[0], y: y[0] - (handleWidth / 2) }, yProps),
+      left: dimension !== "y" && assign({ y: y[1], x: x[0] - (handleWidth / 2) }, xProps),
+      right: dimension !== "y" && assign({ y: y[1], x: x[1] - (handleWidth / 2) }, xProps)
     };
     const handles = ["top", "bottom", "left", "right"].reduce((memo, curr) => {
       memo = handleProps[curr] ?
         memo.concat(React.cloneElement(
           handleComponent,
-          assign({key: `handle-${curr}`}, handleProps[curr]
+          assign({ key: `handle-${curr}` }, handleProps[curr]
         ))) : memo;
       return memo;
     }, []);
@@ -100,7 +104,7 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
   }
 
   getRect(props) {
-    const {currentDomain, cachedSelectedDomain, scale} = props;
+    const { currentDomain, cachedSelectedDomain, scale } = props;
     const selectedDomain = defaults({}, props.selectedDomain, props.domain);
     const domain = isEqual(selectedDomain, cachedSelectedDomain) ?
       defaults({}, currentDomain, selectedDomain) : selectedDomain;
@@ -119,7 +123,7 @@ export const brushContainerMixin = (base) => class VictoryBrushContainer extends
   getChildren(props) {
     const children = React.Children.toArray(props.children);
     return [...children, this.getRect(props)].map((component, i) => {
-      return component ? React.cloneElement(component, {key: i}) : null;
+      return component ? React.cloneElement(component, { key: i }) : null;
     });
   }
 };

package/src/components/containers/victory-cursor-container.js

@@ -0,0 +1,145 @@
+/*eslint no-magic-numbers: ["error", { "ignore": [0, 1, 2] }]*/
+import PropTypes from "prop-types";
+import React from "react";
+import { VictoryContainer, VictoryLabel, Line, Selection, Helpers } from "victory-core";
+import { isNumber } from "lodash";
+import CursorHelpers from "./cursor-helpers";
+
+export const cursorContainerMixin = (base) => class VictoryCursorContainer extends base {
+  static displayName = "VictoryCursorContainer";
+  static propTypes = {
+    ...VictoryContainer.propTypes,
+    cursorLabel: PropTypes.func,
+    cursorLabelComponent: PropTypes.element,
+    cursorLabelOffset: PropTypes.oneOfType([
+      PropTypes.number,
+      PropTypes.shape({
+        x: PropTypes.number,
+        y: PropTypes.number
+      })
+    ]),
+    defaultCursorValue: PropTypes.oneOfType([
+      PropTypes.number,
+      PropTypes.shape({
+        x: PropTypes.number,
+        y: PropTypes.number
+      })
+    ]),
+    dimension: PropTypes.oneOf(["x", "y"]),
+    onChange: PropTypes.func,
+    standalone: PropTypes.bool
+  };
+  static defaultProps = {
+    ...VictoryContainer.defaultProps,
+    cursorLabelComponent: <VictoryLabel/>,
+    cursorLabelOffset: {
+      x: 5,
+      y: -10
+    },
+    cursorComponent: <Line/>
+  };
+
+  static defaultEvents = [{
+    target: "parent",
+    eventHandlers: {
+      onMouseLeave: () => {
+        return [];
+      },
+      onMouseMove: (evt, targetProps) => {
+        const mutations = CursorHelpers.onMouseMove(evt, targetProps);
+
+        if (mutations.id !== this.mouseMoveMutationId) { // eslint-disable-line
+          this.mouseMoveMutationId = mutations.id; // eslint-disable-line
+          return mutations.mutations;
+        }
+
+        return [];
+      }
+    }
+  }];
+
+  getCursorPosition(props) {
+    const { cursorValue, defaultCursorValue, dimension, domain } = props;
+    if (cursorValue) { return cursorValue; }
+
+    if (isNumber(defaultCursorValue)) {
+      return {
+        x: (domain.x[0] + domain.x[1]) / 2,
+        y: (domain.y[0] + domain.y[1]) / 2,
+        [dimension]: defaultCursorValue
+      };
+    }
+
+    return defaultCursorValue;
+  }
+
+  getCursorLabelOffset(props) {
+    const { cursorLabelOffset } = props;
+
+    if (isNumber(cursorLabelOffset)) {
+      return {
+        x: cursorLabelOffset,
+        y: cursorLabelOffset
+      };
+    }
+
+    return cursorLabelOffset;
+  }
+
+  getCursorElements(props) {
+    const {
+      scale, domain, dimension, cursorLabelComponent, cursorLabel, cursorComponent
+    } = props;
+    const cursorValue = this.getCursorPosition(props);
+    const cursorLabelOffset = this.getCursorLabelOffset(props);
+
+    if (!cursorValue) { return []; }
+
+    const newElements = [];
+    const domainCoordinates = Selection.getDomainCoordinates(scale, domain);
+
+    const cursorCoordinates = {
+      x: scale.x(cursorValue.x),
+      y: scale.y(cursorValue.y)
+    };
+    if (cursorLabel) {
+      newElements.push(React.cloneElement(cursorLabelComponent, {
+        x: cursorCoordinates.x + cursorLabelOffset.x,
+        y: cursorCoordinates.y + cursorLabelOffset.y,
+        text: Helpers.evaluateProp(cursorLabel, cursorValue, true),
+        active: true,
+        key: "cursor-label"
+      }));
+    }
+
+    if (dimension === "x" || dimension === undefined) {
+      newElements.push(React.cloneElement(cursorComponent, {
+        key: "x-cursor",
+        x1: cursorCoordinates.x,
+        x2: cursorCoordinates.x,
+        y1: domainCoordinates.y[0],
+        y2: domainCoordinates.y[1]
+      }));
+    }
+    if (dimension === "y" || dimension === undefined) {
+      newElements.push(React.cloneElement(cursorComponent, {
+        key: "y-cursor",
+        x1: domainCoordinates.x[0],
+        x2: domainCoordinates.x[1],
+        y1: cursorCoordinates.y,
+        y2: cursorCoordinates.y
+      }));
+    }
+    return newElements;
+  }
+
+  // Overrides method in VictoryContainer
+  getChildren(props) {
+    return [
+      ...React.Children.toArray(props.children),
+      ...this.getCursorElements(props)
+    ];
+  }
+};
+
+export default cursorContainerMixin(VictoryContainer);

package/src/components/containers/victory-selection-container.js

@@ -1,3 +1,4 @@
+import PropTypes from "prop-types";
 import React from "react";
 import { VictoryContainer } from "victory-core";
 import SelectionHelpers from "./selection-helpers";
@@ -6,21 +7,21 @@ export const selectionContainerMixin = (base) => class VictorySelectionContainer
   static displayName = "VictorySelectionContainer";
   static propTypes = {
     ...VictoryContainer.propTypes,
-    selectionStyle: React.PropTypes.object,
-    onSelection: React.PropTypes.func,
-    onSelectionCleared: React.PropTypes.func,
-    dimension: React.PropTypes.oneOf(["x", "y"]),
-    standalone: React.PropTypes.bool,
-    selectionComponent: React.PropTypes.element
+    dimension: PropTypes.oneOf(["x", "y"]),
+    onSelection: PropTypes.func,
+    onSelectionCleared: PropTypes.func,
+    selectionComponent: PropTypes.element,
+    selectionStyle: PropTypes.object,
+    standalone: PropTypes.bool
   };
   static defaultProps = {
     ...VictoryContainer.defaultProps,
+    selectionComponent: <rect/>,
     selectionStyle: {
       stroke: "transparent",
       fill: "black",
       fillOpacity: 0.1
-    },
-    selectionComponent: <rect/>
+    }
   };
 
   static defaultEvents = [{
@@ -36,6 +37,8 @@ export const selectionContainerMixin = (base) => class VictorySelectionContainer
           this.mouseMoveMutationId = mutations.id; // eslint-disable-line
           return mutations.mutations;
         }
+
+        return undefined;
       },
       onMouseUp: (evt, targetProps) => {
         return SelectionHelpers.onMouseUp(evt, targetProps);
@@ -44,20 +47,20 @@ export const selectionContainerMixin = (base) => class VictorySelectionContainer
   }];
 
   getRect(props) {
-    const {x1, x2, y1, y2, selectionStyle, selectionComponent} = props;
+    const { x1, x2, y1, y2, selectionStyle, selectionComponent } = props;
     const width = Math.abs(x2 - x1) || 1;
     const height = Math.abs(y2 - y1) || 1;
     const x = Math.min(x1, x2);
     const y = Math.min(y1, y2);
     return y2 && x2 && x1 && y1 ?
-      React.cloneElement(selectionComponent, {x, y, width, height, style: selectionStyle}) : null;
+      React.cloneElement(selectionComponent, { x, y, width, height, style: selectionStyle }) : null;
   }
 
   // Overrides method in VictoryContainer
   getChildren(props) {
     const children = React.Children.toArray(props.children);
     return [...children, this.getRect(props)].map((component, i) => {
-      return component ? React.cloneElement(component, {key: i}) : null;
+      return component ? React.cloneElement(component, { key: i }) : null;
     });
   }
 };

package/src/components/containers/victory-voronoi-container.js

@@ -1,3 +1,5 @@
+/*eslint no-magic-numbers: ["error", { "ignore": [-1, 0, 1, 2] }]*/
+import PropTypes from "prop-types";
 import React from "react";
 import { VictoryContainer, VictoryTooltip, Helpers, TextSize } from "victory-core";
 import VoronoiHelpers from "./voronoi-helpers";
@@ -7,14 +9,14 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
   static displayName = "VictoryVoronoiContainer";
   static propTypes = {
     ...VictoryContainer.propTypes,
-    onActivated: React.PropTypes.func,
-    onDeactivated: React.PropTypes.func,
-    standalone: React.PropTypes.bool,
-    radius: React.PropTypes.number,
-    voronoiPadding: React.PropTypes.number,
-    labelComponent: React.PropTypes.element,
-    labels: React.PropTypes.func,
-    dimension: React.PropTypes.oneOf(["x", "y"])
+    dimension: PropTypes.oneOf(["x", "y"]),
+    labelComponent: PropTypes.element,
+    labels: PropTypes.func,
+    onActivated: PropTypes.func,
+    onDeactivated: PropTypes.func,
+    radius: PropTypes.number,
+    standalone: PropTypes.bool,
+    voronoiPadding: PropTypes.number
   };
   static defaultProps = {
     ...VictoryContainer.defaultProps,
@@ -35,6 +37,8 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
           this.mouseMoveMutationId = mutations.id; // eslint-disable-line
           return mutations.mutations;
         }
+
+        return undefined;
       }
     }
   }, {
@@ -63,19 +67,41 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
     };
   }
 
-  getFlyoutExtent(position, flyoutSize) {
-    const {x, y} = position;
-    const width = flyoutSize.x / 2;
-    const height = flyoutSize.y;
-    const extent = {x: [x - width, x + width], y: [y - height, y]};
+  getLabelCornerRadius(props, labelProps) {
+    if (typeof labelProps.cornerRadius !== "undefined") {
+      return labelProps.cornerRadius;
+    }
+    const theme = props.theme || labelProps.theme;
+    return theme.tooltip && theme.tooltip.cornerRadius || 0;
+  }
+
+  getFlyoutExtent(position, props, labelProps) {
+    const { text, style } = labelProps;
+    const { orientation, dx = 0, dy = 0 } = labelProps;
+    const flyoutSize = this.getFlyoutSize(props.labelComponent, text, style);
+    const cornerRadius = this.getLabelCornerRadius(props, labelProps);
+    const x = position.x + dx + 2 * cornerRadius;
+    const y = position.y + dy + 2 * cornerRadius;
+    const width = orientation === "top" || orientation === "bottom" ?
+      flyoutSize.x / 2 :
+      flyoutSize.x;
+    const horizontalSign = orientation === "left" ? -1 : 1;
+    const verticalSign = orientation === "bottom" ? 1 : -1;
+    const extent = {};
+    if (orientation === "top" || orientation === "bottom") {
+      extent.x = [x - width, x + width];
+    } else {
+      extent.x = [x, x + horizontalSign * width];
+    }
+    extent.y = [y, y + verticalSign * flyoutSize.y];
     return {
       x: [Math.min(...extent.x), Math.max(...extent.x)],
       y: [Math.min(...extent.y), Math.max(...extent.y)]
     };
   }
 
-  getLabelPosition(props, points, text, style) { // eslint-disable-line max-params
-    const { mousePosition, dimension, scale, labelComponent, voronoiPadding } = props;
+  getLabelPosition(props, points, labelProps) {
+    const { mousePosition, dimension, scale, voronoiPadding } = props;
     const dataX = points[0]._x1 !== undefined ? points[0]._x1 : points[0]._x;
     const dataY = points[0]._y1 !== undefined ? points[0]._y1 : points[0]._y;
     const basePosition = {
@@ -88,13 +114,12 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
 
     const x = dimension === "y" ? mousePosition.x : basePosition.x;
     const y = dimension === "x" ? mousePosition.y : basePosition.y;
-    const flyoutSize = this.getFlyoutSize(labelComponent, text, style);
     const range = { x: scale.x.range(), y: scale.y.range() };
     const extent = {
       x: [Math.min(...range.x) + voronoiPadding, Math.max(...range.x) - voronoiPadding],
       y: [Math.min(...range.y) + voronoiPadding, Math.max(...range.y) - voronoiPadding]
     };
-    const flyoutExtent = this.getFlyoutExtent({x, y}, flyoutSize);
+    const flyoutExtent = this.getFlyoutExtent({ x, y }, props, labelProps);
     const adjustments = {
       x: [
         flyoutExtent.x[0] < extent.x[0] ? extent.x[0] - flyoutExtent.x[0] : 0,
@@ -129,7 +154,7 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
   }
 
   getDefaultLabelProps(props, points) {
-    const {dimension} = props;
+    const { dimension } = props;
     const multiPoint = dimension && points.length > 1;
     return {
       orientation: multiPoint ? "top" : undefined,
@@ -138,7 +163,7 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
   }
 
   getLabelProps(props, points) {
-    const {labels, scale, labelComponent, theme} = props;
+    const { labels, scale, labelComponent, theme } = props;
     const text = points.reduce((memo, point) => {
       const t = Helpers.evaluateProp(labels, point, true);
       if (t === null || t === undefined) {
@@ -148,23 +173,23 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
       return memo;
     }, []);
     const style = this.getStyle(props, points, "labels");
-    const labelPosition = this.getLabelPosition(props, points, text, style);
-    return defaults(
+    const labelProps = defaults(
       {
         theme, style, text, scale,
         active: true,
         renderInPortal: false,
         flyoutStyle: this.getStyle(props, points, "flyout")[0],
-        datum: omit(points[0], ["childName", "style", "continuous"]),
-        ...labelPosition
+        datum: omit(points[0], ["childName", "style", "continuous"])
       },
       labelComponent.props,
       this.getDefaultLabelProps(props, points)
     );
+    const labelPosition = this.getLabelPosition(props, points, labelProps);
+    return { ...labelProps, ...labelPosition };
   }
 
   getTooltip(props) {
-    const {labels, activePoints, labelComponent} = props;
+    const { labels, activePoints, labelComponent } = props;
     if (!labels) {
       return null;
     }
@@ -179,7 +204,7 @@ export const voronoiContainerMixin = (base) => class VictoryVoronoiContainer ext
   getChildren(props) {
     const children = React.Children.toArray(props.children);
     return [...children, this.getTooltip(props)].map((component, i) => {
-      return component ? React.cloneElement(component, {key: i}) : null;
+      return component ? React.cloneElement(component, { key: i }) : null;
     });
   }
 };

package/src/components/containers/victory-zoom-container.js

@@ -1,25 +1,28 @@
-import React, {PropTypes} from "react";
+import PropTypes from "prop-types";
+import React from "react";
 import { defaults, isEqual } from "lodash";
 import ZoomHelpers from "./zoom-helpers";
 import { VictoryContainer, VictoryClipContainer, PropTypes as CustomPropTypes } from "victory-core";
 
 export const zoomContainerMixin = (base) => class VictoryZoomContainer extends base {
   static displayName = "VictoryZoomContainer";
+
   static propTypes = {
     ...VictoryContainer.propTypes,
-    zoomDomain: PropTypes.shape({
-      x: CustomPropTypes.domain,
-      y: CustomPropTypes.domain
-    }),
+    allowZoom: PropTypes.bool,
+    clipContainerComponent: PropTypes.element.isRequired,
+    dimension: PropTypes.oneOf(["x", "y"]),
     minimumZoom: PropTypes.shape({
       x: PropTypes.number,
       y: PropTypes.number
     }),
     onDomainChange: PropTypes.func,
-    clipContainerComponent: PropTypes.element.isRequired,
-    allowZoom: PropTypes.bool,
-    dimension: PropTypes.oneOf(["x", "y"])
+    zoomDomain: PropTypes.shape({
+      x: CustomPropTypes.domain,
+      y: CustomPropTypes.domain
+    })
   };
+
   static defaultProps = {
     ...VictoryContainer.defaultProps,
     clipContainerComponent: <VictoryClipContainer/>,
@@ -46,6 +49,8 @@ export const zoomContainerMixin = (base) => class VictoryZoomContainer extends b
           this.mouseMoveMutationId = mutations.id; // eslint-disable-line
           return mutations.mutations;
         }
+
+        return undefined;
       },
       onWheel: (evt, targetProps, eventKey, ctx) => { // eslint-disable-line max-params
         evt.preventDefault();
@@ -55,6 +60,8 @@ export const zoomContainerMixin = (base) => class VictoryZoomContainer extends b
           this.wheelMutationId = mutations.id; // eslint-disable-line
           return mutations.mutations;
         }
+
+        return undefined;
       }
     }
   }];
@@ -110,14 +117,14 @@ export const zoomContainerMixin = (base) => class VictoryZoomContainer extends b
     const childComponents = React.Children.toArray(props.children);
 
     return childComponents.map((child) => {
-      const {currentDomain} = props;
+      const { currentDomain } = props;
       const originalDomain = defaults({}, props.original, props.domain);
       const zoomDomain = defaults({}, props.zoomDomain, props.domain);
       const cachedZoomDomain = defaults({}, props.cachedZoomDomain, props.domain);
       const domain = isEqual(zoomDomain, cachedZoomDomain) ?
         defaults({}, currentDomain, originalDomain) : zoomDomain;
       return React.cloneElement(
-        child, defaults({domain}, child.props)
+        child, defaults({ domain }, child.props)
       );
     });
   }

package/src/components/containers/voronoi-helpers.js

@@ -6,9 +6,9 @@ import { attachId } from "../../helpers/event-handlers.js";
 
 const VoronoiHelpers = {
   withinBounds(props, point) {
-    const {width, height, voronoiPadding} = props;
+    const { width, height, voronoiPadding } = props;
     const padding = voronoiPadding || 0;
-    const {x, y} = point;
+    const { x, y } = point;
     return x >= padding && x <= width - padding && y >= padding && y <= height - padding;
   },
 
@@ -54,7 +54,7 @@ const VoronoiHelpers = {
   // returns an array of objects with point and data where point is an x, y coordinate, and data is
   // an array of points belonging to that coordinate
   mergeDatasets(props, datasets) {
-    const {scale} = props;
+    const { scale } = props;
     const points = groupBy(datasets, (datum) => {
       const x = scale.x(datum ._voronoiX);
       const y = scale.y(datum ._voronoiY);
@@ -71,7 +71,7 @@ const VoronoiHelpers = {
   },
 
   getVoronoi(props, mousePosition) {
-    const {width, height, voronoiPadding} = props;
+    const { width, height, voronoiPadding } = props;
     const padding = voronoiPadding || 0;
     const voronoiFunction = d3Voronoi()
       .x((d) => d.x)
@@ -84,18 +84,18 @@ const VoronoiHelpers = {
   },
 
   getActiveMutations(props, point) {
-    const {childName, continuous} = point;
+    const { childName, continuous } = point;
     const targets = props.labels ? ["data"] : ["data", "labels"];
     return targets.map((target) => {
       const eventKey = continuous === true && target === "data" ? "all" : point.eventKey;
       return {
-        childName, eventKey, target, mutation: () => ({active: true })
+        childName, eventKey, target, mutation: () => ({ active: true })
       };
     });
   },
 
   getInactiveMutations(props, point) {
-    const {childName, continuous} = point;
+    const { childName, continuous } = point;
     const targets = props.labels ? ["data"] : ["data", "labels"];
     return targets.map((target) => {
       const eventKey = continuous && target === "data" ? "all" : point.eventKey;
@@ -163,6 +163,6 @@ export default {
   onMouseLeave: VoronoiHelpers.onMouseLeave.bind(VoronoiHelpers),
   onMouseMove: throttle(
     attachId(VoronoiHelpers.onMouseMove.bind(VoronoiHelpers)),
-    32,
-    {leading: true, trailing: false})
+    32, // eslint-disable-line no-magic-numbers
+    { leading: true, trailing: false })
 };