victory-core 37.3.1 → 37.3.3

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

@@ -1,7 +1,7 @@
 import React from "react";
 import TimerContext from "../victory-util/timer-context";
 import Timer from "../victory-util/timer";
-declare type VictoryTransitionChild = React.ReactElement<{
+type VictoryTransitionChild = React.ReactElement<{
     polar?: boolean;
     domain?: number[] | {
         x: number[];

package/es/victory-transition/victory-transition.js

@@ -1,13 +1,13 @@
-import _pick from "lodash/pick";
-import _defaults from "lodash/defaults";
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 import React from "react";
+import defaults from "lodash/defaults";
+import pick from "lodash/pick";
+import isEqual from "react-fast-compare";
 import { VictoryAnimation } from "../victory-animation/victory-animation";
 import * as Collection from "../victory-util/collection";
 import * as Helpers from "../victory-util/helpers";
 import TimerContext from "../victory-util/timer-context";
 import * as Transitions from "../victory-util/transitions";
-import isEqual from "react-fast-compare";
 export class VictoryTransition extends React.Component {
   static displayName = "VictoryTransition";
   static contextType = TimerContext;
@@ -25,7 +25,7 @@ export class VictoryTransition extends React.Component {
   componentDidMount() {
     this.setState({
       nodesShouldLoad: true
-    }); // eslint-disable-line react/no-did-mount-set-state
+    });
   }
   shouldComponentUpdate(nextProps) {
     if (!isEqual(this.props, nextProps)) {
@@ -121,13 +121,13 @@ export class VictoryTransition extends React.Component {
       y: this.getDomainFromChildren(props, "y")
     };
     const clipWidth = this.getClipWidth(props, child);
-    const combinedProps = _defaults({
+    const combinedProps = defaults({
       domain,
       clipWidth
     }, transitionProps, child.props);
     const animationWhitelist = props.animationWhitelist || [];
     const whitelist = animationWhitelist.concat(["clipWidth"]);
-    const propsToAnimate = whitelist.length ? _pick(combinedProps, whitelist) : combinedProps;
+    const propsToAnimate = whitelist.length ? pick(combinedProps, whitelist) : combinedProps;
     return /*#__PURE__*/React.createElement(VictoryAnimation, _extends({}, combinedProps.animate, {
       data: propsToAnimate
     }), newProps => {
@@ -135,13 +135,13 @@ export class VictoryTransition extends React.Component {
         const groupComponent = this.continuous ? /*#__PURE__*/React.cloneElement(child.props.groupComponent, {
           clipWidth: newProps.clipWidth || 0
         }) : child.props.groupComponent;
-        return /*#__PURE__*/React.cloneElement(child, _defaults({
+        return /*#__PURE__*/React.cloneElement(child, defaults({
           animate: null,
           animating: true,
           groupComponent
         }, newProps, combinedProps));
       }
-      return /*#__PURE__*/React.cloneElement(child, _defaults({
+      return /*#__PURE__*/React.cloneElement(child, defaults({
         animate: null,
         animating: true
       }, newProps, combinedProps));

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

@@ -3,7 +3,7 @@ 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 = {
+export type MixinOptions = {
     components?: Array<{
         name: string;
         index?: string | number;
@@ -24,7 +24,7 @@ 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;
+    renderData(props: TProps, shouldRenderDatum?: () => boolean): any;
     renderContinuousData(props: TProps): any;
     animateComponent(props: TProps, defaultAnimationWhitelist: string[]): React.ReactElement;
     getComponentProps(component: React.ReactNode, type: string, index: string | number): TProps;
@@ -44,12 +44,12 @@ export interface EventMixinCalculatedValues {
 /**
  * These are the common roles that we care about internally.
  */
-export declare type VictoryComponentCommonRole = "container" | "group" | "histogram" | "label" | "line" | "portal" | "stack" | "tooltip" | "voronoi";
+export 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;
+export type VictoryComponentRole = VictoryComponentCommonRole | string;
 /**
  * Static component fields used by Victory for common behavior
  */
@@ -111,17 +111,17 @@ export declare function addEvents<TBase extends WrappedComponentClass<TProps>, T
         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[];
+        componentEvents: Array<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;
+    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
+    role?: VictoryComponentRole;
     expectedComponents?: (string | keyof TProps)[] | undefined;
-    getChildren?: ((props: TProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: TProps | undefined) => void) | undefined;
+    getChildren?: ((props: TProps, childComponents?: Array<React.ReactNode>, 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,7 +1,7 @@
-import _pick from "lodash/pick";
-import _isEmpty from "lodash/isEmpty";
-import _defaults from "lodash/defaults";
 import React from "react";
+import defaults from "lodash/defaults";
+import isEmpty from "lodash/isEmpty";
+import pick from "lodash/pick";
 import isEqual from "react-fast-compare";
 import { VictoryTransition } from "../victory-transition/victory-transition";
 import { difference } from "./collection";
@@ -61,7 +61,7 @@ const defaultComponents = [{
 export function addEvents(WrappedComponent, options) {
   if (options === void 0) {
     options = {};
-  } // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  } // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
   class AddEventsMixin extends WrappedComponent {
     constructor(props) {
@@ -138,8 +138,8 @@ export function addEvents(WrappedComponent, options) {
         return {};
       }
       const getState = (key, type) => {
-        const result = _defaults({}, this.getEventState(key, type), this.getSharedEventState(key, type));
-        return _isEmpty(result) ? undefined : result;
+        const result = defaults({}, this.getEventState(key, type), this.getSharedEventState(key, type));
+        return isEmpty(result) ? undefined : result;
       };
       const components = options.components || defaultComponents;
       const stateChanges = components.map(component => {
@@ -152,7 +152,7 @@ export function addEvents(WrappedComponent, options) {
       return stateChanges;
     }
     applyExternalMutations(props, externalMutations) {
-      if (!_isEmpty(externalMutations)) {
+      if (!isEmpty(externalMutations)) {
         const callbacks = props.externalEventMutations.reduce((memo, mutation) => isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo, []);
         const compiledCallbacks = callbacks.length ? () => {
           callbacks.forEach(c => c());
@@ -185,7 +185,7 @@ export function addEvents(WrappedComponent, options) {
         sharedEvents,
         externalEventMutations
       } = props;
-      return _isEmpty(externalEventMutations) || sharedEvents ? undefined : Events.getExternalMutations(externalEventMutations, this.baseProps, this.state);
+      return isEmpty(externalEventMutations) || sharedEvents ? undefined : Events.getExternalMutations(externalEventMutations, this.baseProps, this.state);
     }
     cacheValues(obj) {
       Object.keys(obj).forEach(key => {
@@ -196,10 +196,10 @@ export function addEvents(WrappedComponent, options) {
       const getSharedEventStateFunction = getSharedEventState || this.getSharedEventState.bind(this);
       const sharedParentState = getSharedEventStateFunction("parent", "parent");
       const parentState = this.getEventState("parent", "parent");
-      const baseParentProps = _defaults({}, parentState, sharedParentState);
+      const baseParentProps = defaults({}, parentState, sharedParentState);
       const parentPropsList = baseParentProps.parentControlledProps;
-      const parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
-      const modifiedProps = _defaults({}, parentProps, props);
+      const parentProps = parentPropsList ? pick(baseParentProps, parentPropsList) : {};
+      const modifiedProps = defaults({}, parentProps, props);
       return typeof WrappedComponent.getBaseProps === "function" ? WrappedComponent.getBaseProps(modifiedProps) : {};
     }
     getAllEvents(props) {
@@ -219,18 +219,18 @@ export function addEvents(WrappedComponent, options) {
       const currentProps = component && typeof component === "object" && "props" in component ? component.props : undefined;
       if (this.hasEvents) {
         const baseEvents = this.getEvents(this.props, type, key);
-        const componentProps = _defaults({
+        const componentProps = defaults({
           index,
           key: id
         }, this.getEventState(key, type), this.getSharedEventState(key, type), currentProps, baseProps, {
           id
         });
-        const events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
+        const events = defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
         return Object.assign({}, componentProps, {
           events
         });
       }
-      return _defaults({
+      return defaults({
         index,
         key: id
       }, currentProps, baseProps, {

package/es/victory-util/axis.js

@@ -1,8 +1,8 @@
-import _orderBy from "lodash/orderBy";
-import _uniq from "lodash/uniq";
-import _isObject from "lodash/isObject";
-import _defaults from "lodash/defaults";
 import React from "react";
+import defaults from "lodash/defaults";
+import isObject from "lodash/isObject";
+import uniq from "lodash/uniq";
+import orderBy from "lodash/orderBy";
 import * as Collection from "./collection";
 import * as Domain from "./domain";
 import * as Helpers from "./helpers";
@@ -138,7 +138,7 @@ function getDefaultTickFormat(props) {
     return stringTicks(props) ? (x, index) => tickValues[index] : fallbackFormat;
   }
   const invertedStringMap = stringMap && Helpers.invert(stringMap);
-  const tickValueArray = _orderBy(Object.values(stringMap), n => n);
+  const tickValueArray = orderBy(Object.values(stringMap), n => n);
   const dataNames = tickValueArray.map(tick => invertedStringMap[tick]);
   // string ticks should have one tick of padding at the beginning
   const dataTicks = ["", ...dataNames, ""];
@@ -175,14 +175,14 @@ function getTickArray(props) {
   if (tickValues && Collection.containsStrings(tickValues)) {
     ticks = stringMap ? tickValues.map(tick => stringMap[tick]) : Helpers.range(1, tickValues.length + 1);
   }
-  const tickArray = ticks ? _uniq(ticks) : getTicksFromFormat();
+  const tickArray = ticks ? uniq(ticks) : getTicksFromFormat();
   const buildTickArray = arr => {
     const newTickArray = [];
     const domain = props.domain && props.domain[axis] || props.domain;
     if (arr) {
       arr.forEach((t, index) => {
         if (Array.isArray(domain)) {
-          if (t >= Collection.getMinValue(domain) && t <= Collection.getMaxValue(domain)) {
+          if (t >= Collection.getMinValue(domain).valueOf() && t <= Collection.getMaxValue(domain).valueOf()) {
             newTickArray.push({
               value: t,
               index
@@ -271,7 +271,7 @@ export function getTicks(props, scale, filterZero) {
  * @param {String} axis: either x or y
  * @returns {Array} returns a domain from tickValues
  */
-// eslint-disable-next-line max-statements
+
 function getDomainFromData(props, axis) {
   const {
     polar,
@@ -312,17 +312,17 @@ export function getAxisValue(props, axis) {
     return undefined;
   }
   const scaleAxis = axis === "x" ? "y" : "x";
-  const scale = _isObject(props.scale) && Helpers.isFunction(props.scale[scaleAxis]) ? props.scale[scaleAxis] : undefined;
+  const scale = isObject(props.scale) && Helpers.isFunction(props.scale[scaleAxis]) ? props.scale[scaleAxis] : undefined;
   if (!scale) {
     return undefined;
   }
   const stringMapAxis = axis === "x" ? "y" : "x";
-  const stringMap = _isObject(props.stringMap) && props.stringMap[stringMapAxis];
+  const stringMap = isObject(props.stringMap) && props.stringMap[stringMapAxis];
   const axisValue = stringMap && typeof props.axisValue === "string" ? stringMap[props.axisValue] : props.axisValue;
   return scale(axisValue);
 }
 export function modifyProps(props, fallbackProps) {
-  if (!_isObject(props.theme)) {
+  if (!isObject(props.theme)) {
     return Helpers.modifyProps(props, fallbackProps, "axis");
   }
   let role = "axis";
@@ -334,7 +334,7 @@ export function modifyProps(props, fallbackProps) {
   if (role === "axis") {
     return Helpers.modifyProps(props, fallbackProps, "axis");
   }
-  const axisTheme = _defaults({}, props.theme[role], props.theme.axis);
+  const axisTheme = defaults({}, props.theme[role], props.theme.axis);
   const theme = Object.assign({}, props.theme, {
     axis: axisTheme
   });

package/es/victory-util/data.js

@@ -1,13 +1,12 @@
-import _omitBy from "lodash/omitBy";
-import _isUndefined from "lodash/isUndefined";
-import _isEqual from "lodash/isEqual";
-import _isEmpty from "lodash/isEmpty";
-import _orderBy from "lodash/orderBy";
-import _property from "lodash/property";
-import _isPlainObject from "lodash/isPlainObject";
-import _uniq from "lodash/uniq";
-/* eslint-disable no-use-before-define */
 import React from "react";
+import isEmpty from "lodash/isEmpty";
+import isEqual from "lodash/isEqual";
+import isPlainObject from "lodash/isPlainObject";
+import isUndefined from "lodash/isUndefined";
+import omitBy from "lodash/omitBy";
+import orderBy from "lodash/orderBy";
+import property from "lodash/property";
+import uniq from "lodash/uniq";
 import * as Helpers from "./helpers";
 import * as Collection from "./collection";
 import * as Scale from "./scale";
@@ -28,7 +27,7 @@ function getLength(data) {
 
 // Returns generated data for a given axis based on domain and sample from props
 function generateDataArray(props, axis) {
-  const propsDomain = _isPlainObject(props.domain) ? props.domain[axis] : props.domain;
+  const propsDomain = isPlainObject(props.domain) ? props.domain[axis] : props.domain;
   const domain = propsDomain || Scale.getBaseScale(props, axis).domain();
   const samples = props.samples || 1;
   const domainMax = Math.max(...domain);
@@ -53,7 +52,7 @@ function sortData(dataset, sortKey, sortOrder) {
     formattedSortKey = `_${sortKey}`;
   }
   const order = sortOrder === "ascending" ? "asc" : "desc";
-  return _orderBy(dataset, formattedSortKey, order);
+  return orderBy(dataset, formattedSortKey, order);
 }
 
 // This method will remove data points that break certain scales. (log scale only)
@@ -97,7 +96,7 @@ function getEventKey(key) {
     return () => undefined;
   }
   // otherwise, assume it is an array index, property key or path (_.property handles all three)
-  return _property(key);
+  return property(key);
 }
 
 // Returns data with an eventKey prop added to each datum
@@ -132,8 +131,6 @@ export function formatDataFromDomain(dataset, domain, defaultBaseline) {
   const isUnderMinY = underMin(minDomainY);
   const isOverMaxX = overMax(maxDomainX);
   const isOverMaxY = overMax(maxDomainY);
-
-  // eslint-disable-next-line complexity
   return dataset.map(datum => {
     let {
       _x,
@@ -158,12 +155,12 @@ export function formatDataFromDomain(dataset, domain, defaultBaseline) {
     if (isUnderMinY(baseline) && !isUnderMinY(value)) _y0 = minDomainY;
     // baseline and value with only baseline above max, set baseline to maxDomainY
     if (isOverMaxY(baseline) && !isOverMaxY(value)) _y0 = maxDomainY;
-    return Object.assign({}, datum, _omitBy({
+    return Object.assign({}, datum, omitBy({
       _x,
       _y,
       _y0,
       _y1
-    }, _isUndefined));
+    }, isUndefined));
   });
 }
 
@@ -177,7 +174,7 @@ export function createStringMap(props, axis) {
   const stringsFromAxes = getStringsFromAxes(props, axis);
   const stringsFromCategories = getStringsFromCategories(props, axis);
   const stringsFromData = getStringsFromData(props, axis);
-  const allStrings = _uniq([...stringsFromAxes, ...stringsFromCategories, ...stringsFromData]);
+  const allStrings = uniq([...stringsFromAxes, ...stringsFromCategories, ...stringsFromData]);
   return allStrings.length === 0 ? null : allStrings.reduce((memo, string, index) => {
     memo[string] = index + 1;
     return memo;
@@ -233,7 +230,7 @@ export function formatData(dataset, props, expectedKeys) {
     memo[type] = createAccessor(type);
     return memo;
   }, {});
-  const preformattedData = _isEqual(expectedKeys, defaultKeys) && props.x === "_x" && props.y === "_y" && props.y0 === "_y0";
+  const preformattedData = isEqual(expectedKeys, defaultKeys) && props.x === "_x" && props.y === "_y" && props.y0 === "_y0";
   let stringMap;
   if (preformattedData === false) {
     // stringMap is not required if the data is preformatted
@@ -244,7 +241,6 @@ export function formatData(dataset, props, expectedKeys) {
     };
   }
   const data = preformattedData ? dataset : dataset.reduce((dataArr, datum, index) => {
-    // eslint-disable-line complexity
     const parsedDatum = parseDatum(datum);
     const fallbackValues = {
       x: index,
@@ -264,7 +260,7 @@ export function formatData(dataset, props, expectedKeys) {
       return memo;
     }, {});
     const formattedDatum = Object.assign({}, processedValues, parsedDatum);
-    if (!_isEmpty(formattedDatum)) {
+    if (!isEmpty(formattedDatum)) {
       dataArr.push(formattedDatum);
     }
     return dataArr;

package/es/victory-util/domain.js

@@ -1,8 +1,7 @@
-import _isDate from "lodash/isDate";
-import _sortedUniq from "lodash/sortedUniq";
-import _isPlainObject from "lodash/isPlainObject";
-/* eslint-disable no-use-before-define */
 import React from "react";
+import isDate from "lodash/isDate";
+import isPlainObject from "lodash/isPlainObject";
+import sortedUniq from "lodash/sortedUniq";
 import * as Data from "./data";
 import * as Scale from "./scale";
 import * as Helpers from "./helpers";
@@ -33,7 +32,7 @@ function getDomainPadding(props, axis) {
       right: padding
     };
   };
-  return _isPlainObject(props.domainPadding) ? formatPadding(props.domainPadding[axis]) : formatPadding(props.domainPadding);
+  return isPlainObject(props.domainPadding) ? formatPadding(props.domainPadding[axis]) : formatPadding(props.domainPadding);
 }
 function getFlatData(dataset, axis) {
   const axisKey = `_${axis}`;
@@ -57,8 +56,6 @@ function getExtremeFromData(dataset, axis, type) {
   }, initialValue);
   return containsDate ? new Date(result) : result;
 }
-
-// eslint-disable-next-line max-statements
 function padDomain(domain, props, axis) {
   if (!props.domainPadding) {
     return domain;
@@ -84,10 +81,10 @@ function padDomain(domain, props, axis) {
     min: min.valueOf() - simplePadding.left,
     max: max.valueOf() + simplePadding.right
   };
-  const singleQuadrantDomainPadding = _isPlainObject(props.singleQuadrantDomainPadding) ? props.singleQuadrantDomainPadding[axis] : props.singleQuadrantDomainPadding;
-  const addsQuadrants = min >= 0 && paddedDomain.min <= 0 || max <= 0 && paddedDomain.max >= 0;
+  const singleQuadrantDomainPadding = isPlainObject(props.singleQuadrantDomainPadding) ? props.singleQuadrantDomainPadding[axis] : props.singleQuadrantDomainPadding;
+  const addsQuadrants = min.valueOf() >= 0 && paddedDomain.min <= 0 || max.valueOf() <= 0 && paddedDomain.max >= 0;
   const adjust = (val, type) => {
-    const coerce = type === "min" && min >= 0 && val <= 0 || type === "max" && max <= 0 && val >= 0;
+    const coerce = type === "min" && min.valueOf() >= 0 && val <= 0 || type === "max" && max.valueOf() <= 0 && val >= 0;
     return coerce ? 0 : val;
   };
   if (addsQuadrants && singleQuadrantDomainPadding !== false) {
@@ -256,7 +253,7 @@ export function getDomainFromMinMax(min, max) {
 export function getDomainFromProps(props, axis) {
   const minDomain = getMinFromProps(props, axis);
   const maxDomain = getMaxFromProps(props, axis);
-  if (_isPlainObject(props.domain) && props.domain[axis]) {
+  if (isPlainObject(props.domain) && props.domain[axis]) {
     return props.domain[axis];
   } else if (Array.isArray(props.domain)) {
     return props.domain;
@@ -307,10 +304,10 @@ export function getDomainWithZero(props, axis) {
  * @returns {Number|Date|undefined} the maxDomain based on props
  */
 export function getMaxFromProps(props, axis) {
-  if (_isPlainObject(props.maxDomain) && props.maxDomain[axis] !== undefined) {
+  if (isPlainObject(props.maxDomain) && props.maxDomain[axis] !== undefined) {
     return props.maxDomain[axis];
   }
-  return typeof props.maxDomain === "number" || _isDate(props.maxDomain) ? props.maxDomain : undefined;
+  return typeof props.maxDomain === "number" || isDate(props.maxDomain) ? props.maxDomain : undefined;
 }
 
 /**
@@ -320,10 +317,10 @@ export function getMaxFromProps(props, axis) {
  * @returns {Number|Date|undefined} the minDomain based on props
  */
 export function getMinFromProps(props, axis) {
-  if (_isPlainObject(props.minDomain) && props.minDomain[axis] !== undefined) {
+  if (isPlainObject(props.minDomain) && props.minDomain[axis] !== undefined) {
     return props.minDomain[axis];
   }
-  return typeof props.minDomain === "number" || _isDate(props.minDomain) ? props.minDomain : undefined;
+  return typeof props.minDomain === "number" || isDate(props.minDomain) ? props.minDomain : undefined;
 }
 
 /**
@@ -334,7 +331,7 @@ export function getMinFromProps(props, axis) {
  * @returns {Array} the symmetric domain
  */
 export function getSymmetricDomain(domain, values) {
-  const processedData = _sortedUniq(values.sort((a, b) => a - b));
+  const processedData = sortedUniq(values.sort((a, b) => a - b));
   const step = processedData[1] - processedData[0];
   return [domain[0], domain[1] + step];
 }

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

@@ -1,17 +1,17 @@
-/// <reference types="react" />
+import React from "react";
 import type { EventMixinCalculatedValues } from "./add-events";
-declare type ComponentEventKey = string | number;
+type ComponentEventKey = string | number;
 export interface ComponentEvent {
     target?: "parent" | string;
     eventKey?: ComponentEventKey | ComponentEventKey[];
     eventHandlers: ComponentEventHandlers;
 }
-export declare type ComponentEventName = string;
+export type ComponentEventName = string;
 export interface ComponentEventHandlers {
     [k: ComponentEventName]: ComponentEventHandler;
 }
-export declare type ComponentEventHandler = (evt: React.SyntheticEvent, childProps: unknown, eventKey: ComponentEventKey, eventName: ComponentEventName) => UpdatedProps;
-export declare type UpdatedProps = any;
+export type ComponentEventHandler = (evt: React.SyntheticEvent, childProps: unknown, eventKey: ComponentEventKey, eventName: ComponentEventName) => UpdatedProps;
+export type UpdatedProps = any;
 interface ComponentWithEvents extends EventMixinCalculatedValues {
     state: any;
     setState: any;

package/es/victory-util/events.js

@@ -1,8 +1,7 @@
-import _uniq from "lodash/uniq";
-import _omitBy from "lodash/omitBy";
-import _pickBy from "lodash/pickBy";
-import _isEmpty from "lodash/isEmpty";
-/* eslint-disable no-use-before-define */
+import isEmpty from "lodash/isEmpty";
+import pickBy from "lodash/pickBy";
+import omitBy from "lodash/omitBy";
+import uniq from "lodash/uniq";
 import { isFunction } from "./helpers";
 const GLOBAL_EVENT_REGEX = /^onGlobal(.*)$/;
 
@@ -50,11 +49,10 @@ getScopedEvents) {
    */
   const getAllEvents = () => {
     // Mandatory usage: `getEvents.bind(this)`
-    /* eslint-disable no-invalid-this */
+
     if (Array.isArray(this.componentEvents)) {
       return Array.isArray(props.events) ? this.componentEvents.concat(...props.events) : this.componentEvents;
     }
-    /* eslint-enable no-invalid-this */
     return props.events;
   };
   const allEvents = getAllEvents();
@@ -74,12 +72,12 @@ getScopedEvents) {
  */
 // eslint-disable-next-line max-params
 export function getScopedEvents(events, namespace, childType, baseProps) {
-  if (_isEmpty(events)) {
+  if (isEmpty(events)) {
     return {};
   }
 
   // Mandatory usage: `getScopedEvents.bind(this)`
-  // eslint-disable-next-line no-invalid-this
+
   const newBaseProps = baseProps || this.baseProps;
   // returns the original base props or base state of a given target element
   const getTargetProps = (identifier, type) => {
@@ -88,7 +86,6 @@ export function getScopedEvents(events, namespace, childType, baseProps) {
       target,
       key
     } = identifier;
-    // eslint-disable-next-line no-invalid-this
     const baseType = type === "props" ? newBaseProps : this.state || {};
     const base = childName === undefined || childName === null || !baseType[childName] ? baseType : baseType[childName];
     return key === "parent" ? base.parent : base[key] && base[key][target];
@@ -115,7 +112,6 @@ export function getScopedEvents(events, namespace, childType, baseProps) {
 
     // returns the state object with mutated props applied for a single key
     const getMutationObject = (key, childName) => {
-      // eslint-disable-next-line no-invalid-this
       const baseState = this.state || {};
       if (!isFunction(eventReturn.mutation)) {
         return baseState;
@@ -188,11 +184,9 @@ export function getScopedEvents(events, namespace, childType, baseProps) {
   // into a state mutation, and calls setState
   // eslint-disable-next-line max-params
   const onEvent = (evt, childProps, eventKey, eventName) => {
-    // eslint-disable-next-line no-invalid-this
     const eventReturn = events[eventName](evt, childProps, eventKey, this);
-    if (!_isEmpty(eventReturn)) {
+    if (!isEmpty(eventReturn)) {
       const callbacks = compileCallbacks(eventReturn);
-      // eslint-disable-next-line no-invalid-this
       this.setState(parseEventReturn(eventReturn, eventKey), callbacks);
     }
   };
@@ -222,7 +216,7 @@ export function getPartialEvents(events, eventKey, childProps) {
 // eslint-disable-next-line max-params
 export function getEventState(eventKey, namespace, childType) {
   // Mandatory usage: `getEventState.bind(this)`
-  // eslint-disable-next-line no-invalid-this
+
   const state = this.state || {};
   if (!childType) {
     return eventKey === "parent" ? state[eventKey] && state[eventKey][namespace] || state[eventKey] : state[eventKey] && state[eventKey][namespace];
@@ -252,7 +246,7 @@ export function getExternalMutationsWithChildren(mutations, baseProps, baseState
     const childState = baseState[childName];
     const mutation = getExternalMutations(mutations, baseProps[childName], baseState[childName], childName);
     memo[childName] = mutation ? mutation : childState;
-    return _pickBy(memo, v => !_isEmpty(v));
+    return pickBy(memo, v => !isEmpty(v));
   }, {});
 }
 
@@ -288,7 +282,7 @@ export function getExternalMutations(mutations, baseProps, baseState, childName)
     } else {
       // use keys from both state and props so that elements not intially included in baseProps
       // will be used. (i.e. labels)
-      const targets = _uniq(Object.keys(keyProps).concat(Object.keys(keyState)));
+      const targets = uniq(Object.keys(keyProps).concat(Object.keys(keyState)));
       memo[eventKey] = targets.reduce((m, target) => {
         const identifier = {
           eventKey,
@@ -297,10 +291,10 @@ export function getExternalMutations(mutations, baseProps, baseState, childName)
         };
         const mutation = getExternalMutation(mutations, keyProps[target], keyState[target], identifier);
         m[target] = mutation !== undefined ? Object.assign({}, keyState[target], mutation) : keyState[target];
-        return _pickBy(m, v => !_isEmpty(v));
+        return pickBy(m, v => !isEmpty(v));
       }, {});
     }
-    return _pickBy(memo, v => !_isEmpty(v));
+    return pickBy(memo, v => !isEmpty(v));
   }, {});
 }
 
@@ -332,11 +326,11 @@ export function getExternalMutation(mutations, baseProps, baseState, identifier)
   }
   // find any mutation objects that match the target
   const targetMutations = scopedMutations.filter(m => filterMutations(m, "target"));
-  if (_isEmpty(targetMutations)) {
+  if (isEmpty(targetMutations)) {
     return undefined;
   }
   const keyMutations = targetMutations.filter(m => filterMutations(m, "eventKey"));
-  if (_isEmpty(keyMutations)) {
+  if (isEmpty(keyMutations)) {
     return undefined;
   }
   return keyMutations.reduce((memo, curr) => {
@@ -362,8 +356,8 @@ export function getGlobalEventNameFromKey(key) {
   const match = key.match(GLOBAL_EVENT_REGEX);
   return match && match[1] && match[1].toLowerCase();
 }
-export const getGlobalEvents = events => _pickBy(events, (_, key) => GLOBAL_EVENT_REGEX.test(key));
-export const omitGlobalEvents = events => _omitBy(events, (_, key) => GLOBAL_EVENT_REGEX.test(key));
+export const getGlobalEvents = events => pickBy(events, (_, key) => GLOBAL_EVENT_REGEX.test(key));
+export const omitGlobalEvents = events => omitBy(events, (_, key) => GLOBAL_EVENT_REGEX.test(key));
 export const emulateReactEvent = event => Object.assign(event, {
   nativeEvent: event
 });