victory-cursor-container 30.6.1 → 31.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-cursor-container",
-  "version": "30.6.1",
+  "version": "31.2.0",
   "description": "Interactive Cursor Component for Victory",
   "keywords": [
     "data visualization",
@@ -21,7 +21,7 @@
   "dependencies": {
     "lodash": "^4.17.5",
     "prop-types": "^15.5.8",
-    "victory-core": "^30.6.1"
+    "victory-core": "^31.2.0"
   },
   "scripts": {
     "version": "nps build-libs && nps build-dists"

package/src/cursor-helpers.js

@@ -5,10 +5,12 @@ const CursorHelpers = {
   withinBounds(point, bounds) {
     const { x1, x2, y1, y2 } = mapValues(bounds, Number);
     const { x, y } = mapValues(point, Number);
-    return x >= Math.min(x1, x2) &&
+    return (
+      x >= Math.min(x1, x2) &&
       x <= Math.max(x1, x2) &&
       y >= Math.min(y1, y2) &&
-      y <= Math.max(y1, y2);
+      y <= Math.max(y1, y2)
+    );
   },
 
   onMouseMove(evt, targetProps) {
@@ -42,11 +44,13 @@ const CursorHelpers = {
       }
     }
 
-    return [{
-      target: "parent",
-      eventKey: "parent",
-      mutation: () => ({ cursorValue, parentSVG })
-    }];
+    return [
+      {
+        target: "parent",
+        eventKey: "parent",
+        mutation: () => ({ cursorValue, parentSVG })
+      }
+    ];
   },
 
   onTouchEnd(evt, targetProps) {
@@ -56,11 +60,13 @@ const CursorHelpers = {
       onCursorChange(null, targetProps);
     }
 
-    return [{
-      target: "parent",
-      eventKey: "parent",
-      mutation: () => ({ cursorValue: null })
-    }];
+    return [
+      {
+        target: "parent",
+        eventKey: "parent",
+        mutation: () => ({ cursorValue: null })
+      }
+    ];
   }
 };
 
@@ -68,6 +74,7 @@ export default {
   onMouseMove: throttle(
     CursorHelpers.onMouseMove.bind(CursorHelpers),
     32, // eslint-disable-line no-magic-numbers
-    { leading: true, trailing: false }),
+    { leading: true, trailing: false }
+  ),
   onTouchEnd: CursorHelpers.onTouchEnd.bind(CursorHelpers)
 };

package/src/victory-cursor-container.js

@@ -4,160 +4,176 @@ import { VictoryContainer, VictoryLabel, LineSegment, Helpers } from "victory-co
 import { defaults, assign, isObject } from "lodash";
 import CursorHelpers from "./cursor-helpers";
 
-export const cursorContainerMixin = (base) => class VictoryCursorContainer extends base {
-  static displayName = "VictoryCursorContainer";
-  static propTypes = {
-    ...VictoryContainer.propTypes,
-    cursorDimension: PropTypes.oneOf(["x", "y"]),
-    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
-      })
-    ]),
-    disable: PropTypes.bool,
-    onCursorChange: PropTypes.func
-  };
-  static defaultProps = {
-    ...VictoryContainer.defaultProps,
-    cursorLabelComponent: <VictoryLabel/>,
-    cursorLabelOffset: {
-      x: 5,
-      y: -10
-    },
-    cursorComponent: <LineSegment/>
-  };
+export const cursorContainerMixin = (base) =>
+  class VictoryCursorContainer extends base {
+    static displayName = "VictoryCursorContainer";
+    static propTypes = {
+      ...VictoryContainer.propTypes,
+      cursorDimension: PropTypes.oneOf(["x", "y"]),
+      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
+        })
+      ]),
+      disable: PropTypes.bool,
+      onCursorChange: PropTypes.func
+    };
+    static defaultProps = {
+      ...VictoryContainer.defaultProps,
+      cursorLabelComponent: <VictoryLabel />,
+      cursorLabelOffset: {
+        x: 5,
+        y: -10
+      },
+      cursorComponent: <LineSegment />
+    };
 
