victory-cursor-container 36.9.2-next.1 → 36.9.2

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

@@ -1,85 +1,134 @@
-import React from "react";
-import { VictoryContainerProps, CoordinatesPropType, VictoryLabelProps, ValueOrAccessor, VictoryEventHandler, DomainTuple, PaddingProps } 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;
-    horizontal?: boolean;
-    padding?: PaddingProps;
-    onCursorChange?: (value: CursorCoordinatesPropType, props: VictoryCursorContainerProps) => void;
-}
-export declare const VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS: {
-    cursorLabelComponent: JSX.Element;
-    cursorLabelOffset: {
-        x: number;
-        y: number;
-    };
-    cursorComponent: JSX.Element;
-};
-export declare const useVictoryCursorContainer: (initialProps: VictoryCursorContainerProps) => {
-    props: {
-        cursorValue: CoordinatesPropType | null;
-        domain: {
-            x: DomainTuple;
-            y: DomainTuple;
-        };
-        cursorComponent: JSX.Element;
-        cursorDimension?: "x" | "y" | undefined;
-        cursorLabel?: ValueOrAccessor<VictoryLabelProps["text"]>;
-        cursorLabelComponent: JSX.Element;
-        cursorLabelOffset: CursorCoordinatesPropType;
-        defaultCursorValue?: CursorCoordinatesPropType | undefined;
-        disable?: boolean | undefined;
-        horizontal?: boolean | undefined;
-        padding?: PaddingProps | undefined;
-        onCursorChange?: ((value: CursorCoordinatesPropType, props: VictoryCursorContainerProps) => void) | undefined;
-        "aria-describedby"?: string | undefined;
-        "aria-labelledby"?: string | undefined;
-        children?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactElement<any, string | React.JSXElementConstructor<any>>[] | undefined;
-        className?: string | undefined;
-        containerId?: string | number | undefined;
-        containerRef?: React.Ref<HTMLElement> | undefined;
-        desc?: string | undefined;
-        events?: React.DOMAttributes<any> | undefined;
-        height?: number | undefined;
-        name?: string | undefined;
-        origin?: import("victory-core").OriginType | undefined;
-        polar?: boolean | undefined;
-        portalComponent?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
-        portalZIndex?: number | undefined;
-        preserveAspectRatio?: string | undefined;
-        responsive?: boolean | undefined;
-        role?: string | undefined;
-        scale?: {
-            x?: import("victory-core").D3Scale<any> | undefined;
-            y?: import("victory-core").D3Scale<any> | undefined;
-        } | undefined;
-        style?: React.CSSProperties | undefined;
-        tabIndex?: number | undefined;
-        theme?: import("victory-core").VictoryThemeDefinition | undefined;
-        title?: string | undefined;
-        width?: number | undefined;
-        ouiaId?: string | number | undefined;
-        ouiaSafe?: boolean | undefined;
-        ouiaType?: string | undefined;
-    };
-    children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-};
-export declare const VictoryCursorContainer: {
-    (initialProps: VictoryCursorContainerProps): JSX.Element;
-    role: string;
-    defaultEvents(initialProps: VictoryCursorContainerProps): {
-        target: string;
-        eventHandlers: {
-            onMouseLeave: VictoryEventHandler;
-            onMouseMove: VictoryEventHandler;
-            onTouchMove: VictoryEventHandler;
-        };
-    }[];
-};
+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/lib/victory-cursor-container.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useVictoryCursorContainer = exports.VictoryCursorContainer = exports.VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS = void 0;
+exports.VictoryCursorContainer = void 0;
+exports.cursorContainerMixin = cursorContainerMixin;
 
 var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
 
@@ -17,6 +18,10 @@ var _cursorHelpers = require("./cursor-helpers");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+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."); }
@@ -29,187 +34,205 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 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 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 _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; }
 
-var VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS = {
-  cursorLabelComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryLabel, null),
-  cursorLabelOffset: {
-    x: 5,
-    y: -10
-  },
-  cursorComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.LineSegment, null)
-};
-exports.VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS = VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS;
-
-var useVictoryCursorContainer = function (initialProps) {
-  var props = _objectSpread(_objectSpread({}, VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS), initialProps);
-
-  var children = props.children;
-
-  var getCursorPosition = function () {
-    var cursorValue = props.cursorValue,
-        defaultCursorValue = props.defaultCursorValue,
-        domain = props.domain,
-        cursorDimension = props.cursorDimension;
-
-    if (cursorValue) {
-      return cursorValue;
-    }
-
-    if (typeof defaultCursorValue === "number") {
-      return _objectSpread({
-        x: (domain.x[0] + domain.x[1]) / 2,
-        y: (domain.y[0] + domain.y[1]) / 2
-      }, cursorDimension ? _defineProperty({}, cursorDimension, defaultCursorValue) : {});
-    }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-    return defaultCursorValue;
-  };
+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); } }
 
