victory-core 37.3.2 → 37.3.3

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;
@@ -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";
@@ -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
@@ -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,12 +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";
 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";
@@ -27,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);
@@ -52,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)
@@ -96,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
@@ -155,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));
   });
 }
 
@@ -174,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;
@@ -230,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
@@ -260,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,7 +1,7 @@
-import _isDate from "lodash/isDate";
-import _sortedUniq from "lodash/sortedUniq";
-import _isPlainObject from "lodash/isPlainObject";
 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";
@@ -32,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}`;
@@ -81,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) {
@@ -253,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;
@@ -304,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;
 }
 
 /**
@@ -317,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;
 }
 
 /**
@@ -331,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 @@
 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,7 +1,7 @@
-import _uniq from "lodash/uniq";
-import _omitBy from "lodash/omitBy";
-import _pickBy from "lodash/pickBy";
-import _isEmpty from "lodash/isEmpty";
+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(.*)$/;
 
@@ -72,7 +72,7 @@ getScopedEvents) {
  */
 // eslint-disable-next-line max-params
 export function getScopedEvents(events, namespace, childType, baseProps) {
-  if (_isEmpty(events)) {
+  if (isEmpty(events)) {
     return {};
   }
 
@@ -185,7 +185,7 @@ export function getScopedEvents(events, namespace, childType, baseProps) {
   // eslint-disable-next-line max-params
   const onEvent = (evt, childProps, eventKey, eventName) => {
     const eventReturn = events[eventName](evt, childProps, eventKey, this);
-    if (!_isEmpty(eventReturn)) {
+    if (!isEmpty(eventReturn)) {
       const callbacks = compileCallbacks(eventReturn);
       this.setState(parseEventReturn(eventReturn, eventKey), callbacks);
     }
@@ -246,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));
   }, {});
 }
 
@@ -282,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,
@@ -291,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));
   }, {});
 }
 
@@ -326,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) => {
@@ -356,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
 });

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

@@ -1,6 +1,27 @@
 import React from "react";
-import { CallbackArgs } from "../types/callbacks";
 import { ValueOrAccessor } from "../types/prop-types";
+export type ElementPadding = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+export type MaybePointData = {
+    x?: number;
+    x0?: number;
+    x1?: number;
+    y?: number;
+    y0?: number;
+    y1?: number;
+    _x?: number;
+    _x0?: number;
+    _x1?: number;
+    _y?: number;
+    _y0?: number;
+    _y1?: number;
+    _voronoiX?: number;
+    _voronoiY?: number;
+};
 /**
  * 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.
@@ -14,32 +35,83 @@ export declare function invert(original: Record<string, string | number>): {};
  * @returns {Object} new object with same properties as originalObject
  */
 export declare function omit<T, Keys extends keyof T>(originalObject: T, ks?: Array<Keys>): Omit<T, Keys>;
-export declare function getPoint(datum: any): any;
-export declare function scalePoint(props: any, datum: any): {
-    x: any;
-    x0: any;
-    y: any;
-    y0: any;
-};
-export declare function getPadding(props: any, name?: string): {
-    top: any;
-    bottom: any;
-    left: any;
-    right: any;
+/**
+ * Coalesce the x and y values from a data point
+ */
+export declare function getPoint(datum: MaybePointData): MaybePointData;
+/**
+ * Scale a point based on the origin, direction, and given scale function
+ */
+export declare function scalePoint(props: {
+    scale: {
+        x: (x?: number) => number;
+        y: (y?: number) => number;
+    };
+    polar?: boolean;
+    horizontal?: boolean;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}, datum: MaybePointData): {
+    x: number;
+    x0: number;
+    y: number;
+    y0: number;
 };
-export declare function isTooltip(component: any): boolean;
+/**
+ * Returns a padding value from a number or partial padding values
+ */
+export declare function getPadding(padding?: number | Partial<ElementPadding>): ElementPadding;
+/**
+ * Returns true if the component is defined as a tooltip
+ */
+export declare function isTooltip(component?: {
+    type?: {
+        role?: string;
+    };
+}): boolean;
 export declare function getDefaultStyles(props: any, role: any): any;
 export declare function getStyles(style: any, defaultStyles: any): any;
-export declare function evaluateProp<TValue>(prop: ValueOrAccessor<TValue, CallbackArgs>, props: CallbackArgs): TValue;
+/**
+ * Returns the value of a prop or accessor function with the given props
+ */
+export declare function evaluateProp<TValue>(prop: ValueOrAccessor<TValue, Record<string, any>>, props: Record<string, any>): TValue;
 export declare function evaluateStyle(style: any, props: any): any;
 export declare function degreesToRadians(degrees: any): any;
 export declare function radiansToDegrees(radians: any): any;
-export declare function getRadius(props: any): number;
-export declare function getPolarOrigin(props: any): {
+/**
+ * Get the maximum radius that will fit in the container
+ */
+export declare function getRadius(options: {
+    height: number;
+    width: number;
+    padding: ElementPadding;
+}): number;
+/**
+ * Returns the origin for a polar chart within the padded area
+ */
+export declare function getPolarOrigin(props: {
+    height: number;
+    width: number;
+    padding: ElementPadding;
+}): {
     x: number;
     y: number;
 };
-export declare function getRange(props: any, axis: any): any;
+/**
+ * Determine the range of an axis based on the given props
+ */
+export declare function getRange(props: {
+    range?: [number, number];
+    polar?: boolean;
+    innerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    height: number;
+    width: number;
+    padding: number | Partial<ElementPadding>;
+}, axis: "x" | "y"): any;
 /**
  * Checks if `value` is `null` or `undefined`.
  * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
@@ -93,5 +165,8 @@ export declare function reduceChildren<TChildren extends React.ReactNode, TItem,
  * @returns {Boolean} returns true if the props object contains `horizontal: true` of if any
  * children or nested children are horizontal
  */
-export declare function isHorizontal(props: any): any;
+export declare function isHorizontal(props: {
+    horizontal?: boolean;
+    children?: React.ReactNode;
+}): any;
 //# sourceMappingURL=helpers.d.ts.map