victory-cursor-container 36.9.2-next.3 → 37.0.0

package/es/victory-cursor-container.d.ts

@@ -1,134 +1,134 @@
-import React from "react";
-import { VictoryContainer, VictoryContainerProps, CoordinatesPropType, VictoryLabelProps, ValueOrAccessor } from "victory-core";
-export declare type CursorCoordinatesPropType = CoordinatesPropType | number;
-export interface VictoryCursorContainerProps extends VictoryContainerProps {
-    cursorComponent?: React.ReactElement;
-    cursorDimension?: "x" | "y";
-    cursorLabel?: ValueOrAccessor<VictoryLabelProps["text"]>;
-    cursorLabelComponent?: React.ReactElement;
-    cursorLabelOffset?: CursorCoordinatesPropType;
-    defaultCursorValue?: CursorCoordinatesPropType;
-    disable?: boolean;
-    onCursorChange?: (value: CursorCoordinatesPropType, props: VictoryCursorContainerProps) => void;
-}
-declare type ComponentClass<TProps> = {
-    new (props: TProps): React.Component<TProps>;
-};
-export declare function cursorContainerMixin<TBase extends ComponentClass<TProps>, TProps extends VictoryCursorContainerProps>(Base: TBase): {
-    new (props: TProps): {
-        getCursorPosition(props: any): any;
-        getCursorLabelOffset(props: any): any;
-        getPadding(props: any): {
-            top: any;
-            bottom: any;
-            left: any;
-            right: any;
-        };
-        getCursorElements(props: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-        getChildren(props: any): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment)[];
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        render(): React.ReactNode;
-        readonly props: Readonly<TProps>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    displayName: string;
-    defaultProps: {
-        cursorLabelComponent: JSX.Element;
-        cursorLabelOffset: {
-            x: number;
-            y: number;
-        };
-        cursorComponent: JSX.Element;
-        className: string;
-        portalComponent: JSX.Element;
-        portalZIndex: number;
-        responsive: boolean;
-        role: string;
-    };
-    defaultEvents: (props: any) => {
-        target: string;
-        eventHandlers: {
-            onMouseLeave: (evt: any, targetProps: any) => {};
-            onTouchCancel: () => never[];
-            onMouseMove: (evt: any, targetProps: any) => {} | undefined;
-            onTouchMove: (evt: any, targetProps: any) => {} | undefined;
-        };
-    }[];
-} & TBase;
-export declare const VictoryCursorContainer: {
-    new (props: VictoryCursorContainerProps): {
-        getCursorPosition(props: any): any;
-        getCursorLabelOffset(props: any): any;
-        getPadding(props: any): {
-            top: any;
-            bottom: any;
-            left: any;
-            right: any;
-        };
-        getCursorElements(props: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-        getChildren(props: any): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment)[];
-        context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<VictoryCursorContainerProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        render(): React.ReactNode;
-        readonly props: Readonly<VictoryCursorContainerProps>;
-        state: Readonly<{}>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<VictoryCursorContainerProps>, prevState: Readonly<{}>): any;
-        componentDidUpdate?(prevProps: Readonly<VictoryCursorContainerProps>, prevState: Readonly<{}>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<VictoryCursorContainerProps>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<VictoryCursorContainerProps>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): void;
-    };
-    displayName: string;
-    defaultProps: {
-        cursorLabelComponent: JSX.Element;
-        cursorLabelOffset: {
-            x: number;
-            y: number;
-        };
-        cursorComponent: JSX.Element;
-        className: string;
-        portalComponent: JSX.Element;
-        portalZIndex: number;
-        responsive: boolean;
-        role: string;
-    };
-    defaultEvents: (props: any) => {
-        target: string;
-        eventHandlers: {
-            onMouseLeave: (evt: any, targetProps: any) => {};
-            onTouchCancel: () => never[];
-            onMouseMove: (evt: any, targetProps: any) => {} | undefined;
-            onTouchMove: (evt: any, targetProps: any) => {} | undefined;
-        };
-    }[];
-} & typeof VictoryContainer;
-export {};
+import React from "react";
+import { VictoryContainer, VictoryContainerProps, CoordinatesPropType, VictoryLabelProps, ValueOrAccessor } from "victory-core";
+export declare type CursorCoordinatesPropType = CoordinatesPropType | number;
+export interface VictoryCursorContainerProps extends VictoryContainerProps {
+    cursorComponent?: React.ReactElement;
+    cursorDimension?: "x" | "y";
+    cursorLabel?: ValueOrAccessor<VictoryLabelProps["text"]>;
+    cursorLabelComponent?: React.ReactElement;
+    cursorLabelOffset?: CursorCoordinatesPropType;
+    defaultCursorValue?: CursorCoordinatesPropType;
+    disable?: boolean;
+    onCursorChange?: (value: CursorCoordinatesPropType, props: VictoryCursorContainerProps) => void;
+}
+declare type ComponentClass<TProps> = {
+    new (props: TProps): React.Component<TProps>;
+};
+export declare function cursorContainerMixin<TBase extends ComponentClass<TProps>, TProps extends VictoryCursorContainerProps>(Base: TBase): {
+    new (props: TProps): {
+        getCursorPosition(props: any): any;
+        getCursorLabelOffset(props: any): any;
+        getPadding(props: any): {
+            top: any;
+            bottom: any;
+            left: any;
+            right: any;
+        };
+        getCursorElements(props: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+        getChildren(props: any): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment)[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<TProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<TProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<TProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<TProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    defaultProps: {
+        cursorLabelComponent: JSX.Element;
+        cursorLabelOffset: {
+            x: number;
+            y: number;
+        };
+        cursorComponent: JSX.Element;
+        className: string;
+        portalComponent: JSX.Element;
+        portalZIndex: number;
+        responsive: boolean;
+        role: string;
+    };
+    defaultEvents: (props: any) => {
+        target: string;
+        eventHandlers: {
+            onMouseLeave: (evt: any, targetProps: any) => {};
+            onTouchCancel: () => never[];
+            onMouseMove: (evt: any, targetProps: any) => {} | undefined;
+            onTouchMove: (evt: any, targetProps: any) => {} | undefined;
+        };
+    }[];
+} & TBase;
+export declare const VictoryCursorContainer: {
+    new (props: VictoryCursorContainerProps): {
+        getCursorPosition(props: any): any;
+        getCursorLabelOffset(props: any): any;
+        getPadding(props: any): {
+            top: any;
+            bottom: any;
+            left: any;
+            right: any;
+        };
+        getCursorElements(props: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+        getChildren(props: any): (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment)[];
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<VictoryCursorContainerProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<VictoryCursorContainerProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<VictoryCursorContainerProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<VictoryCursorContainerProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<VictoryCursorContainerProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<VictoryCursorContainerProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<VictoryCursorContainerProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    defaultProps: {
+        cursorLabelComponent: JSX.Element;
+        cursorLabelOffset: {
+            x: number;
+            y: number;
+        };
+        cursorComponent: JSX.Element;
+        className: string;
+        portalComponent: JSX.Element;
+        portalZIndex: number;
+        responsive: boolean;
+        role: string;
+    };
+    defaultEvents: (props: any) => {
+        target: string;
+        eventHandlers: {
+            onMouseLeave: (evt: any, targetProps: any) => {};
+            onTouchCancel: () => never[];
+            onMouseMove: (evt: any, targetProps: any) => {} | undefined;
+            onTouchMove: (evt: any, targetProps: any) => {} | undefined;
+        };
+    }[];
+} & typeof VictoryContainer;
+export {};
 //# sourceMappingURL=victory-cursor-container.d.ts.map

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);