victory-core 36.9.2-next.3 → 36.9.2

package/es/victory-transition/victory-transition.d.ts

@@ -1,54 +1,54 @@
-import React from "react";
-import TimerContext from "../victory-util/timer-context";
-import Timer from "../victory-util/timer";
-declare type VictoryTransitionChild = React.ReactElement<{
-    polar?: boolean;
-    domain?: number[] | {
-        x: number[];
-        y: number[];
-    };
-    groupComponent?: React.ReactElement;
-}, {
-    new (props: any): React.Component<any, any>;
-    continuous?: boolean;
-}>;
-interface VictoryTransitionProps {
-    animate?: boolean | any;
-    animationWhitelist?: string[];
-    children: VictoryTransitionChild;
-}
-interface VictoryTransitionState {
-    oldProps?: VictoryTransitionProps | null;
-    nextProps?: VictoryTransitionProps;
-    nodesShouldLoad?: boolean;
-    nodesDoneLoad?: boolean;
-    nodesWillExit?: boolean;
-    nodesWillEnter?: boolean;
-    nodesShouldEnter?: boolean;
-    childrenTransitions?: unknown;
-}
-export interface VictoryTransition {
-    context: React.ContextType<typeof TimerContext>;
-}
-export declare class VictoryTransition extends React.Component<VictoryTransitionProps, VictoryTransitionState> {
-    static displayName: string;
-    static contextType: React.Context<{
-        transitionTimer: Timer;
-        animationTimer: Timer;
-    }>;
-    private continuous;
-    private timer;
-    private transitionProps;
-    constructor(props: any, context: any);
-    componentDidMount(): void;
-    shouldComponentUpdate(nextProps: VictoryTransitionProps): boolean;
-    componentWillUnmount(): void;
-    private getTransitionState;
-    private getDomainFromChildren;
-    pickProps(): Readonly<VictoryTransitionProps>;
-    private pickDomainProps;
-    getClipWidth(props: any, child: any): any;
-    render(): JSX.Element;
-}
-export {};
+import React from "react";
+import TimerContext from "../victory-util/timer-context";
+import Timer from "../victory-util/timer";
+declare type VictoryTransitionChild = React.ReactElement<{
+    polar?: boolean;
+    domain?: number[] | {
+        x: number[];
+        y: number[];
+    };
+    groupComponent?: React.ReactElement;
+}, {
+    new (props: any): React.Component<any, any>;
+    continuous?: boolean;
+}>;
+interface VictoryTransitionProps {
+    animate?: boolean | any;
+    animationWhitelist?: string[];
+    children: VictoryTransitionChild;
+}
+interface VictoryTransitionState {
+    oldProps?: VictoryTransitionProps | null;
+    nextProps?: VictoryTransitionProps;
+    nodesShouldLoad?: boolean;
+    nodesDoneLoad?: boolean;
+    nodesWillExit?: boolean;
+    nodesWillEnter?: boolean;
+    nodesShouldEnter?: boolean;
+    childrenTransitions?: unknown;
+}
+export interface VictoryTransition {
+    context: React.ContextType<typeof TimerContext>;
+}
+export declare class VictoryTransition extends React.Component<VictoryTransitionProps, VictoryTransitionState> {
+    static displayName: string;
+    static contextType: React.Context<{
+        transitionTimer: Timer;
+        animationTimer: Timer;
+    }>;
+    private continuous;
+    private timer;
+    private transitionProps;
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: VictoryTransitionProps): boolean;
+    componentWillUnmount(): void;
+    private getTransitionState;
+    private getDomainFromChildren;
+    pickProps(): Readonly<VictoryTransitionProps>;
+    private pickDomainProps;
+    getClipWidth(props: any, child: any): any;
+    render(): JSX.Element;
+}
+export {};
 //# sourceMappingURL=victory-transition.d.ts.map

package/es/victory-util/add-events.d.ts