-  var getCursorLabelOffset = function () {
-    var cursorLabelOffset = props.cursorLabelOffset;
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-    if (typeof cursorLabelOffset === "number") {
-      return {
-        x: cursorLabelOffset,
-        y: cursorLabelOffset
-      };
-    }
+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); }
 
-    return cursorLabelOffset;
-  };
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-  var getPadding = function () {
-    if (props.padding === undefined) {
-      var child = Array.isArray(props.children) ? props.children.find(function (c) {
-        return (0, _isObject2.default)(c.props) && c.props.padding !== undefined;
-      }) : props.children;
-      return _victoryCore.Helpers.getPadding(child === null || child === void 0 ? void 0 : child.props);
-    }
+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); }; }
 
-    return _victoryCore.Helpers.getPadding(props);
-  };
+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); }
 
-  var getCursorElements = function () {
-    var _scale$y, _scale$x, _scale$x2, _scale$y2;
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-    // 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;
+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; } }
 
-    var cursorDimension = _cursorHelpers.CursorHelpers.getDimension(props);
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-    var cursorValue = getCursorPosition();
-    var cursorLabelOffset = getCursorLabelOffset();
+function cursorContainerMixin(Base) {
+  var _class;
 
-    if (!cursorValue) {
-      return [];
-    }
+  // @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 newElements = [];
-    var padding = getPadding();
-    var cursorCoordinates = {
-      x: horizontal ? scale === null || scale === void 0 ? void 0 : (_scale$y = scale.y) === null || _scale$y === void 0 ? void 0 : _scale$y.call(scale, cursorValue.y) : scale === null || scale === void 0 ? void 0 : (_scale$x = scale.x) === null || _scale$x === void 0 ? void 0 : _scale$x.call(scale, cursorValue.x),
-      y: horizontal ? scale === null || scale === void 0 ? void 0 : (_scale$x2 = scale.x) === null || _scale$x2 === void 0 ? void 0 : _scale$x2.call(scale, cursorValue.x) : scale === null || scale === void 0 ? void 0 : (_scale$y2 = scale.y) === null || _scale$y2 === void 0 ? void 0 : _scale$y2.call(scale, cursorValue.y)
-    };
-
-    if (cursorLabel) {
-      var labelProps = (0, _defaults2.default)({
-        active: true
-      }, cursorLabelComponent.props, {
-        x: cursorCoordinates.x || 0 + cursorLabelOffset.x,
-        y: cursorCoordinates.y || 0 + cursorLabelOffset.y,
-        datum: cursorValue,
-        active: true,
-        key: "".concat(name, "-cursor-label")
-      });
-
-      if (_victoryCore.Helpers.isTooltip(cursorLabelComponent)) {
-        var tooltipTheme = theme && theme.tooltip || {};
-        labelProps = (0, _defaults2.default)({}, labelProps, tooltipTheme);
-      }
+    var _super = _createSuper(VictoryCursorContainer);
 
-      newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorLabelComponent, (0, _defaults2.default)({}, labelProps, {
-        text: _victoryCore.Helpers.evaluateProp(cursorLabel, labelProps)
-      })));
-    }
+    function VictoryCursorContainer() {
+      _classCallCheck(this, VictoryCursorContainer);
 
-    var cursorStyle = Object.assign({
-      stroke: "black"
-    }, cursorComponent.props.style);
-
-    if (cursorDimension === "x" || cursorDimension === undefined) {
-      newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
-        key: "".concat(name, "-x-cursor"),
-        x1: cursorCoordinates.x,
-        x2: cursorCoordinates.x,
-        y1: padding.top,
-        y2: height || 0 - padding.bottom,
-        style: cursorStyle
-      }));
+      return _super.apply(this, arguments);
     }
 
