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

package/CHANGELOG.md

@@ -1,22 +1,14 @@
 # victory-cursor-container
 
-## 36.9.2-next.3
+## 36.9.2
 
 ### Patch Changes
 
-- 65d02419f: Refactor containers and portal to function components
-- 7efd582cc: Replace lodash array utils with native code
-- 9cdaf2c08: Replace lodash values and mapValues with native code
-- 6e34169a5: Replace lodash isFunction with native code
-- Updated dependencies [7da790934]
-- Updated dependencies [3f2da66e3]
-- Updated dependencies [c13308624]
-- Updated dependencies [65d02419f]
-- Updated dependencies [7efd582cc]
-- Updated dependencies [9cdaf2c08]
-- Updated dependencies [f6f7cc515]
-- Updated dependencies [6e34169a5]
-  - victory-core@36.9.2-next.3
+- Replace lodash array utils with native code ([#2810](https://github.com/FormidableLabs/victory/pull/2810))
+
+* Replace lodash values and mapValues with native code ([#2808](https://github.com/FormidableLabs/victory/pull/2808))
+
+- Replace lodash isFunction with native code ([#2802](https://github.com/FormidableLabs/victory/pull/2802))
 
 ## 36.9.1
 

package/README.md

@@ -2,6 +2,6 @@
 
 `victory-cursor-container@^30.0.0` exports `VictoryCursorContainer`, `cursorContainerMixin` and `CursorHelpers`
 
-To view documentation for `VictoryCursorContainer` please see https://formidable.com/open-source/victory/docs/victory-cursor-container
+To view documentation for `VictoryCursorContainer` please see https://commerce.nearform.com/open-source/victory/docs/victory-cursor-container
 
-To suggest an addition or correction to this documentation please see https://github.com/FormidableLabs/victory/blob/main/docs/src/content/docs/victory-cursor-container.md
+To suggest an addition or correction to this documentation please see https://github.com/FormidableLabs/victory/blob/main/docs/src/content/docs/victory-cursor-container.md

package/dist/victory-cursor-container.js

@@ -4458,6 +4458,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "containsNumbers": () => (/* binding */ containsNumbers),
 /* harmony export */   "containsOnlyStrings": () => (/* binding */ containsOnlyStrings),
 /* harmony export */   "containsStrings": () => (/* binding */ containsStrings),
+/* harmony export */   "difference": () => (/* binding */ difference),
 /* harmony export */   "getMaxValue": () => (/* binding */ getMaxValue),
 /* harmony export */   "getMinValue": () => (/* binding */ getMinValue),
 /* harmony export */   "isArrayOfArrays": () => (/* binding */ isArrayOfArrays),
@@ -4499,6 +4500,22 @@ function containsOnlyStrings(collection) {
     return typeof value === "string";
   });
 }
+/**
+ * Creates an array of array values not included in the other given arrays
+ * @param a The array to inspect
+ * @param b The values to exclude
+ * @returns The new array of filtered values
+ */
+
+function difference(a, b) {
+  if (a && b) {
+    return a.filter(function (value) {
+      return !b.includes(value);
+    });
+  }
+
+  return [];
+}
 function isArrayOfArrays(collection) {
   return isNonEmptyArray(collection) && collection.every(Array.isArray);
 }
@@ -4549,6 +4566,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "getRadius": () => (/* binding */ getRadius),
 /* harmony export */   "getRange": () => (/* binding */ getRange),
 /* harmony export */   "getStyles": () => (/* binding */ getStyles),
+/* harmony export */   "invert": () => (/* binding */ invert),
 /* harmony export */   "isFunction": () => (/* binding */ isFunction),
 /* harmony export */   "isHorizontal": () => (/* binding */ isHorizontal),
 /* harmony export */   "isNil": () => (/* binding */ isNil),
@@ -4599,6 +4617,18 @@ function getPolarRange(props, axis) {
   return [props.innerRadius || 0, getRadius(props)];
 } // Exported Functions
 
+/**
+ * Creates an object composed of the inverted keys and values of object.
+ * If object contains duplicate values, subsequent values overwrite property assignments of previous values.
+ */
+
+
+function invert(original) {
+  return Object.entries(original).reduce(function (acc, current) {
+    acc[current[1]] = current[0];
+    return acc;
+  }, {});
+}
 /**
  * creates an object with some keys excluded
  * replacement for lodash.omit for performance. does not mimic the entire lodash.omit api
@@ -4607,7 +4637,6 @@ function getPolarRange(props, axis) {
  * @returns {Object} new object with same properties as originalObject
  */
 
-
 function omit(originalObject) {
   var ks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
   // code based on babel's _objectWithoutProperties

package/es/cursor-helpers.d.ts

@@ -1,33 +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 {};
+/// <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

package/es/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./cursor-helpers";
-export * from "./victory-cursor-container";
+export * from "./cursor-helpers";
+export * from "./victory-cursor-container";
 //# sourceMappingURL=index.d.ts.map

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/lib/cursor-helpers.d.ts

@@ -1,33 +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 {};
+/// <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

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./cursor-helpers";
-export * from "./victory-cursor-container";
+export * from "./cursor-helpers";
+export * from "./victory-cursor-container";
 //# sourceMappingURL=index.d.ts.map

package/lib/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-cursor-container",
-  "version": "36.9.2-next.3",
+  "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.3"
+    "victory-core": "^36.9.2"
   },
   "peerDependencies": {
     "react": ">=16.6.0"
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "wireit": {
     "###            THESE WIREIT CONFIGS ARE GENERATED        ####": {},
     "###            DO NOT MODIFY THESE MANUALLY              ####": {},

package/src/victory-cursor-container.tsx

@@ -1,6 +1,6 @@
-/* eslint-disable complexity */
 import React from "react";
 import {
+  VictoryContainer,
   Helpers,
   VictoryContainerProps,
   CoordinatesPropType,
@@ -8,10 +8,6 @@ import {
   ValueOrAccessor,
   VictoryLabel,
   LineSegment,
-  VictoryContainer,
-  VictoryEventHandler,
-  DomainTuple,
-  PaddingProps,
 } from "victory-core";
 import { defaults, isObject } from "lodash";
 import { CursorHelpers } from "./cursor-helpers";
@@ -26,208 +22,191 @@ export interface VictoryCursorContainerProps extends VictoryContainerProps {
   cursorLabelOffset?: CursorCoordinatesPropType;
   defaultCursorValue?: CursorCoordinatesPropType;
   disable?: boolean;
-  horizontal?: boolean;
-  padding?: PaddingProps;
   onCursorChange?: (
     value: CursorCoordinatesPropType,
     props: VictoryCursorContainerProps,
   ) => void;
 }
 
-interface VictoryCursorContainerMutatedProps
-  extends VictoryCursorContainerProps {
-  cursorValue: CoordinatesPropType | null;
-  domain: { x: DomainTuple; y: DomainTuple };
-}
-
-export const VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS = {
-  cursorLabelComponent: <VictoryLabel />,
-  cursorLabelOffset: {
-    x: 5,
-    y: -10,
-  },
-  cursorComponent: <LineSegment />,
-};
-
-export const useVictoryCursorContainer = (
-  initialProps: VictoryCursorContainerProps,
-) => {
-  const props = {
-    ...VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS,
-    ...(initialProps as VictoryCursorContainerMutatedProps),
-  };
-  const { children } = props;
+type ComponentClass<TProps> = { new (props: TProps): React.Component<TProps> };
+
+export function cursorContainerMixin<
+  TBase extends ComponentClass<TProps>,
+  TProps extends VictoryCursorContainerProps,
+>(Base: TBase) {
+  // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
+  return class VictoryCursorContainer extends Base {
+    static displayName = "VictoryCursorContainer";
+    static defaultProps = {
+      ...VictoryContainer.defaultProps,
+      cursorLabelComponent: <VictoryLabel />,
+      cursorLabelOffset: {
+        x: 5,
+        y: -10,
+      },
+      cursorComponent: <LineSegment />,
+    };
+    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);
+            },
+          },
+        },
+      ];
+    };
+
+    getCursorPosition(props) {
+      const { cursorValue, defaultCursorValue, domain, cursorDimension } =
+        props;
+      if (cursorValue) {
+        return cursorValue;
+      }
 
-  const getCursorPosition = () => {
-    const { cursorValue, defaultCursorValue, domain, cursorDimension } = props;
-    if (cursorValue) {
-      return cursorValue;
-    }
+      if (typeof defaultCursorValue === "number") {
+        return {
+          x: (domain.x[0] + domain.x[1]) / 2,
+          y: (domain.y[0] + domain.y[1]) / 2,
+          [cursorDimension]: defaultCursorValue,
+        };
+      }
 
-    if (typeof defaultCursorValue === "number") {
-      return {
-        x: ((domain.x[0] as number) + (domain.x[1] as number)) / 2,
-        y: ((domain.y[0] as number) + (domain.y[1] as number)) / 2,
-        ...(cursorDimension ? { [cursorDimension]: defaultCursorValue } : {}),
-      };
+      return defaultCursorValue;
     }
 
-    return defaultCursorValue;
-  };
+    getCursorLabelOffset(props) {
+      const { cursorLabelOffset } = props;
 
-  const getCursorLabelOffset = () => {
-    const { cursorLabelOffset } = props;
+      if (typeof cursorLabelOffset === "number") {
+        return {
+          x: cursorLabelOffset,
+          y: cursorLabelOffset,
+        };
+      }
 
-    if (typeof cursorLabelOffset === "number") {
-      return {
-        x: cursorLabelOffset,
-        y: cursorLabelOffset,
-      };
+      return cursorLabelOffset;
     }
 
-    return cursorLabelOffset;
-  };
-
-  const getPadding = () => {
-    if (props.padding === undefined) {
-      const child = Array.isArray(props.children)
-        ? props.children.find((c: any) => {
-            return isObject(c.props) && c.props.padding !== undefined;
-          })
-        : props.children;
-      return Helpers.getPadding(child?.props);
+    getPadding(props) {
+      if (props.padding === undefined) {
+        const child = props.children.find((c) => {
+          return isObject(c.props) && c.props.padding !== undefined;
+        });
+        return Helpers.getPadding(child.props);
+      }
+      return Helpers.getPadding(props);
     }
-    return Helpers.getPadding(props);
-  };
 
-  const getCursorElements = () => {
-    // eslint-disable-line max-statements
-    const {
-      scale,
-      cursorLabelComponent,
-      cursorLabel,
-      cursorComponent,
-      width,
-      height,
-      name,
-      horizontal,
-      theme,
-    } = props;
-    const cursorDimension = CursorHelpers.getDimension(props);
-    const cursorValue = getCursorPosition();
-    const cursorLabelOffset = getCursorLabelOffset();
-
-    if (!cursorValue) {
-      return [];
-    }
+    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: React.ReactElement[] = [];
-    const padding = getPadding();
-    const cursorCoordinates =
-      scale &&
-      "x" in scale &&
-      "y" in scale &&
-      typeof scale.y === "function" &&
-      typeof scale.x === "function"
-        ? {
-            x: horizontal ? scale.y(cursorValue.y) : scale.x(cursorValue.x),
-            y: horizontal ? scale.x(cursorValue.x) : scale.y(cursorValue.y),
-          }
-        : {
-            x: cursorValue.x,
-            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);
+      const newElements: React.ReactElement[] = [];
+      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(
+          React.cloneElement(
+            cursorLabelComponent,
+            defaults({}, labelProps, {
+              text: Helpers.evaluateProp(cursorLabel, labelProps),
+            }),
+          ),
+        );
       }
-      newElements.push(
-        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(
-        React.cloneElement(cursorComponent, {
-          key: `${name}-x-cursor`,
-          x1: cursorCoordinates.x,
-          x2: cursorCoordinates.x,
-          y1: padding.top,
-          y2: (typeof height === "number" ? height : 0) - padding.bottom,
-          style: cursorStyle,
-        }),
+      const cursorStyle = Object.assign(
+        { stroke: "black" },
+        cursorComponent.props.style,
       );
+      if (cursorDimension === "x" || cursorDimension === undefined) {
+        newElements.push(
+          React.cloneElement(cursorComponent, {
+            key: `${name}-x-cursor`,
+            x1: cursorCoordinates.x,
+            x2: cursorCoordinates.x,
+            y1: padding.top,
+            y2: height - padding.bottom,
+            style: cursorStyle,
+          }),
+        );
+      }
+      if (cursorDimension === "y" || cursorDimension === undefined) {
+        newElements.push(
+          React.cloneElement(cursorComponent, {
+            key: `${name}-y-cursor`,
+            x1: padding.left,
+            x2: width - padding.right,
+            y1: cursorCoordinates.y,
+            y2: cursorCoordinates.y,
+            style: cursorStyle,
+          }),
+        );
+      }
+      return newElements;
     }
-    if (cursorDimension === "y" || cursorDimension === undefined) {
-      newElements.push(
-        React.cloneElement(cursorComponent, {
-          key: `${name}-y-cursor`,
-          x1: padding.left,
-          x2: (typeof width === "number" ? width : 0) - padding.right,
-          y1: cursorCoordinates.y,
-          y2: cursorCoordinates.y,
-          style: cursorStyle,
-        }),
-      );
+
+    // Overrides method in VictoryContainer
+    getChildren(props) {
+      return [
+        ...React.Children.toArray(props.children),
+        ...this.getCursorElements(props),
+      ];
     }
-    return newElements;
   };
+}
 
-  return {
-    props,
-    children: [
-      ...React.Children.toArray(children),
-      ...getCursorElements(),
-    ] as React.ReactElement[],
-  };
-};
-
-export const VictoryCursorContainer = (
-  initialProps: VictoryCursorContainerProps,
-) => {
-  const { props, children } = useVictoryCursorContainer(initialProps);
-  return <VictoryContainer {...props}>{children}</VictoryContainer>;
-};
-
-VictoryCursorContainer.role = "container";
-
-VictoryCursorContainer.defaultEvents = (
-  initialProps: VictoryCursorContainerProps,
-) => {
-  const props = { ...VICTORY_CURSOR_CONTAINER_DEFAULT_PROPS, ...initialProps };
-  const createEventHandler =
-    (handler: VictoryEventHandler, disabled?: boolean): VictoryEventHandler =>
-    // eslint-disable-next-line max-params
-    (event, targetProps, eventKey, context) =>
-      disabled || props.disable
-        ? {}
-        : handler(event, { ...props, ...targetProps }, eventKey, context);
-
-  return [
-    {
-      target: "parent",
-      eventHandlers: {
-        onMouseLeave: createEventHandler(CursorHelpers.onMouseLeave),
-        onMouseMove: createEventHandler(CursorHelpers.onMouseMove),
-        onTouchMove: createEventHandler(CursorHelpers.onMouseMove),
-      },
-    },
-  ];
-};
+export const VictoryCursorContainer = cursorContainerMixin(VictoryContainer);