victory-core 36.4.0 → 36.5.1

package/lib/victory-transition/victory-transition.js

@@ -3,9 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-
-var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+exports.VictoryTransition = void 0;
 
 var _pick2 = _interopRequireDefault(require("lodash/pick"));
 
@@ -17,7 +15,7 @@ var _react = _interopRequireDefault(require("react"));
 
 var _propTypes = _interopRequireDefault(require("prop-types"));
 
-var _victoryAnimation = _interopRequireDefault(require("../victory-animation/victory-animation"));
+var _victoryAnimation = require("../victory-animation/victory-animation");
 
 var Collection = _interopRequireWildcard(require("../victory-util/collection"));
 
@@ -35,7 +33,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _extends() { _extends = Object.assign || 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); }
+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); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
@@ -45,7 +43,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -55,9 +53,7 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 var VictoryTransition = /*#__PURE__*/function (_React$Component) {
   _inherits(VictoryTransition, _React$Component);
@@ -70,6 +66,9 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
     _classCallCheck(this, VictoryTransition);
 
     _this = _super.call(this, props, context);
+    _this.continuous = void 0;
+    _this.timer = void 0;
+    _this.transitionProps = void 0;
     _this.state = {
       nodesShouldLoad: false,
       nodesDoneLoad: false
@@ -77,7 +76,6 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
     var child = _this.props.children;
     var polar = child.props.polar;
     _this.continuous = !polar && child.type && child.type.continuous === true;
-    _this.getTransitionState = _this.getTransitionState.bind(_assertThisInitialized(_this));
     _this.timer = _this.context.transitionTimer;
     return _this;
   }
@@ -183,10 +181,12 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
   }, {
     key: "pickDomainProps",
     value: function pickDomainProps(props) {
-      var parentState = (0, _isObject2.default)(props.animate) && props.animate.parentState;
+      var _props$animate;
+
+      var parentState = (_props$animate = props.animate) === null || _props$animate === void 0 ? void 0 : _props$animate.parentState;
 
       if (parentState && parentState.nodesWillExit) {
-        return this.continous || parentState.continuous ? parentState.nextProps || this.state.nextProps || props : props;
+        return this.continuous || parentState.continuous ? parentState.nextProps || this.state.nextProps || props : props;
       }
 
       return this.continuous && this.state.nodesWillExit ? this.state.nextProps || props : props;
@@ -205,10 +205,11 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
   }, {
     key: "render",
     value: function render() {
-      var _this3 = this;
+      var _this$props$animate,
+          _this3 = this;
 
       var props = this.pickProps();
-      var getTransitionProps = (0, _isObject2.default)(this.props.animate) && this.props.animate.getTransitions ? this.props.animate.getTransitions : Transitions.getTransitionPropsFactory(props, this.state, function (newState) {
+      var getTransitionProps = (_this$props$animate = this.props.animate) !== null && _this$props$animate !== void 0 && _this$props$animate.getTransitions ? this.props.animate.getTransitions : Transitions.getTransitionPropsFactory(props, this.state, function (newState) {
         return _this3.setState(newState);
       });
 
@@ -228,7 +229,7 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
       var animationWhitelist = props.animationWhitelist || [];
       var whitelist = animationWhitelist.concat(["clipWidth"]);
       var propsToAnimate = whitelist.length ? (0, _pick2.default)(combinedProps, whitelist) : combinedProps;
-      return /*#__PURE__*/_react.default.createElement(_victoryAnimation.default, _extends({}, combinedProps.animate, {
+      return /*#__PURE__*/_react.default.createElement(_victoryAnimation.VictoryAnimation, _extends({}, combinedProps.animate, {
         data: propsToAnimate
       }), function (newProps) {
         if (child.props.groupComponent) {
@@ -253,14 +254,12 @@ var VictoryTransition = /*#__PURE__*/function (_React$Component) {
   return VictoryTransition;
 }(_react.default.Component);
 
-exports.default = VictoryTransition;
-
-_defineProperty(VictoryTransition, "displayName", "VictoryTransition");
-
-_defineProperty(VictoryTransition, "propTypes", {
+exports.VictoryTransition = VictoryTransition;
+VictoryTransition.displayName = "VictoryTransition";
+VictoryTransition.propTypes = {
   animate: _propTypes.default.oneOfType([_propTypes.default.bool, _propTypes.default.object]),
   animationWhitelist: _propTypes.default.array,
   children: _propTypes.default.node
-});
-
-_defineProperty(VictoryTransition, "contextType", _timerContext.default);
+};
+VictoryTransition.contextType = _timerContext.default;
+//# sourceMappingURL=victory-transition.js.map

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

@@ -0,0 +1,106 @@
+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;
+    }>;
+};
+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;
+    cacheValues<TThis>(this: TThis, obj: Partial<TThis>): void;
+    getEventState: typeof Events.getEventState;
+    renderContinuousData(props: TProps): any;
+    animateComponent(props: TProps, defaultAnimationWhitelist: any): any;
+}
+/**
+ * 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;
+}
+/**
+ * This represents the class itself, including static fields
+ */
+export interface WrappedComponentClass<TProps> {
+    new (props: TProps): React.Component<TProps>;
+    getBaseProps?(props: TProps): EventMixinCalculatedValues["baseProps"];
+    role?: string;
+    expectedComponents?: string[];
+}
+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: any, type: any, index: any): any;
+        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+        animateComponent(props: TProps, defaultAnimationWhitelist: string[]): JSX.Element;
+        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[] | undefined;
+} & TBase;
+//# sourceMappingURL=add-events.d.ts.map

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

@@ -3,35 +3,33 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-
-var _difference2 = _interopRequireDefault(require("lodash/difference"));
-
-var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
-
-var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
+exports.addEvents = addEvents;
 
 var _without2 = _interopRequireDefault(require("lodash/without"));
 
 var _pick2 = _interopRequireDefault(require("lodash/pick"));
 
+var _keys2 = _interopRequireDefault(require("lodash/keys"));
+
+var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
+
 var _isFunction2 = _interopRequireDefault(require("lodash/isFunction"));
 
-var _keys2 = _interopRequireDefault(require("lodash/keys"));
+var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
 
-var _assign2 = _interopRequireDefault(require("lodash/assign"));
+var _difference2 = _interopRequireDefault(require("lodash/difference"));
 
 var _defaults2 = _interopRequireDefault(require("lodash/defaults"));
 
+var _assign2 = _interopRequireDefault(require("lodash/assign"));
+
 var _react = _interopRequireDefault(require("react"));
 
 var Events = _interopRequireWildcard(require("./events"));
 
 var _reactFastCompare = _interopRequireDefault(require("react-fast-compare"));
 
-var _victoryTransition = _interopRequireDefault(require("../victory-transition/victory-transition"));
-
-var UserProps = _interopRequireWildcard(require("../victory-util/user-props"));
+var _victoryTransition = require("../victory-transition/victory-transition");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -59,7 +57,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -69,8 +67,12 @@ function _assertThisInitialized(self) { if (self === void 0) { throw new Referen
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
+// 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
+// to this file without manual testing and/or refactoring and adding tests.
 var datumHasXandY = function (datum) {
   return !(0, _isNil2.default)(datum._x) && !(0, _isNil2.default)(datum._y);
 }; //  used for checking state changes. Expected components can be passed in via options
@@ -85,44 +87,45 @@ var defaultComponents = [{
   name: "labels"
 }];
 
-var _default = function _default(WrappedComponent, options) {
-  return /*#__PURE__*/function (_WrappedComponent) {
-    _inherits(addEvents, _WrappedComponent);
+function addEvents(WrappedComponent) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    var _super = _createSuper(addEvents);
+  // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
+  var AddEventsMixin = /*#__PURE__*/function (_WrappedComponent) {
+    _inherits(AddEventsMixin, _WrappedComponent);
 
-    function addEvents(props) {
+    var _super = _createSuper(AddEventsMixin);
+
+    function AddEventsMixin(props) {
       var _this;
 
-      _classCallCheck(this, addEvents);
+      _classCallCheck(this, AddEventsMixin);
 
       _this = _super.call(this, props);
-      var getScopedEvents = Events.getScopedEvents.bind(_assertThisInitialized(_this));
-      var boundGetEvents = Events.getEvents.bind(_assertThisInitialized(_this));
       _this.state = {};
+      _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
+      _this.getScopedEvents = Events.getScopedEvents.bind(_assertThisInitialized(_this));
 
       _this.getEvents = function (p, target, eventKey) {
-        return boundGetEvents(p, target, eventKey, getScopedEvents);
+        return Events.getEvents.call(_assertThisInitialized(_this), p, target, eventKey, _this.getScopedEvents);
       };
 
-      _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
-
-      var calculatedValues = _this.getCalculatedValues(props);
-
-      _this.cacheValues(calculatedValues);
-
-      _this.externalMutations = _this.getExternalMutations(props);
-      _this.calculatedState = _this.getStateChanges(props);
+      _this.externalMutations = _this.getExternalMutations(_this.props);
+      _this.calculatedState = _this.getStateChanges(_this.props);
       _this.globalEvents = {};
       _this.prevGlobalEventKeys = [];
       _this.boundGlobalEvents = {};
+
+      _this.cacheValues(_this.getCalculatedValues(props));
+
       return _this;
     }
 
-    _createClass(addEvents, [{
+    _createClass(AddEventsMixin, [{
       key: "shouldComponentUpdate",
       value: function shouldComponentUpdate(nextProps) {
-        var externalMutations = this.getExternalMutations(nextProps);
+        var externalMutations = this.getExternalMutations(nextProps); // @ts-expect-error "Property 'animating' does not exist on type EventMixinCommonProps"
+
         var animating = this.props.animating || this.props.animate;
         var newMutation = !(0, _reactFastCompare.default)(externalMutations, this.externalMutations);
 
@@ -219,7 +222,6 @@ var _default = function _default(WrappedComponent, options) {
           return (0, _isEmpty2.default)(result) ? undefined : result;
         };
 
-        options = options || {};
         var components = options.components || defaultComponents;
         var stateChanges = components.map(function (component) {
           if (!props.standalone && component.name === "parent") {
@@ -292,14 +294,14 @@ var _default = function _default(WrappedComponent, options) {
     }, {
       key: "getBaseProps",
       value: function getBaseProps(props, getSharedEventState) {
-        getSharedEventState = getSharedEventState || this.getSharedEventState;
+        getSharedEventState = getSharedEventState || this.getSharedEventState.bind(this);
         var sharedParentState = getSharedEventState("parent", "parent");
         var parentState = this.getEventState("parent", "parent");
         var baseParentProps = (0, _defaults2.default)({}, parentState, sharedParentState);
         var parentPropsList = baseParentProps.parentControlledProps;
         var parentProps = parentPropsList ? (0, _pick2.default)(baseParentProps, parentPropsList) : {};
         var modifiedProps = (0, _defaults2.default)({}, parentProps, props);
-        return (0, _isFunction2.default)(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
+        return typeof WrappedComponent.getBaseProps === "function" ? WrappedComponent.getBaseProps(modifiedProps) : {};
       }
     }, {
       key: "getAllEvents",
@@ -361,11 +363,14 @@ var _default = function _default(WrappedComponent, options) {
     }, {
       key: "animateComponent",
       value: function animateComponent(props, defaultAnimationWhitelist) {
-        var animationWhitelist = props.animate && props.animate.animationWhitelist ? props.animate.animationWhitelist : defaultAnimationWhitelist;
-        return /*#__PURE__*/_react.default.createElement(_victoryTransition.default, {
+        var _props$animate;
+
+        var animationWhitelist = typeof props.animate === "object" && ((_props$animate = props.animate) === null || _props$animate === void 0 ? void 0 : _props$animate.animationWhitelist) || defaultAnimationWhitelist;
+        var Comp = this.constructor;
+        return /*#__PURE__*/_react.default.createElement(_victoryTransition.VictoryTransition, {
           animate: props.animate,
           animationWhitelist: animationWhitelist
-        }, /*#__PURE__*/_react.default.createElement(this.constructor, props));
+        }, /*#__PURE__*/_react.default.createElement(Comp, props));
       } // Used by `VictoryLine` and `VictoryArea`
 
     }, {
@@ -399,7 +404,6 @@ var _default = function _default(WrappedComponent, options) {
         var dataComponent = props.dataComponent,
             labelComponent = props.labelComponent,
             groupComponent = props.groupComponent;
-        var userProps = UserProps.getSafeUserProps(props);
         var dataComponents = this.dataKeys.reduce(function (validDataComponents, _dataKey, index) {
           var dataProps = _this9.getComponentProps(dataComponent, "data", index);
 
@@ -419,15 +423,13 @@ var _default = function _default(WrappedComponent, options) {
           return undefined;
         }).filter(Boolean);
         var children = [].concat(_toConsumableArray(dataComponents), _toConsumableArray(labelComponents));
-
-        var group = /*#__PURE__*/_react.default.cloneElement(groupComponent, userProps, children);
-
-        return this.renderContainer(group, children);
+        return this.renderContainer(groupComponent, children);
       }
     }]);
 
-    return addEvents;
+    return AddEventsMixin;
   }(WrappedComponent);
-};
 
-exports.default = _default;
+  return AddEventsMixin;
+}
+//# sourceMappingURL=add-events.js.map

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

@@ -0,0 +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[];
+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/lib/victory-util/axis.js

@@ -261,7 +261,7 @@ function getTickArray(props) {
     }) : (0, _range2.default)(1, tickValues.length + 1);
   }
 
-  var tickArray = ticks ? (0, _uniq2.default)(ticks) : getTicksFromFormat(props);
+  var tickArray = ticks ? (0, _uniq2.default)(ticks) : getTicksFromFormat();
 
   var buildTickArray = function (arr) {
     var newTickArray = [];
@@ -306,11 +306,11 @@ function getTickFormat(props, scale) {
     return defaultTickFormat || scaleTickFormat;
   } else if (tickFormat && Array.isArray(tickFormat)) {
     var tickArray = getTickArray(props);
-    var tickArrayIndices = tickArray ? tickArray.map(function (v) {
+    var tickArrayIndices = tickArray === null || tickArray === void 0 ? void 0 : tickArray.map(function (v) {
       return v.index;
-    }) : undefined;
+    });
     var filteredTickFormat = tickFormat.filter(function (t, index) {
-      return tickArrayIndices.includes(index);
+      return tickArrayIndices === null || tickArrayIndices === void 0 ? void 0 : tickArrayIndices.includes(index);
     });
     return function (x, index) {
       return filteredTickFormat[index];
@@ -343,7 +343,8 @@ function downsampleTicks(ticks, tickCount) {
   });
 }
 
-function getTicks(props, scale, filterZero) {
+function getTicks(props, scale) {
+  var filterZero = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var tickCount = props.tickCount;
   var tickArray = getTickArray(props);
   var tickValues = tickArray ? tickArray.map(function (v) {
@@ -466,4 +467,5 @@ function modifyProps(props, fallbackProps) {
   return Helpers.modifyProps((0, _assign2.default)({}, props, {
     theme: theme
   }), fallbackProps, "axis");
-}
+}
+//# sourceMappingURL=axis.js.map

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

@@ -0,0 +1,9 @@
+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: any): any;
+export declare function isArrayOfArrays(collection: any): any;
+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/lib/victory-util/collection.js

@@ -24,9 +24,6 @@ function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToAr
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-/* eslint-disable func-style */
-
-/* eslint-disable no-use-before-define */
 function isNonEmptyArray(collection) {
   return Array.isArray(collection) && collection.length > 0;
 }
@@ -71,7 +68,8 @@ function getMaxValue(arr) {
   }
 
   var array = arr.concat(values);
-  return containsDates(array) ? new Date(Math.max.apply(Math, _toConsumableArray(array))) : Math.max.apply(Math, _toConsumableArray(array));
+  return containsDates(array) ? new Date(Math.max.apply(Math, _toConsumableArray(array))) // Dates will be coerced to numbers
+  : Math.max.apply(Math, _toConsumableArray(array));
 }
 
 function getMinValue(arr) {
@@ -80,5 +78,7 @@ function getMinValue(arr) {
   }
 
   var array = arr.concat(values);
-  return containsDates(array) ? new Date(Math.min.apply(Math, _toConsumableArray(array))) : Math.min.apply(Math, _toConsumableArray(array));
-}
+  return containsDates(array) ? new Date(Math.min.apply(Math, _toConsumableArray(array))) // Dates will be coerced to numbers
+  : Math.min.apply(Math, _toConsumableArray(array));
+}
+//# sourceMappingURL=collection.js.map

package/lib/victory-util/common-props.d.ts

@@ -0,0 +1,84 @@
+import * as React from "react";
+import { OriginType } from "../victory-label/victory-label";
+import { PaddingProps, VictoryThemeDefinition } from "../victory-theme/types";
+import { AnimatePropTypeInterface, CategoryPropType, ColorScalePropType, D3Scale, DataGetterPropType, DomainPaddingPropType, DomainPropType, EventCallbackInterface, RangePropType, ScalePropType, SortOrderPropType, StringOrNumberOrList } from "../types/prop-types";
+import { NumberOrCallback, StringOrCallback } from "../types/callbacks";
+export interface VictoryDatableProps {
+    categories?: CategoryPropType;
+    data?: readonly any[];
+    dataComponent?: React.ReactElement;
+    domain?: DomainPropType;
+    domainPadding?: DomainPaddingPropType;
+    samples?: number;
+    sortKey?: DataGetterPropType;
+    sortOrder?: SortOrderPropType;
+    x?: DataGetterPropType;
+    y?: DataGetterPropType;
+    y0?: DataGetterPropType;
+}
+export interface VictoryCommonThemeProps {
+    animate?: boolean | AnimatePropTypeInterface;
+    colorScale?: ColorScalePropType;
+    containerComponent?: React.ReactElement;
+    domainPadding?: DomainPaddingPropType;
+    externalEventMutations?: EventCallbackInterface<string | string[], StringOrNumberOrList>[];
+    groupComponent?: React.ReactElement;
+    height?: number;
+    horizontal?: boolean;
+    maxDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    minDomain?: number | {
+        x?: number;
+        y?: number;
+    };
+    name?: string;
+    origin?: OriginType;
+    padding?: PaddingProps;
+    polar?: boolean;
+    range?: RangePropType;
+    scale?: ScalePropType | D3Scale | {
+        x?: ScalePropType | D3Scale;
+        y?: ScalePropType | D3Scale;
+    };
+    sharedEvents?: {
+        events: any[];
+        getEventState: Function;
+    };
+    singleQuadrantDomainPadding?: boolean | {
+        x?: boolean;
+        y?: boolean;
+    };
+    standalone?: boolean;
+    width?: number;
+}
+export interface VictoryCommonProps extends VictoryCommonThemeProps {
+    theme?: VictoryThemeDefinition;
+}
+export interface VictoryCommonPrimitiveProps {
+    active?: boolean;
+    ariaLabel?: StringOrCallback;
+    className?: string;
+    clipPath?: string;
+    data?: any;
+    desc?: string | Function;
+    disableInlineStyles?: boolean;
+    events?: object;
+    id?: number | string | Function;
+    index?: number | string;
+    origin?: OriginType;
+    polar?: boolean;
+    role?: string;
+    scale?: any;
+    shapeRendering?: string;
+    style?: any;
+    tabIndex?: NumberOrCallback;
+    transform?: string;
+}
+export declare const CommonProps: {
+    dataProps: React.WeakValidationMap<VictoryDatableProps>;
+    baseProps: React.WeakValidationMap<VictoryCommonProps>;
+    primitiveProps: React.WeakValidationMap<VictoryCommonPrimitiveProps>;
+};
+//# sourceMappingURL=common-props.d.ts.map