-    if (cursorDimension === "y" || cursorDimension === undefined) {
-      newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorComponent, {
-        key: "".concat(name, "-y-cursor"),
-        x1: padding.left,
-        x2: width || 0 - padding.right,
-        y1: cursorCoordinates.y,
-        y2: cursorCoordinates.y,
-        style: cursorStyle
-      }));
-    }
-
-    return newElements;
-  };
-
-  return {
-    props: props,
-    children: [].concat(_toConsumableArray(_react.default.Children.toArray(children)), _toConsumableArray(getCursorElements()))
-  };
-};
-
-exports.useVictoryCursorContainer = useVictoryCursorContainer;
-
-var VictoryCursorContainer = function (initialProps) {
-  var _useVictoryCursorCont = useVictoryCursorContainer(initialProps),
-      props = _useVictoryCursorCont.props,
-      children = _useVictoryCursorCont.children;
-
-  return /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryContainer, props, children);
-};
-
-exports.VictoryCursorContainer = VictoryCursorContainer;
-VictoryCursorContainer.role = "container";
-
-VictoryCursorContainer.defaultEvents = function (initialProps) {
-  var props = _objectSpread(_objectSpread({}, VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS), initialProps);
-
-  var createEventHandler = function (handler, disabled) {
-    return (// eslint-disable-next-line max-params
-      function (event, targetProps, eventKey, context) {
-        return disabled || props.disable ? {} : handler(event, _objectSpread(_objectSpread({}, props), targetProps), eventKey, context);
+    _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;
       }
-    );
-  };
-
-  return [{
-    target: "parent",
-    eventHandlers: {
-      onMouseLeave: createEventHandler(_cursorHelpers.CursorHelpers.onMouseLeave),
-      onMouseMove: createEventHandler(_cursorHelpers.CursorHelpers.onMouseMove),
-      onTouchMove: createEventHandler(_cursorHelpers.CursorHelpers.onMouseMove)
-    }
-  }];
-};
+    }, {
+      key: "getCursorLabelOffset",
+      value: function getCursorLabelOffset(props) {
+        var cursorLabelOffset = props.cursorLabelOffset;
+
+        if (typeof cursorLabelOffset === "number") {
+          return {
+            x: cursorLabelOffset,
+            y: cursorLabelOffset
+          };
+        }
+
+        return cursorLabelOffset;
+      }
+    }, {
+      key: "getPadding",
+      value: function getPadding(props) {
+        if (props.padding === undefined) {
+          var child = props.children.find(function (c) {
+            return (0, _isObject2.default)(c.props) && c.props.padding !== undefined;
+          });
+          return _victoryCore.Helpers.getPadding(child.props);
+        }
+
+        return _victoryCore.Helpers.getPadding(props);
+      }
+    }, {
+      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.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)
+        };
+
+        if (cursorLabel) {
+          var labelProps = (0, _defaults2.default)({
+            active: true
+          }, cursorLabelComponent.props, {
+            x: cursorCoordinates.x + cursorLabelOffset.x,
+            y: cursorCoordinates.y + cursorLabelOffset.y,
+            datum: cursorValue,
+            active: true,
+            key: "".concat(name, "-cursor-label")
+          });
+
+          if (_victoryCore.Helpers.isTooltip(cursorLabelComponent)) {
+            var tooltipTheme = theme && theme.tooltip || {};
+            labelProps = (0, _defaults2.default)({}, labelProps, tooltipTheme);
+          }
+
+          newElements.push( /*#__PURE__*/_react.default.cloneElement(cursorLabelComponent, (0, _defaults2.default)({}, labelProps, {
+            text: _victoryCore.Helpers.evaluateProp(cursorLabel, labelProps)
+          })));
+        }
+
+        var cursorStyle = Object.assign({
+          stroke: "black"
+        }, cursorComponent.props.style);
+
+        if (cursorDimension === "x" || cursorDimension === undefined) {
+          newElements.push( /*#__PURE__*/_react.default.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.default.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.default.Children.toArray(props.children)), _toConsumableArray(this.getCursorElements(props)));
+      }
+    }]);
+
+    return VictoryCursorContainer;
+  }(Base), _class.displayName = "VictoryCursorContainer", _class.defaultProps = _objectSpread(_objectSpread({}, _victoryCore.VictoryContainer.defaultProps), {}, {
+    cursorLabelComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryLabel, null),
+    cursorLabelOffset: {
+      x: 5,
+      y: -10
+    },
+    cursorComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.LineSegment, null)
+  }), _class.defaultEvents = function (props) {
+    return [{
+      target: "parent",
+      eventHandlers: {
+        onMouseLeave: function (evt, targetProps) {
+          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseLeave(evt, targetProps);
+        },
+        onTouchCancel: function () {
+          return [];
+        },
+        onMouseMove: function (evt, targetProps) {
+          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
+        },
+        onTouchMove: function (evt, targetProps) {
+          return props.disable ? {} : _cursorHelpers.CursorHelpers.onMouseMove(evt, targetProps);
+        }
+      }
+    }];
+  }, _class;
+}
+
+var VictoryCursorContainer = cursorContainerMixin(_victoryCore.VictoryContainer);
+exports.VictoryCursorContainer = VictoryCursorContainer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-cursor-container",
-  "version": "36.9.2-next.1",
+  "version": "36.9.2",
   "description": "Interactive Cursor Component for Victory",
   "keywords": [
     "data visualization",
@@ -12,7 +12,7 @@
     "type": "git",
     "url": "https://github.com/FormidableLabs/victory"
   },
-  "homepage": "https://formidable.com/open-source/victory",
+  "homepage": "https://commerce.nearform.com/open-source/victory",
   "sideEffects": false,
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -21,11 +21,14 @@
   "license": "MIT",
   "dependencies": {
     "lodash": "^4.17.19",
-    "victory-core": "^36.9.2-next.1"
+    "victory-core": "^36.9.2"
   },
   "peerDependencies": {
     "react": ">=16.6.0"
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "wireit": {
     "###            THESE WIREIT CONFIGS ARE GENERATED        ####": {},
     "###            DO NOT MODIFY THESE MANUALLY              ####": {},