victory-cursor-container 36.9.2 → 37.0.0

package/es/victory-cursor-container.js

@@ -1,220 +1,153 @@
 import _isObject from "lodash/isObject";
 import _defaults from "lodash/defaults";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-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 _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-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); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
 import React from "react";
 import { VictoryContainer, Helpers, VictoryLabel, LineSegment } from "victory-core";
 import { CursorHelpers } from "./cursor-helpers";
 export function cursorContainerMixin(Base) {
-  var _class;
-
   // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
-  return _class = /*#__PURE__*/function (_Base) {
-    _inherits(VictoryCursorContainer, _Base);
-
-    var _super = _createSuper(VictoryCursorContainer);
-
-    function VictoryCursorContainer() {
-      _classCallCheck(this, VictoryCursorContainer);
-
-      return _super.apply(this, arguments);
-    }
-
-    _createClass(VictoryCursorContainer, [{
-      key: "getCursorPosition",
-      value: function getCursorPosition(props) {
-        var cursorValue = props.cursorValue,
-            defaultCursorValue = props.defaultCursorValue,
-            domain = props.domain,
-            cursorDimension = props.cursorDimension;
-
-        if (cursorValue) {
-          return cursorValue;
-        }
-
-        if (typeof defaultCursorValue === "number") {
-          return _defineProperty({
-            x: (domain.x[0] + domain.x[1]) / 2,
-            y: (domain.y[0] + domain.y[1]) / 2
-          }, cursorDimension, defaultCursorValue);
-        }
-
-        return defaultCursorValue;
-      }
-    }, {
-      key: "getCursorLabelOffset",
-      value: function getCursorLabelOffset(props) {
-        var cursorLabelOffset = props.cursorLabelOffset;
-
-        if (typeof cursorLabelOffset === "number") {
-          return {
-            x: cursorLabelOffset,
-            y: cursorLabelOffset
-          };
+  return class VictoryCursorContainer extends Base {
+    static displayName = "VictoryCursorContainer";
+    static defaultProps = {
+      ...VictoryContainer.defaultProps,
+      cursorLabelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
+      cursorLabelOffset: {
+        x: 5,
+        y: -10
+      },
+      cursorComponent: /*#__PURE__*/React.createElement(LineSegment, null)
+    };
+    static defaultEvents = props => {
+      return [{
+        target: "parent",
+        eventHandlers: {
+          onMouseLeave: (evt, targetProps) => {
+            return props.disable ? {} : CursorHelpers.onMouseLeave(evt, targetProps);
+          },
+          onTouchCancel: () => {
+            return [];
+          },
+          onMouseMove: (evt, targetProps) => {
+            return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+          },
+          onTouchMove: (evt, targetProps) => {
+            return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+          }
         }
-
-        return cursorLabelOffset;
+      }];
+    };
+    getCursorPosition(props) {
+      const {
+        cursorValue,
+        defaultCursorValue,
+        domain,
+        cursorDimension
+      } = props;
+      if (cursorValue) {
+        return cursorValue;
       }
-    }, {
-      key: "getPadding",
-      value: function getPadding(props) {
-        if (props.padding === undefined) {
-          var child = props.children.find(function (c) {
-            return _isObject(c.props) && c.props.padding !== undefined;
-          });
-          return Helpers.getPadding(child.props);
-        }
-
-        return Helpers.getPadding(props);
+      if (typeof defaultCursorValue === "number") {
+        return {
+          x: (domain.x[0] + domain.x[1]) / 2,
+          y: (domain.y[0] + domain.y[1]) / 2,
+          [cursorDimension]: defaultCursorValue
+        };
       }
-    }, {
-      key: "getCursorElements",
-      value: function getCursorElements(props) {
-        // eslint-disable-line max-statements
-        var scale = props.scale,
-            cursorLabelComponent = props.cursorLabelComponent,
-            cursorLabel = props.cursorLabel,
-            cursorComponent = props.cursorComponent,
-            width = props.width,
-            height = props.height,
-            name = props.name,
-            horizontal = props.horizontal,
-            theme = props.theme;
-        var cursorDimension = CursorHelpers.getDimension(props);
-        var cursorValue = this.getCursorPosition(props);
-        var cursorLabelOffset = this.getCursorLabelOffset(props);
-
-        if (!cursorValue) {
-          return [];
-        }
-
-        var newElements = [];
-        var padding = this.getPadding(props);
-        var cursorCoordinates = {
-          x: horizontal ? scale.y(cursorValue.y) : scale.x(cursorValue.x),
-          y: horizontal ? scale.x(cursorValue.x) : scale.y(cursorValue.y)
+      return defaultCursorValue;
+    }
+    getCursorLabelOffset(props) {
+      const {
+        cursorLabelOffset
+      } = props;
+      if (typeof cursorLabelOffset === "number") {
+        return {
+          x: cursorLabelOffset,
+          y: cursorLabelOffset
         };
-
-        if (cursorLabel) {
-          var labelProps = _defaults({
-            active: true
-          }, cursorLabelComponent.props, {
-            x: cursorCoordinates.x + cursorLabelOffset.x,
-            y: cursorCoordinates.y + cursorLabelOffset.y,
-            datum: cursorValue,
-            active: true,
-            key: "".concat(name, "-cursor-label")
-          });
-
-          if (Helpers.isTooltip(cursorLabelComponent)) {
-            var tooltipTheme = theme && theme.tooltip || {};
-            labelProps = _defaults({}, labelProps, tooltipTheme);
-          }
-
-          newElements.push( /*#__PURE__*/React.cloneElement(cursorLabelComponent, _defaults({}, labelProps, {
-            text: Helpers.evaluateProp(cursorLabel, labelProps)
-          })));
-        }
-
-        var cursorStyle = Object.assign({
-          stroke: "black"
-        }, cursorComponent.props.style);
-
-        if (cursorDimension === "x" || cursorDimension === undefined) {
-          newElements.push( /*#__PURE__*/React.cloneElement(cursorComponent, {
-            key: "".concat(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( /*#__PURE__*/React.cloneElement(cursorComponent, {
-            key: "".concat(name, "-y-cursor"),
-            x1: padding.left,
-            x2: width - padding.right,
-            y1: cursorCoordinates.y,
-            y2: cursorCoordinates.y,
-            style: cursorStyle
-          }));
-        }
-
-        return newElements;
-      } // Overrides method in VictoryContainer
-
-    }, {
-      key: "getChildren",
-      value: function getChildren(props) {
-        return [].concat(_toConsumableArray(React.Children.toArray(props.children)), _toConsumableArray(this.getCursorElements(props)));
       }
-    }]);
-
-    return VictoryCursorContainer;
-  }(Base), _class.displayName = "VictoryCursorContainer", _class.defaultProps = _objectSpread(_objectSpread({}, VictoryContainer.defaultProps), {}, {
-    cursorLabelComponent: /*#__PURE__*/React.createElement(VictoryLabel, null),
-    cursorLabelOffset: {
-      x: 5,
-      y: -10
-    },
-    cursorComponent: /*#__PURE__*/React.createElement(LineSegment, null)
-  }), _class.defaultEvents = function (props) {
-    return [{
-      target: "parent",
-      eventHandlers: {
-        onMouseLeave: function (evt, targetProps) {
-          return props.disable ? {} : CursorHelpers.onMouseLeave(evt, targetProps);
-        },
-        onTouchCancel: function () {
-          return [];
-        },
-        onMouseMove: function (evt, targetProps) {
-          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
-        },
-        onTouchMove: function (evt, targetProps) {
-          return props.disable ? {} : CursorHelpers.onMouseMove(evt, targetProps);
+      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);
+      }
+      return Helpers.getPadding(props);
+    }
+    getCursorElements(props) {
+      // eslint-disable-line max-statements
+      const {
+        scale,
+        cursorLabelComponent,
+        cursorLabel,
+        cursorComponent,
+        width,
+        height,
+        name,
+        horizontal,
+        theme
+      } = props;
+      const cursorDimension = CursorHelpers.getDimension(props);
+      const cursorValue = this.getCursorPosition(props);
+      const cursorLabelOffset = this.getCursorLabelOffset(props);
+      if (!cursorValue) {
+        return [];
+      }
+      const newElements = [];
+      const padding = this.getPadding(props);
+      const cursorCoordinates = {
+        x: horizontal ? scale.y(cursorValue.y) : scale.x(cursorValue.x),
+        y: horizontal ? scale.x(cursorValue.x) : scale.y(cursorValue.y)
+      };
+      if (cursorLabel) {
+        let labelProps = _defaults({
+          active: true
+        }, cursorLabelComponent.props, {
+          x: cursorCoordinates.x + cursorLabelOffset.x,
+          y: cursorCoordinates.y + cursorLabelOffset.y,
+          datum: cursorValue,
+          active: true,
+          key: `${name}-cursor-label`
+        });
+        if (Helpers.isTooltip(cursorLabelComponent)) {
+          const tooltipTheme = theme && theme.tooltip || {};
+          labelProps = _defaults({}, labelProps, tooltipTheme);
         }
+        newElements.push( /*#__PURE__*/React.cloneElement(cursorLabelComponent, _defaults({}, labelProps, {
+          text: Helpers.evaluateProp(cursorLabel, labelProps)
+        })));
+      }
+      const cursorStyle = Object.assign({
+        stroke: "black"
+      }, cursorComponent.props.style);
+      if (cursorDimension === "x" || cursorDimension === undefined) {
+        newElements.push( /*#__PURE__*/React.cloneElement(cursorComponent, {
+          key: `${name}-x-cursor`,
+          x1: cursorCoordinates.x,
+          x2: cursorCoordinates.x,
+          y1: padding.top,
+          y2: height - padding.bottom,
+          style: cursorStyle
+        }));
       }
-    }];
-  }, _class;
+      if (cursorDimension === "y" || cursorDimension === undefined) {
+        newElements.push( /*#__PURE__*/React.cloneElement(cursorComponent, {
+          key: `${name}-y-cursor`,
+          x1: padding.left,
+          x2: width - padding.right,
+          y1: cursorCoordinates.y,
+          y2: cursorCoordinates.y,
+          style: cursorStyle
+        }));
+      }
+      return newElements;
+    }
+
+    // Overrides method in VictoryContainer
+    getChildren(props) {
+      return [...React.Children.toArray(props.children), ...this.getCursorElements(props)];
+    }
+  };
 }
-export var VictoryCursorContainer = cursorContainerMixin(VictoryContainer);
+export const VictoryCursorContainer = cursorContainerMixin(VictoryContainer);

package/lib/cursor-helpers.js

@@ -4,129 +4,92 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.CursorHelpers = void 0;
-
 var _throttle2 = _interopRequireDefault(require("lodash/throttle"));
-
 var _victoryCore = require("victory-core");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-var ON_MOUSE_MOVE_THROTTLE_MS = 16;
-
-var CursorHelpersClass = /*#__PURE__*/function () {
-  function CursorHelpersClass() {
-    var _this = this;
-
-    _classCallCheck(this, CursorHelpersClass);
-
-    this.handleMouseMove = function (evt, targetProps) {
-      var onCursorChange = targetProps.onCursorChange,
-          domain = targetProps.domain;
-
-      var cursorDimension = _this.getDimension(targetProps);
-
-      var parentSVG = targetProps.parentSVG || _victoryCore.Selection.getParentSVG(evt);
-
-      var cursorSVGPosition = _victoryCore.Selection.getSVGEventCoordinates(evt, parentSVG);
-
-      var cursorValue = _victoryCore.Selection.getDataCoordinates(targetProps, targetProps.scale, cursorSVGPosition.x, cursorSVGPosition.y);
-
-      var inBounds = _this.withinBounds(cursorValue, {
-        x1: domain.x[0],
-        x2: domain.x[1],
-        y1: domain.y[0],
-        y2: domain.y[1]
-      });
-
-      if (!inBounds) {
-        cursorValue = null;
-      }
-
-      if (_victoryCore.Helpers.isFunction(onCursorChange)) {
-        if (cursorValue) {
-          var value = cursorDimension ? cursorValue[cursorDimension] : cursorValue;
-          onCursorChange(value, targetProps);
-        } else if (cursorValue !== targetProps.cursorValue) {
-          onCursorChange(targetProps.defaultCursorValue || null, targetProps);
-        }
-      }
-
-      return [{
-        target: "parent",
-        eventKey: "parent",
-        mutation: function () {
-          return {
-            cursorValue: cursorValue,
-            parentSVG: parentSVG
-          };
-        }
-      }];
-    };
-
-    this.onMouseMove = (0, _throttle2.default)(this.handleMouseMove, ON_MOUSE_MOVE_THROTTLE_MS, {
-      leading: true,
-      trailing: false
-    });
-    this.onMouseLeave = this.handleMouseMove;
-
-    this.onTouchEnd = function (evt, targetProps) {
-      var onCursorChange = targetProps.onCursorChange;
-
-      if (_victoryCore.Helpers.isFunction(targetProps.onCursorChange)) {
-        onCursorChange(null, targetProps);
-      }
-
-      return [{
-        target: "parent",
-        eventKey: "parent",
-        mutation: function () {
-          return {
-            cursorValue: null
-          };
-        }
-      }];
-    };
+const ON_MOUSE_MOVE_THROTTLE_MS = 16;
+class CursorHelpersClass {
+  getDimension(props) {
+    const {
+      horizontal,
+      cursorDimension
+    } = props;
+    if (!horizontal || !cursorDimension) {
+      return cursorDimension;
+    }
+    return cursorDimension === "x" ? "y" : "x";
   }
-
-  _createClass(CursorHelpersClass, [{
-    key: "getDimension",
-    value: function getDimension(props) {
-      var horizontal = props.horizontal,
-          cursorDimension = props.cursorDimension;
-
-      if (!horizontal || !cursorDimension) {
-        return cursorDimension;
+  withinBounds(point, bounds) {
+    const {
+      x1,
+      x2,
+      y1,
+      y2
+    } = _victoryCore.Helpers.mapValues(bounds, Number);
+    const {
+      x,
+      y
+    } = _victoryCore.Helpers.mapValues(point, Number);
+    return x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
+  }
+  handleMouseMove = (evt, targetProps) => {
+    const {
+      onCursorChange,
+      domain
+    } = targetProps;
+    const cursorDimension = this.getDimension(targetProps);
+    const parentSVG = targetProps.parentSVG || _victoryCore.Selection.getParentSVG(evt);
+    const cursorSVGPosition = _victoryCore.Selection.getSVGEventCoordinates(evt, parentSVG);
+    let cursorValue = _victoryCore.Selection.getDataCoordinates(targetProps, targetProps.scale, cursorSVGPosition.x, cursorSVGPosition.y);
+    const inBounds = this.withinBounds(cursorValue, {
+      x1: domain.x[0],
+      x2: domain.x[1],
+      y1: domain.y[0],
+      y2: domain.y[1]
+    });
+    if (!inBounds) {
+      cursorValue = null;
+    }
+    if (_victoryCore.Helpers.isFunction(onCursorChange)) {
+      if (cursorValue) {
+        const value = cursorDimension ? cursorValue[cursorDimension] : cursorValue;
+        onCursorChange(value, targetProps);
+      } else if (cursorValue !== targetProps.cursorValue) {
+        onCursorChange(targetProps.defaultCursorValue || null, targetProps);
       }
-
-      return cursorDimension === "x" ? "y" : "x";
     }
-  }, {
-    key: "withinBounds",
-    value: function withinBounds(point, bounds) {
-      var _Helpers$mapValues = _victoryCore.Helpers.mapValues(bounds, Number),
-          x1 = _Helpers$mapValues.x1,
-          x2 = _Helpers$mapValues.x2,
-          y1 = _Helpers$mapValues.y1,
-          y2 = _Helpers$mapValues.y2;
-
-      var _Helpers$mapValues2 = _victoryCore.Helpers.mapValues(point, Number),
-          x = _Helpers$mapValues2.x,
-          y = _Helpers$mapValues2.y;
-
-      return x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
+    return [{
+      target: "parent",
+      eventKey: "parent",
+      mutation: () => ({
+        cursorValue,
+        parentSVG
+      })
+    }];
+  };
+  onMouseMove = (0, _throttle2.default)(this.handleMouseMove, ON_MOUSE_MOVE_THROTTLE_MS, {
+    leading: true,
+    trailing: false
+  });
+  onMouseLeave = this.handleMouseMove;
+  onTouchEnd = (evt, targetProps) => {
+    const {
+      onCursorChange
+    } = targetProps;
+    if (_victoryCore.Helpers.isFunction(targetProps.onCursorChange)) {
+      onCursorChange(null, targetProps);
     }
-  }]);
+    return [{
+      target: "parent",
+      eventKey: "parent",
+      mutation: () => ({
+        cursorValue: null
+      })
+    }];
+  };
+}
+const CursorHelpers = exports.CursorHelpers = new CursorHelpersClass();
 
-  return CursorHelpersClass;
-}();
-
-var CursorHelpers = new CursorHelpersClass();
 /* {
   ...CursorHelpers,
   onMouseMove: throttle(
@@ -142,6 +105,4 @@ var CursorHelpers = new CursorHelpersClass();
 };
 
 
-   */
-
-exports.CursorHelpers = CursorHelpers;
+   */

package/lib/index.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
 var _cursorHelpers = require("./cursor-helpers");
-
 Object.keys(_cursorHelpers).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _cursorHelpers[key]) return;
@@ -16,9 +14,7 @@ Object.keys(_cursorHelpers).forEach(function (key) {
     }
   });
 });
-
 var _victoryCursorContainer = require("./victory-cursor-container");
-
 Object.keys(_victoryCursorContainer).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (key in exports && exports[key] === _victoryCursorContainer[key]) return;