victory-cursor-container 36.5.3 → 36.6.2

package/es/cursor-helpers.js

@@ -2,100 +2,135 @@ import _mapValues from "lodash/mapValues";
 import _isFunction from "lodash/isFunction";
 import _throttle from "lodash/throttle";
 
-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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-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 _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 _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 _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 import { Selection } from "victory-core";
 var ON_MOUSE_MOVE_THROTTLE_MS = 16;
-var CursorHelpers = {
-  getDimension: function (props) {
-    var horizontal = props.horizontal,
-        cursorDimension = props.cursorDimension;
 
-    if (!horizontal || !cursorDimension) {
-      return cursorDimension;
-    }
+var CursorHelpersClass = /*#__PURE__*/function () {
+  function CursorHelpersClass() {
+    var _this = this;
 
-    return cursorDimension === "x" ? "y" : "x";
-  },
-  withinBounds: function (point, bounds) {
-    var _mapValues2 = _mapValues(bounds, Number),
-        x1 = _mapValues2.x1,
-        x2 = _mapValues2.x2,
-        y1 = _mapValues2.y1,
-        y2 = _mapValues2.y2;
-
-    var _mapValues3 = _mapValues(point, Number),
-        x = _mapValues3.x,
-        y = _mapValues3.y;
-
-    return x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
-  },
-  onMouseMove: function (evt, targetProps) {
-    var onCursorChange = targetProps.onCursorChange,
-        domain = targetProps.domain;
-    var cursorDimension = this.getDimension(targetProps);
-    var parentSVG = targetProps.parentSVG || Selection.getParentSVG(evt);
-    var cursorSVGPosition = Selection.getSVGEventCoordinates(evt, parentSVG);
-    var cursorValue = 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]
-    });
+    _classCallCheck(this, CursorHelpersClass);
 
-    if (!inBounds) {
-      cursorValue = null;
-    }
+    this.handleMouseMove = function (evt, targetProps) {
+      var onCursorChange = targetProps.onCursorChange,
+          domain = targetProps.domain;
+
+      var cursorDimension = _this.getDimension(targetProps);
 
-    if (_isFunction(onCursorChange)) {
-      if (inBounds) {
-        var value = cursorDimension ? cursorValue[cursorDimension] : cursorValue;
-        onCursorChange(value, targetProps);
-      } else if (cursorValue !== targetProps.cursorValue) {
-        onCursorChange(targetProps.defaultCursorValue || null, targetProps);
+      var parentSVG = targetProps.parentSVG || Selection.getParentSVG(evt);
+      var cursorSVGPosition = Selection.getSVGEventCoordinates(evt, parentSVG);
+      var cursorValue = 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;
       }
-    }
 
-    return [{
-      target: "parent",
-      eventKey: "parent",
-      mutation: function () {
-        return {
-          cursorValue: cursorValue,
-          parentSVG: parentSVG
-        };
+      if (_isFunction(onCursorChange)) {
+        if (cursorValue) {
+          var value = cursorDimension ? cursorValue[cursorDimension] : cursorValue;
+          onCursorChange(value, targetProps);
+        } else if (cursorValue !== targetProps.cursorValue) {
+          onCursorChange(targetProps.defaultCursorValue || null, targetProps);
+        }
       }
-    }];
-  },
-  onTouchEnd: function (evt, targetProps) {
-    var onCursorChange = targetProps.onCursorChange;
 
-    if (_isFunction(targetProps.onCursorChange)) {
-      onCursorChange(null, targetProps);
-    }
+      return [{
+        target: "parent",
+        eventKey: "parent",
+        mutation: function () {
+          return {
+            cursorValue: cursorValue,
+            parentSVG: parentSVG
+          };
+        }
+      }];
+    };
+
+    this.onMouseMove = _throttle(this.handleMouseMove, ON_MOUSE_MOVE_THROTTLE_MS, {
+      leading: true,
+      trailing: false
+    });
+    this.onMouseLeave = this.handleMouseMove;
 
-    return [{
-      target: "parent",
-      eventKey: "parent",
-      mutation: function () {
-        return {
-          cursorValue: null
-        };
+    this.onTouchEnd = function (evt, targetProps) {
+      var onCursorChange = targetProps.onCursorChange;
+
+      if (_isFunction(targetProps.onCursorChange)) {
+        onCursorChange(null, targetProps);
       }
-    }];
+
+      return [{
+        target: "parent",
+        eventKey: "parent",
+        mutation: function () {
+          return {
+            cursorValue: null
+          };
+        }
+      }];
+    };
   }
-};
-export default _objectSpread(_objectSpread({}, CursorHelpers), {}, {
-  onMouseMove: _throttle(CursorHelpers.onMouseMove.bind(CursorHelpers), ON_MOUSE_MOVE_THROTTLE_MS, {
-    leading: true,
-    trailing: false
-  }),
+
+  _createClass(CursorHelpersClass, [{
+    key: "getDimension",
+    value: function getDimension(props) {
+      var horizontal = props.horizontal,
+          cursorDimension = props.cursorDimension;
+
+      if (!horizontal || !cursorDimension) {
+        return cursorDimension;
+      }
+
+      return cursorDimension === "x" ? "y" : "x";
+    }
+  }, {
+    key: "withinBounds",
+    value: function withinBounds(point, bounds) {
+      var _mapValues2 = _mapValues(bounds, Number),
+          x1 = _mapValues2.x1,
+          x2 = _mapValues2.x2,
+          y1 = _mapValues2.y1,
+          y2 = _mapValues2.y2;
+
+      var _mapValues3 = _mapValues(point, Number),
+          x = _mapValues3.x,
+          y = _mapValues3.y;
+
+      return x >= Math.min(x1, x2) && x <= Math.max(x1, x2) && y >= Math.min(y1, y2) && y <= Math.max(y1, y2);
+    }
+  }]);
+
+  return CursorHelpersClass;
+}();
+
+export var CursorHelpers = new CursorHelpersClass();
+/* {
+  ...CursorHelpers,
+  onMouseMove: throttle(
+    CursorHelpers.onMouseMove.bind(CursorHelpers),
+    ON_MOUSE_MOVE_THROTTLE_MS,
+    {
+      leading: true,
+      trailing: false,
+    },
+  ),
   onMouseLeave: CursorHelpers.onMouseMove.bind(CursorHelpers),
-  onTouchEnd: CursorHelpers.onTouchEnd.bind(CursorHelpers)
-});
+  onTouchEnd: CursorHelpers.onTouchEnd.bind(CursorHelpers),
+};
+
+
+   */
 //# sourceMappingURL=cursor-helpers.js.map

package/es/index.d.ts

@@ -1,37 +1,3 @@
-import * as React from "react";
-import {
-  VictoryContainerProps,
-  CoordinatesPropType,
-  CallbackArgs,
-} from "victory-core";
-
-export type CursorCoordinatesPropType = CoordinatesPropType | number;
-
-export interface VictoryCursorContainerProps extends VictoryContainerProps {
-  cursorComponent?: React.ReactElement;
-  cursorDimension?: "x" | "y";
-  cursorLabel?: (point: CoordinatesPropType, args: CallbackArgs) => any | void;
-  cursorLabelComponent?: React.ReactElement;
-  cursorLabelOffset?: CursorCoordinatesPropType;
-  defaultCursorValue?: CursorCoordinatesPropType;
-  disable?: boolean;
-  onCursorChange?: (
-    value: CursorCoordinatesPropType,
-    props: VictoryCursorContainerProps,
-  ) => void;
-}
-
-export class VictoryCursorContainer extends React.Component<
-  VictoryCursorContainerProps,
-  any
-> {}
-
-export const CursorHelpers: {
-  getDimension(props): any;
-  withinBounds(point, bounds): any;
-  onMouseMove(evt, targetProps): any;
-  onMouseLeave(evt, targetProps): any;
-  onTouchEnd(evt, targetProps): any;
-};
-
-export const cursorContainerMixin: (base: Function) => Function;
+export * from "./cursor-helpers";
+export * from "./victory-cursor-container";
+//# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -1,3 +1,3 @@
-export { cursorContainerMixin, default as VictoryCursorContainer } from "./victory-cursor-container";
-export { default as CursorHelpers } from "./cursor-helpers";
+export * from "./cursor-helpers";
+export * from "./victory-cursor-container";
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,221 @@
+import PropTypes from "prop-types";
+import React from "react";
+import { VictoryContainer, VictoryContainerProps, CoordinatesPropType, VictoryLabelProps, ValueOrCallback } from "victory-core";
+export declare type CursorCoordinatesPropType = CoordinatesPropType | number;
+export interface VictoryCursorContainerProps extends VictoryContainerProps {
+    cursorComponent?: React.ReactElement;
+    cursorDimension?: "x" | "y";
+    cursorLabel?: ValueOrCallback<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;
+    propTypes: {
+        cursorDimension: PropTypes.Requireable<string>;
+        cursorLabel: PropTypes.Requireable<(...args: any[]) => any>;
+        cursorLabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        cursorLabelOffset: PropTypes.Requireable<number | PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>;
+        defaultCursorValue: PropTypes.Requireable<number | PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>;
+        disable: PropTypes.Requireable<boolean>;
+        onCursorChange: PropTypes.Requireable<(...args: any[]) => any>;
+        "aria-describedby": PropTypes.Requireable<string>;
+        "aria-labelledby": PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<string | number | boolean | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        className: PropTypes.Requireable<string>;
+        containerId: PropTypes.Requireable<string | number>;
+        containerRef: PropTypes.Requireable<(...args: any[]) => any>;
+        desc: PropTypes.Requireable<string>;
+        events: PropTypes.Requireable<object>;
+        height: PropTypes.Requireable<number | undefined>;
+        name: PropTypes.Requireable<string>;
+        origin: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Requireable<number | undefined>;
+            y: PropTypes.Requireable<number | undefined>;
+        }>>;
+        ouiaId: PropTypes.Requireable<string | number>;
+        ouiaSafe: PropTypes.Requireable<boolean>;
+        ouiaType: PropTypes.Requireable<string>;
+        polar: PropTypes.Requireable<boolean>;
+        portalComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        portalZIndex: PropTypes.Requireable<number | undefined>;
+        preserveAspectRatio: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+        role: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        tabIndex: PropTypes.Requireable<number>;
+        theme: PropTypes.Requireable<object>;
+        title: PropTypes.Requireable<string>;
+        width: PropTypes.Requireable<number | undefined>;
+    };
+    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;
+    propTypes: {
+        cursorDimension: PropTypes.Requireable<string>;
+        cursorLabel: PropTypes.Requireable<(...args: any[]) => any>;
+        cursorLabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        cursorLabelOffset: PropTypes.Requireable<number | PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>;
+        defaultCursorValue: PropTypes.Requireable<number | PropTypes.InferProps<{
+            x: PropTypes.Requireable<number>;
+            y: PropTypes.Requireable<number>;
+        }>>;
+        disable: PropTypes.Requireable<boolean>;
+        onCursorChange: PropTypes.Requireable<(...args: any[]) => any>;
+        "aria-describedby": PropTypes.Requireable<string>;
+        "aria-labelledby": PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<string | number | boolean | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        className: PropTypes.Requireable<string>;
+        containerId: PropTypes.Requireable<string | number>;
+        containerRef: PropTypes.Requireable<(...args: any[]) => any>;
+        desc: PropTypes.Requireable<string>;
+        events: PropTypes.Requireable<object>;
+        height: PropTypes.Requireable<number | undefined>;
+        name: PropTypes.Requireable<string>;
+        origin: PropTypes.Requireable<PropTypes.InferProps<{
+            x: PropTypes.Requireable<number | undefined>;
+            y: PropTypes.Requireable<number | undefined>;
+        }>>;
+        ouiaId: PropTypes.Requireable<string | number>;
+        ouiaSafe: PropTypes.Requireable<boolean>;
+        ouiaType: PropTypes.Requireable<string>;
+        polar: PropTypes.Requireable<boolean>;
+        portalComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        portalZIndex: PropTypes.Requireable<number | undefined>;
+        preserveAspectRatio: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+        role: PropTypes.Requireable<string>;
+        style: PropTypes.Requireable<object>;
+        tabIndex: PropTypes.Requireable<number>;
+        theme: PropTypes.Requireable<object>;
+        title: PropTypes.Requireable<string>;
+        width: PropTypes.Requireable<number | undefined>;
+    };
+    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

@@ -43,12 +43,13 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 import PropTypes from "prop-types";
 import React from "react";
 import { VictoryContainer, VictoryLabel, LineSegment, Helpers } from "victory-core";
-import CursorHelpers from "./cursor-helpers";
-export var cursorContainerMixin = function (base) {
+import { CursorHelpers } from "./cursor-helpers";
+export function cursorContainerMixin(Base) {
   var _class;
 
-  return _class = /*#__PURE__*/function (_base) {
-    _inherits(VictoryCursorContainer, _base);
+  // @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);
 
@@ -101,9 +102,9 @@ export var cursorContainerMixin = function (base) {
             return _isObject(c.props) && c.props.padding !== undefined;
           });
           return Helpers.getPadding(child.props);
-        } else {
-          return Helpers.getPadding(props);
         }
+
+        return Helpers.getPadding(props);
       }
     }, {
       key: "getCursorElements",
@@ -191,7 +192,7 @@ export var cursorContainerMixin = function (base) {
     }]);
 
     return VictoryCursorContainer;