-  static defaultEvents = (props) => {
-    return [{
-      target: "parent",
-      eventHandlers: {
-        onMouseLeave: () => {
-          return [];
-        },
-        onTouchCancel: () => {
-          return [];
-        },
-        onMouseMove: (evt, targetProps) => {
-          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
-        },
-        onTouchMove: (evt, targetProps) => {
-          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+    static defaultEvents = (props) => {
+      return [
+        {
+          target: "parent",
+          eventHandlers: {
+            onMouseLeave: () => {
+              return [];
+            },
+            onTouchCancel: () => {
+              return [];
+            },
+            onMouseMove: (evt, targetProps) => {
+              return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+            },
+            onTouchMove: (evt, targetProps) => {
+              return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+            }
+          }
         }
+      ];
+    };
+
+    getCursorPosition(props) {
+      const { cursorValue, defaultCursorValue, cursorDimension, domain } = props;
+      if (cursorValue) {
+        return cursorValue;
       }
-    }];
-  };
 
-  getCursorPosition(props) {
-    const { cursorValue, defaultCursorValue, cursorDimension, domain } = props;
-    if (cursorValue) { return cursorValue; }
+      if (typeof defaultCursorValue === "number") {
+        return {
+          x: (domain.x[0] + domain.x[1]) / 2,
+          y: (domain.y[0] + domain.y[1]) / 2,
+          [cursorDimension]: defaultCursorValue
+        };
+      }
 
-    if (typeof defaultCursorValue === "number") {
-      return {
-        x: (domain.x[0] + domain.x[1]) / 2,
-        y: (domain.y[0] + domain.y[1]) / 2,
-        [cursorDimension]: defaultCursorValue
-      };
+      return defaultCursorValue;
     }
 
-    return defaultCursorValue;
-  }
+    getCursorLabelOffset(props) {
+      const { cursorLabelOffset } = props;
 
-  getCursorLabelOffset(props) {
-    const { cursorLabelOffset } = props;
+      if (typeof cursorLabelOffset === "number") {
+        return {
+          x: cursorLabelOffset,
+          y: cursorLabelOffset
+        };
+      }
 
-    if (typeof cursorLabelOffset === "number") {
-      return {
-        x: cursorLabelOffset,
-        y: cursorLabelOffset
-      };
+      return cursorLabelOffset;
     }
 
-    return cursorLabelOffset;
-  }
-
-  getPadding(props) {
-    if (props.padding === undefined) {
-      const child = props.children.find((c) => {
-        return isObject(c.props) && c.props.padding !== undefined;
-      });
-      return Helpers.getPadding(child.props);
-    } else {
-      return Helpers.getPadding(props);
+    getPadding(props) {
+      if (props.padding === undefined) {
+        const child = props.children.find((c) => {
+          return isObject(c.props) && c.props.padding !== undefined;
+        });
+        return Helpers.getPadding(child.props);
+      } else {
+        return Helpers.getPadding(props);
+      }
     }
-  }
 
-  getCursorElements(props) { // eslint-disable-line max-statements
-    const {
-      scale, cursorDimension, cursorLabelComponent, cursorLabel,
-      cursorComponent, width, height, name
-    } = props;
-    const cursorValue = this.getCursorPosition(props);
-    const cursorLabelOffset = this.getCursorLabelOffset(props);
+    getCursorElements(props) {
+      // eslint-disable-line max-statements
+      const {
+        scale,
+        cursorDimension,
+        cursorLabelComponent,
+        cursorLabel,
+        cursorComponent,
+        width,
+        height,
+        name
+      } = props;
+      const cursorValue = this.getCursorPosition(props);
+      const cursorLabelOffset = this.getCursorLabelOffset(props);
 
-    if (!cursorValue) { return []; }
+      if (!cursorValue) {
+        return [];
+      }
 
-    const newElements = [];
-    const padding = this.getPadding(props);
-    const cursorCoordinates = {
-      x: scale.x(cursorValue.x),
-      y: scale.y(cursorValue.y)
-    };
-    if (cursorLabel) {
-      newElements.push(React.cloneElement(
-        cursorLabelComponent,
-        defaults(
-          { active: true },
-          cursorLabelComponent.props,
-          {
-            x: cursorCoordinates.x + cursorLabelOffset.x,
-            y: cursorCoordinates.y + cursorLabelOffset.y,
-            text: Helpers.evaluateProp(cursorLabel, cursorValue, true),
-            active: true,
-            key: `${name}-cursor-label`
-          }
-        )
-      ));
-    }
+      const newElements = [];
+      const padding = this.getPadding(props);
+      const cursorCoordinates = {
+        x: scale.x(cursorValue.x),
+        y: scale.y(cursorValue.y)
+      };
+      if (cursorLabel) {
+        newElements.push(
+          React.cloneElement(
+            cursorLabelComponent,
+            defaults({ active: true }, cursorLabelComponent.props, {
+              x: cursorCoordinates.x + cursorLabelOffset.x,
+              y: cursorCoordinates.y + cursorLabelOffset.y,
+              text: Helpers.evaluateProp(cursorLabel, cursorValue, true),
+              active: true,
+              key: `${name}-cursor-label`
+            })
+          )
+        );
+      }
 
-    const cursorStyle = assign({ stroke: "black" }, cursorComponent.props.style);
-    if (cursorDimension === "x" || cursorDimension === undefined) {
-      newElements.push(React.cloneElement(cursorComponent, {
-        key: `${name}-x-cursor`,
-        x1: cursorCoordinates.x,
-        x2: cursorCoordinates.x,
-        y1: padding.top,
-        y2: (height - padding.bottom),
-        style: cursorStyle
-      }));
-    }
-    if (cursorDimension === "y" || cursorDimension === undefined) {
-      newElements.push(React.cloneElement(cursorComponent, {
-        key: `${name}-y-cursor`,
-        x1: padding.left,
-        x2: (width - padding.right),
-        y1: cursorCoordinates.y,
-        y2: cursorCoordinates.y,
-        style: cursorStyle
-      }));
+      const cursorStyle = assign({ stroke: "black" }, cursorComponent.props.style);
+      if (cursorDimension === "x" || cursorDimension === undefined) {
+        newElements.push(
+          React.cloneElement(cursorComponent, {
+            key: `${name}-x-cursor`,
+            x1: cursorCoordinates.x,
+            x2: cursorCoordinates.x,
+            y1: padding.top,
+            y2: height - padding.bottom,
+            style: cursorStyle
+          })
+        );
+      }
+      if (cursorDimension === "y" || cursorDimension === undefined) {
+        newElements.push(
+          React.cloneElement(cursorComponent, {
+            key: `${name}-y-cursor`,
+            x1: padding.left,
+            x2: width - padding.right,
+            y1: cursorCoordinates.y,
+            y2: cursorCoordinates.y,
+            style: cursorStyle
+          })
+        );
+      }
+      return newElements;
     }
-    return newElements;
-  }
 
-  // Overrides method in VictoryContainer
-  getChildren(props) {
-    return [...React.Children.toArray(props.children), ...this.getCursorElements(props)];
-  }
-};
+    // Overrides method in VictoryContainer
+    getChildren(props) {
+      return [...React.Children.toArray(props.children), ...this.getCursorElements(props)];
+    }
+  };
 
 export default cursorContainerMixin(VictoryContainer);