@@ -1,127 +1,127 @@
-import React from "react";
-import type { ComponentEvent } from "./events";
-import * as Events from "./events";
-import { VictoryCommonProps, VictoryDatableProps } from "./common-props";
-import { VictoryLabelableProps } from "../types/prop-types";
-export declare type MixinOptions = {
-    components?: Array<{
-        name: string;
-        index?: string | number;
-    }>;
-};
-export interface EventMixinCommonProps extends VictoryCommonProps, VictoryDatableProps, VictoryLabelableProps {
-}
-/**
- * These methods will be implemented by the Mixin,
- * and are accessible to the Wrapped Component.
- *
- * To make your Wrapped Component type-safe, use "interface merging" like so:
- * @example
- *    interface MyComponent extends EventsMixinClass<MyProps> {}
- *    class MyComponent extends React.Component<MyProps> { ... }
- */
-export interface EventsMixinClass<TProps> {
-    renderContainer(component: React.ReactElement, children: React.ReactElement | React.ReactElement[]): React.ReactElement;
-    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
-    getEventState: typeof Events.getEventState;
-    renderData(props: TProps): any;
-    renderContinuousData(props: TProps): any;
-    animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
-    getComponentProps(component: React.ReactNode, type: string, index: string | number): TProps;
-    dataKeys: string[];
-}
-/**
- * These fields are calculated by the Mixin
- */
-export interface EventMixinCalculatedValues {
-    componentEvents: Array<ComponentEvent>;
-    getSharedEventState: (key: string, value: string) => unknown;
-    baseProps: Record<string, object>;
-    dataKeys: string[];
-    hasEvents: unknown;
-    events: unknown;
-}
-/**
- * These are the common roles that we care about internally.
- */
-export declare type VictoryComponentCommonRole = "container" | "group" | "histogram" | "label" | "line" | "portal" | "stack" | "tooltip" | "voronoi";
-/**
- * A component can have any "role",
- * but there are certain ones that we actually care about internally
- */
-export declare type VictoryComponentRole = VictoryComponentCommonRole | string;
-/**
- * Static component fields used by Victory for common behavior
- */
-export interface VictoryComponentConfiguration<TProps> {
-    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
-    role?: VictoryComponentRole;
-    expectedComponents?: Array<keyof TProps | string>;
-    getChildren?: (props: TProps, childComponents?: Array<React.ReactNode>, calculatedProps?: TProps) => void;
-    animationWhitelist?: Array<keyof TProps | string>;
-}
-/**
- * This represents the class itself, including static fields
- */
-export interface WrappedComponentClass<TProps> extends VictoryComponentConfiguration<TProps> {
-    new (props: TProps): React.Component<TProps>;
-}
-export declare function addEvents<TBase extends WrappedComponentClass<TProps>, TProps extends EventMixinCommonProps>(WrappedComponent: TBase, options?: MixinOptions): {
-    new (props: TProps): {
-        state: {};
-        getEventState: (eventKey: string | number, namespace: string, childType?: string | undefined) => any;
-        getScopedEvents: (events: any, namespace: any, childType: any, baseProps: any) => {};
-        getEvents: (p: any, target: any, eventKey: any) => any;
-        externalMutations: {} | undefined;
-        calculatedState: {};
-        globalEvents: {};
-        prevGlobalEventKeys: string[];
-        boundGlobalEvents: {};
-        shouldComponentUpdate(nextProps: TProps): boolean;
-        componentDidMount(): void;
-        componentDidUpdate(prevProps: any): void;
-        componentWillUnmount(): void;
-        addGlobalListener(key: any): void;
-        removeGlobalListener(key: any): void;
-        getStateChanges(props: any): {};
-        applyExternalMutations(props: any, externalMutations: any): void;
-        getCalculatedValues(props: any): EventMixinCalculatedValues;
-        getExternalMutations(props: TProps): {} | undefined;
-        cacheValues(obj: any): void;
-        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
-        getAllEvents(props: any): any;
-        getComponentProps(component: React.ReactNode, type: string, index: string | number): any;
-        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
-        animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
-        renderContinuousData(props: TProps): React.DetailedReactHTMLElement<any, HTMLElement>;
-        renderData(props: any, shouldRenderDatum?: (datum: any) => boolean): React.DetailedReactHTMLElement<any, HTMLElement>;
-        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>;
-        refs: {
-            [key: string]: React.ReactInstance;
-        };
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
-        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;
-        componentEvents: ComponentEvent[];
-        getSharedEventState: (key: string, value: string) => unknown;
-        baseProps: Record<string, object>;
-        dataKeys: string[];
-        hasEvents: unknown;
-        events: unknown;
-    };
-    getBaseProps?(props: TProps): Record<string, object>;
-    role?: string | undefined;
-    expectedComponents?: (string | keyof TProps)[] | undefined;
-    getChildren?: ((props: TProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: TProps | undefined) => void) | undefined;
-    animationWhitelist?: (string | keyof TProps)[] | undefined;
-} & TBase;
+import React from "react";
+import { VictoryLabelableProps } from "../types/prop-types";
+import { VictoryCommonProps, VictoryDatableProps } from "./common-props";
+import type { ComponentEvent } from "./events";
+import * as Events from "./events";
+export declare type MixinOptions = {
+    components?: Array<{
+        name: string;
+        index?: string | number;
+    }>;
+};
+export interface EventMixinCommonProps extends VictoryCommonProps, VictoryDatableProps, VictoryLabelableProps {
+}
+/**
+ * These methods will be implemented by the Mixin,
+ * and are accessible to the Wrapped Component.
+ *
+ * To make your Wrapped Component type-safe, use "interface merging" like so:
+ * @example
+ *    interface MyComponent extends EventsMixinClass<MyProps> {}
+ *    class MyComponent extends React.Component<MyProps> { ... }
+ */
+export interface EventsMixinClass<TProps> {
+    renderContainer(component: React.ReactElement, children: React.ReactElement | React.ReactElement[]): React.ReactElement;
+    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
+    getEventState: typeof Events.getEventState;
+    renderData(props: TProps): any;
+    renderContinuousData(props: TProps): any;
+    animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
+    getComponentProps(component: React.ReactNode, type: string, index: string | number): TProps;
+    dataKeys: string[];
+}
+/**
+ * These fields are calculated by the Mixin
+ */
+export interface EventMixinCalculatedValues {
+    componentEvents: Array<ComponentEvent>;
+    getSharedEventState: (key: string, value: string) => unknown;
+    baseProps: Record<string, object>;
+    dataKeys: string[];
+    hasEvents: unknown;
+    events: unknown;
+}
+/**
+ * These are the common roles that we care about internally.
+ */
+export declare type VictoryComponentCommonRole = "container" | "group" | "histogram" | "label" | "line" | "portal" | "stack" | "tooltip" | "voronoi";
+/**
+ * A component can have any "role",
+ * but there are certain ones that we actually care about internally
+ */
+export declare type VictoryComponentRole = VictoryComponentCommonRole | string;
+/**
+ * Static component fields used by Victory for common behavior
+ */
+export interface VictoryComponentConfiguration<TProps> {
+    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
+    role?: VictoryComponentRole;
+    expectedComponents?: Array<keyof TProps | string>;
+    getChildren?: (props: TProps, childComponents?: Array<React.ReactNode>, calculatedProps?: TProps) => void;
+    animationWhitelist?: Array<keyof TProps | string>;
+}
+/**
+ * This represents the class itself, including static fields
+ */
+export interface WrappedComponentClass<TProps> extends VictoryComponentConfiguration<TProps> {
+    new (props: TProps): React.Component<TProps>;
+}
+export declare function addEvents<TBase extends WrappedComponentClass<TProps>, TProps extends EventMixinCommonProps>(WrappedComponent: TBase, options?: MixinOptions): {
+    new (props: TProps): {
+        state: {};
+        getEventState: (eventKey: string | number, namespace: string, childType?: string | undefined) => any;
+        getScopedEvents: (events: any, namespace: any, childType: any, baseProps: any) => {};
+        getEvents: (p: any, target: any, eventKey: any) => any;
+        externalMutations: {} | undefined;
+        calculatedState: {};
+        globalEvents: {};
+        prevGlobalEventKeys: string[];
+        boundGlobalEvents: {};
+        shouldComponentUpdate(nextProps: TProps): boolean;
+        componentDidMount(): void;
+        componentDidUpdate(prevProps: any): void;
+        componentWillUnmount(): void;
+        addGlobalListener(key: any): void;
+        removeGlobalListener(key: any): void;
+        getStateChanges(props: any): {};
+        applyExternalMutations(props: any, externalMutations: any): void;
+        getCalculatedValues(props: any): EventMixinCalculatedValues;
+        getExternalMutations(props: TProps): {} | undefined;
+        cacheValues(obj: any): void;
+        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
+        getAllEvents(props: any): any;
+        getComponentProps(component: React.ReactNode, type: string, index: string | number): any;
+        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+        animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
+        renderContinuousData(props: TProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+        renderData(props: any, shouldRenderDatum?: (datum: any) => boolean): React.DetailedReactHTMLElement<any, HTMLElement>;
+        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>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<TProps>, prevState: Readonly<{}>): any;
+        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;
+        componentEvents: ComponentEvent[];
+        getSharedEventState: (key: string, value: string) => unknown;
+        baseProps: Record<string, object>;
+        dataKeys: string[];
+        hasEvents: unknown;
+        events: unknown;
+    };
+    getBaseProps?(props: TProps): Record<string, object>;
+    role?: string | undefined;
+    expectedComponents?: (string | keyof TProps)[] | undefined;
+    getChildren?: ((props: TProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: TProps | undefined) => void) | undefined;
+    animationWhitelist?: (string | keyof TProps)[] | undefined;
+} & TBase;
 //# sourceMappingURL=add-events.d.ts.map