-  }(base), _class.displayName = "VictoryCursorContainer", _class.propTypes = _objectSpread(_objectSpread({}, VictoryContainer.propTypes), {}, {
+  }(Base), _class.displayName = "VictoryCursorContainer", _class.propTypes = _objectSpread(_objectSpread({}, VictoryContainer.propTypes), {}, {
     cursorDimension: PropTypes.oneOf(["x", "y"]),
     cursorLabel: PropTypes.func,
     cursorLabelComponent: PropTypes.element,
@@ -231,6 +232,6 @@ export var cursorContainerMixin = function (base) {
       }
     }];
   }, _class;
-};
-export default cursorContainerMixin(VictoryContainer);
+}
+export var VictoryCursorContainer = cursorContainerMixin(VictoryContainer);
 //# sourceMappingURL=victory-cursor-container.js.map

package/lib/cursor-helpers.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="lodash" />
+import { Selection } from "victory-core";
+declare class CursorHelpersClass {
+    getDimension(props: any): any;
+    withinBounds(point: any, bounds: any): boolean;
+    private handleMouseMove;
+    onMouseMove: import("lodash").DebouncedFunc<(evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: Selection.SVGCoordinateType | null;
+            parentSVG: any;
+        };
+    }[]>;
+    onMouseLeave: (evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: Selection.SVGCoordinateType | null;
+            parentSVG: any;
+        };
+    }[];
+    onTouchEnd: (evt: any, targetProps: any) => {
+        target: string;
+        eventKey: string;
+        mutation: () => {
+            cursorValue: null;
+        };
+    }[];
+}
+export declare const CursorHelpers: CursorHelpersClass;
+export {};
+//# sourceMappingURL=cursor-helpers.d.ts.map