package/es/victory-util/add-events.js

@@ -1,6 +1,5 @@
 import _pick from "lodash/pick";
 import _isEmpty from "lodash/isEmpty";
-import _difference from "lodash/difference";
 import _defaults from "lodash/defaults";
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -36,9 +35,10 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 import React from "react";
-import * as Events from "./events";
 import isEqual from "react-fast-compare";
 import { VictoryTransition } from "../victory-transition/victory-transition";
+import { difference } from "./collection";
+import * as Events from "./events";
 import { isFunction, isNil } from "./helpers"; // DISCLAIMER:
 // This file is not currently tested, and it is first on the list of files
 // to refactor in our current refactoring effort. Please do not make changes
@@ -139,15 +139,11 @@ export function addEvents(WrappedComponent) {
         var calculatedState = this.getStateChanges(prevProps);
         this.calculatedState = calculatedState;
         var globalEventKeys = Object.keys(this.globalEvents);
-
-        var removedGlobalEventKeys = _difference(this.prevGlobalEventKeys, globalEventKeys);
-
+        var removedGlobalEventKeys = difference(this.prevGlobalEventKeys, globalEventKeys);
         removedGlobalEventKeys.forEach(function (key) {
           return _this3.removeGlobalListener(key);
         });
-
-        var addedGlobalEventKeys = _difference(globalEventKeys, this.prevGlobalEventKeys);
-
+        var addedGlobalEventKeys = difference(globalEventKeys, this.prevGlobalEventKeys);
         addedGlobalEventKeys.forEach(function (key) {
           return _this3.addGlobalListener(key);
         });

package/es/victory-util/axis.d.ts

@@ -1,51 +1,51 @@
-import { D3Scale } from "../types/prop-types";
-/**
- * Returns the axis (x or y) of a particular axis component
- * @param {Object} props: the props object.
- * @param {Boolean} horizontal: true for horizontal charts
- * @returns {String} the dimension appropriate for the axis given its props
- */
-export declare function getAxis(props: any): "x" | "y";
-/**
- * Returns all axis components that pass a given predicate
- * @param {Array} childComponents: an array of children
- * @param {Function} predicate: a predicate function that will be called with each
- * @returns {Array} all axis components that pass the given predicate or []
- */
-export declare function findAxisComponents(childComponents: any, predicate?: any): any;
-/**
- * Returns a single axis component of the desired axis type (x or y)
- * @param {Array} childComponents: an array of children
- * @param {String} axis: desired axis either "x" or "y".
- * @returns {ReactComponent} an axis component of the desired axis or undefined
- */
-export declare function getAxisComponent(childComponents: any, axis: any): any;
-/**
- * Returns all axis components of the desired axis type (x or y) along with any
- * parent components excluding VictoryChart
- * @param {Array} childComponents: an optional array of children.
- * @param {String} type: desired axis either "dependent" or "independent".
- * @returns {ReactComponent} an axis component of the desired type or undefined
- */
-export declare function getAxisComponentsWithParent(childComponents: any, type: any): any;
-export declare function getOrigin(domain: any): {
-    x: number | Date;
-    y: number | Date;
-};
-export declare function getOriginSign(origin: any, domain: any): "positive" | "negative";
-/**
- * @param {Object} props: axis component props
- * @returns {Boolean} true when the axis is vertical
- */
-export declare function isVertical(props: any): any;
-/**
- * @param {Object} props: axis component props
- * @returns {Boolean} true when tickValues contain strings
- */
-export declare function stringTicks(props: any): boolean;
-export declare function getTickFormat(props: any, scale: any): any;
-export declare function getTicks(props: any, scale: D3Scale, filterZero?: boolean): number[] | string[];
-export declare function getDomain(props: any, axis?: any): any;
-export declare function getAxisValue(props: any, axis: any): any;
-export declare function modifyProps(props: any, fallbackProps: any): any;
+import { D3Scale } from "../types/prop-types";
+/**
+ * Returns the axis (x or y) of a particular axis component
+ * @param {Object} props: the props object.
+ * @param {Boolean} horizontal: true for horizontal charts
+ * @returns {String} the dimension appropriate for the axis given its props
+ */
+export declare function getAxis(props: any): "x" | "y";
+/**
+ * Returns all axis components that pass a given predicate
+ * @param {Array} childComponents: an array of children
+ * @param {Function} predicate: a predicate function that will be called with each
+ * @returns {Array} all axis components that pass the given predicate or []
+ */
+export declare function findAxisComponents(childComponents: any, predicate?: any): any;
+/**
+ * Returns a single axis component of the desired axis type (x or y)
+ * @param {Array} childComponents: an array of children
+ * @param {String} axis: desired axis either "x" or "y".
+ * @returns {ReactComponent} an axis component of the desired axis or undefined
+ */
+export declare function getAxisComponent(childComponents: any, axis: any): any;
+/**
+ * Returns all axis components of the desired axis type (x or y) along with any
+ * parent components excluding VictoryChart
+ * @param {Array} childComponents: an optional array of children.
+ * @param {String} type: desired axis either "dependent" or "independent".
+ * @returns {ReactComponent} an axis component of the desired type or undefined
+ */
+export declare function getAxisComponentsWithParent(childComponents: any, type: any): any;
+export declare function getOrigin(domain: any): {
+    x: number | Date;
+    y: number | Date;
+};
+export declare function getOriginSign(origin: any, domain: any): "positive" | "negative";
+/**
+ * @param {Object} props: axis component props
+ * @returns {Boolean} true when the axis is vertical
+ */
+export declare function isVertical(props: any): any;
+/**
+ * @param {Object} props: axis component props
+ * @returns {Boolean} true when tickValues contain strings
+ */
+export declare function stringTicks(props: any): boolean;
+export declare function getTickFormat(props: any, scale: any): any;
+export declare function getTicks(props: any, scale: D3Scale, filterZero?: boolean): number[] | string[];
+export declare function getDomain(props: any, axis?: any): any;
+export declare function getAxisValue(props: any, axis: any): any;
+export declare function modifyProps(props: any, fallbackProps: any): any;
 //# sourceMappingURL=axis.d.ts.map

package/es/victory-util/axis.js

@@ -1,8 +1,6 @@
 import _orderBy from "lodash/orderBy";
 import _uniq from "lodash/uniq";
-import _invert from "lodash/invert";
 import _isObject from "lodash/isObject";
-import _identity from "lodash/identity";
 import _defaults from "lodash/defaults";
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -22,12 +20,22 @@ import * as Collection from "./collection";
 import * as Domain from "./domain";
 import * as Helpers from "./helpers";
 
+/**
+ * Returns the first argument it receives
+ * @param value The value to return
+ * @returns The value given
+ */
+function identity(value) {
+  return value;
+}
 /**
  * Returns the axis (x or y) of a particular axis component
  * @param {Object} props: the props object.
  * @param {Boolean} horizontal: true for horizontal charts
  * @returns {String} the dimension appropriate for the axis given its props
  */
+
+
 export function getAxis(props) {
   var dependentAxis = props.dependentAxis;
   return dependentAxis ? "y" : "x";
@@ -40,7 +48,7 @@ export function getAxis(props) {
  */
 
 export function findAxisComponents(childComponents, predicate) {
-  var predicateFunction = predicate || _identity;
+  var predicateFunction = predicate || identity;
 
   var findAxes = function (children) {
     return children.reduce(function (memo, child) {
@@ -156,7 +164,7 @@ function getDefaultTickFormat(props) {
     } : fallbackFormat;
   }
 
-  var invertedStringMap = stringMap && _invert(stringMap);
+  var invertedStringMap = stringMap && Helpers.invert(stringMap);
 
   var tickValueArray = _orderBy(Object.values(stringMap), function (n) {
     return n;
@@ -274,8 +282,7 @@ export function getTickFormat(props, scale) {
     };
   } else if (tickFormat && Helpers.isFunction(tickFormat)) {
     var applyStringTicks = function (tick, index, ticks) {
-      var invertedStringMap = _invert(stringMap);
-
+      var invertedStringMap = Helpers.invert(stringMap);
       var stringTickArray = ticks.map(function (t) {
         return invertedStringMap[t];
       });

package/es/victory-util/collection.d.ts

@@ -1,9 +1,16 @@
-export declare function containsStrings<T>(collection: Array<T>): boolean;
-export declare function containsDates(collection: Array<number | Date>): boolean;
-export declare function containsNumbers(collection: any): boolean;
-export declare function containsOnlyStrings(collection: Array<string> | unknown): collection is Array<string>;
-export declare function isArrayOfArrays<T>(collection: Array<T> | Array<Array<T>> | unknown): collection is Array<Array<T>>;
-export declare function removeUndefined(arr: any): any;
-export declare function getMaxValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
-export declare function getMinValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
+export declare function containsStrings<T>(collection: Array<T>): boolean;
+export declare function containsDates(collection: Array<number | Date>): boolean;
+export declare function containsNumbers(collection: any): boolean;
+export declare function containsOnlyStrings(collection: Array<string> | unknown): collection is Array<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
+ */
+export declare function difference<T>(a: Array<T>, b: Array<T>): Array<T>;
+export declare function isArrayOfArrays<T>(collection: Array<T> | Array<Array<T>> | unknown): collection is Array<Array<T>>;
+export declare function removeUndefined(arr: any): any;
+export declare function getMaxValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
+export declare function getMinValue(arr: Array<number | Date>, ...values: Array<number | Date>): number | Date;
 //# sourceMappingURL=collection.d.ts.map

package/es/victory-util/collection.js

@@ -34,6 +34,22 @@ export 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
+ */
+
+export function difference(a, b) {
+  if (a && b) {
+    return a.filter(function (value) {
+      return !b.includes(value);
+    });
+  }
+
+  return [];
+}
 export function isArrayOfArrays(collection) {
   return isNonEmptyArray(collection) && collection.every(Array.isArray);
 }