victory-core 36.5.0 → 36.5.3

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

@@ -1,12 +1,12 @@
-import _difference from "lodash/difference";
-import _isNil from "lodash/isNil";
-import _isEmpty from "lodash/isEmpty";
 import _without from "lodash/without";
 import _pick from "lodash/pick";
-import _isFunction from "lodash/isFunction";
 import _keys from "lodash/keys";
-import _assign from "lodash/assign";
+import _isNil from "lodash/isNil";
+import _isFunction from "lodash/isFunction";
+import _isEmpty from "lodash/isEmpty";
+import _difference from "lodash/difference";
 import _defaults from "lodash/defaults";
+import _assign from "lodash/assign";
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
@@ -44,11 +44,12 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 import React from "react";
 import * as Events from "./events";
 import isEqual from "react-fast-compare";
-import { VictoryTransition } from "../victory-transition/victory-transition"; // DISCLAIMER:
+import { VictoryTransition } from "../victory-transition/victory-transition";
+
+// 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 !_isNil(datum._x) && !_isNil(datum._y);
 }; //  used for checking state changes. Expected components can be passed in via options
@@ -62,44 +63,45 @@ var defaultComponents = [{
 }, {
   name: "labels"
 }];
-export default (function (WrappedComponent, options) {
-  return /*#__PURE__*/function (_WrappedComponent) {
-    _inherits(addEvents, _WrappedComponent);
+export 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 = !isEqual(externalMutations, this.externalMutations);
 
@@ -203,7 +205,6 @@ export default (function (WrappedComponent, options) {
           return _isEmpty(result) ? undefined : result;
         };
 
-        options = options || {};
         var components = options.components || defaultComponents;
         var stateChanges = components.map(function (component) {
           if (!props.standalone && component.name === "parent") {
@@ -278,7 +279,7 @@ export default (function (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");
 
@@ -289,7 +290,7 @@ export default (function (WrappedComponent, options) {
 
         var modifiedProps = _defaults({}, parentProps, props);
 
-        return _isFunction(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
+        return typeof WrappedComponent.getBaseProps === "function" ? WrappedComponent.getBaseProps(modifiedProps) : {};
       }
     }, {
       key: "getAllEvents",
@@ -354,11 +355,14 @@ export default (function (WrappedComponent, options) {
     }, {
       key: "animateComponent",
       value: function animateComponent(props, defaultAnimationWhitelist) {
-        var animationWhitelist = props.animate && props.animate.animationWhitelist ? props.animate.animationWhitelist : defaultAnimationWhitelist;
+        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.createElement(VictoryTransition, {
           animate: props.animate,
           animationWhitelist: animationWhitelist
-        }, /*#__PURE__*/React.createElement(this.constructor, props));
+        }, /*#__PURE__*/React.createElement(Comp, props));
       } // Used by `VictoryLine` and `VictoryArea`
 
     }, {
@@ -417,6 +421,9 @@ export default (function (WrappedComponent, options) {
       }
     }]);
 
-    return addEvents;
+    return AddEventsMixin;
   }(WrappedComponent);
-});
+
+  return AddEventsMixin;
+}
+//# sourceMappingURL=add-events.js.map

package/es/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/es/victory-util/axis.js

@@ -27,13 +27,13 @@ import React from "react";
 import * as Collection from "./collection";
 import * as Domain from "./domain";
 import * as Helpers from "./helpers";
+
 /**
  * Returns the axis (x or y) of a particular axis component
  * @param {Object} props: the props object.
  * @param {Boolean} horizontal: true for horizontal charts
  * @returns {String} the dimension appropriate for the axis given its props
  */
-
 export function getAxis(props) {
   var dependentAxis = props.dependentAxis;
   return dependentAxis ? "y" : "x";
@@ -219,7 +219,7 @@ function getTickArray(props) {
     }) : _range(1, tickValues.length + 1);
   }
 
-  var tickArray = ticks ? _uniq(ticks) : getTicksFromFormat(props);
+  var tickArray = ticks ? _uniq(ticks) : getTicksFromFormat();
 
   var buildTickArray = function (arr) {
     var newTickArray = [];
@@ -264,11 +264,11 @@ export 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];
@@ -302,7 +302,8 @@ function downsampleTicks(ticks, tickCount) {
   });
 }
 
-export function getTicks(props, scale, filterZero) {
+export 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) {
@@ -424,4 +425,5 @@ export function modifyProps(props, fallbackProps) {
   return Helpers.modifyProps(_assign({}, props, {
     theme: theme
   }), fallbackProps, "axis");
-}
+}
+//# sourceMappingURL=axis.js.map

package/es/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/es/victory-util/collection.js

@@ -10,7 +10,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 no-use-before-define */
 function isNonEmptyArray(collection) {
   return Array.isArray(collection) && collection.length > 0;
 }
@@ -49,7 +48,8 @@ export 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));
 }
 export function getMinValue(arr) {
   for (var _len2 = arguments.length, values = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
@@ -57,5 +57,7 @@ export 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/es/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

package/es/victory-util/common-props.js

@@ -1,42 +1,47 @@
 import PropTypes from "prop-types";
 import * as CustomPropTypes from "./prop-types";
-export var dataProps = {
+var dataProps = {
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   categories: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.shape({
     x: PropTypes.arrayOf(PropTypes.string),
     y: PropTypes.arrayOf(PropTypes.string)
   })]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   data: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),
   dataComponent: PropTypes.element,
   disableInlineStyles: PropTypes.bool,
   labelComponent: PropTypes.element,
   labels: PropTypes.oneOfType([PropTypes.func, PropTypes.array]),
   samples: CustomPropTypes.nonNegative,
-  sortKey: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
+  sortKey: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string.isRequired)]),
   sortOrder: PropTypes.oneOf(["ascending", "descending"]),
   style: PropTypes.shape({
     parent: PropTypes.object,
     data: PropTypes.object,
     labels: PropTypes.object
   }),
-  x: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
-  y: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),
-  y0: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string)])
+  x: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string.isRequired)]),
+  y: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string.isRequired)]),
+  y0: PropTypes.oneOfType([PropTypes.func, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string, PropTypes.arrayOf(PropTypes.string.isRequired)])
 };
-export var baseProps = {
+var baseProps = {
   animate: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
   containerComponent: PropTypes.element,
   domain: PropTypes.oneOfType([CustomPropTypes.domain, PropTypes.shape({
     x: CustomPropTypes.domain,
     y: CustomPropTypes.domain
   })]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   maxDomain: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date), PropTypes.shape({
     x: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
     y: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)])
   })]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   minDomain: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date), PropTypes.shape({
     x: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
     y: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)])
   })]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   domainPadding: PropTypes.oneOfType([PropTypes.shape({
     x: PropTypes.oneOfType([PropTypes.number, PropTypes.arrayOf(PropTypes.number)]),
     y: PropTypes.oneOfType([PropTypes.number, PropTypes.arrayOf(PropTypes.number)])
@@ -47,6 +52,7 @@ export var baseProps = {
     eventKey: PropTypes.oneOfType([PropTypes.array, CustomPropTypes.allOfType([CustomPropTypes.integer, CustomPropTypes.nonNegative]), PropTypes.string]),
     eventHandlers: PropTypes.object
   })),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   externalEventMutations: PropTypes.arrayOf(PropTypes.shape({
     callback: PropTypes.func,
     childName: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
@@ -57,10 +63,12 @@ export var baseProps = {
   groupComponent: PropTypes.element,
   height: CustomPropTypes.nonNegative,
   name: PropTypes.string,
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   origin: PropTypes.shape({
     x: PropTypes.number,
     y: PropTypes.number
   }),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   padding: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
     top: PropTypes.number,
     bottom: PropTypes.number,
@@ -69,17 +77,19 @@ export var baseProps = {
   })]),
   polar: PropTypes.bool,
   range: PropTypes.oneOfType([CustomPropTypes.domain, PropTypes.shape({
-    x: CustomPropTypes.domain,
-    y: CustomPropTypes.domain
+    x: CustomPropTypes.domain.isRequired,
+    y: CustomPropTypes.domain.isRequired
   })]),
   scale: PropTypes.oneOfType([CustomPropTypes.scale, PropTypes.shape({
-    x: CustomPropTypes.scale,
-    y: CustomPropTypes.scale
+    x: CustomPropTypes.scale.isRequired,
+    y: CustomPropTypes.scale.isRequired
   })]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   sharedEvents: PropTypes.shape({
     events: PropTypes.array,
     getEventState: PropTypes.func
   }),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   singleQuadrantDomainPadding: PropTypes.oneOfType([PropTypes.bool, PropTypes.shape({
     x: PropTypes.oneOfType([PropTypes.bool]),
     y: PropTypes.oneOfType([PropTypes.bool])
@@ -88,7 +98,7 @@ export var baseProps = {
   theme: PropTypes.object,
   width: CustomPropTypes.nonNegative
 };
-export var primitiveProps = {
+var primitiveProps = {
   active: PropTypes.bool,
   ariaLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
   className: PropTypes.string,
@@ -99,6 +109,7 @@ export var primitiveProps = {
   events: PropTypes.object,
   id: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.func]),
   index: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
   origin: PropTypes.shape({
     x: PropTypes.number,
     y: PropTypes.number
@@ -113,4 +124,10 @@ export var primitiveProps = {
   style: PropTypes.object,
   tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
   transform: PropTypes.string
-};
+};
+export var CommonProps = {
+  dataProps: dataProps,
+  baseProps: baseProps,
+  primitiveProps: primitiveProps
+};
+//# sourceMappingURL=common-props.js.map

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

@@ -0,0 +1,75 @@
+export declare function formatDataFromDomain(dataset: any, domain: any, defaultBaseline: any): any;
+/**
+ * Returns an object mapping string data to numeric data
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Object} an object mapping string data to numeric data
+ */
+export declare function createStringMap(props: any, axis: any): any;
+/**
+ * Reduces the size of a data array, such that it is <= maxPoints.
+ * @param {Array} data: an array of data; must be sorted
+ * @param {Number} maxPoints: maximum number of data points to return
+ * @param {Number} startingIndex: the index of the data[0] *in the entire dataset*; this function
+                   assumes `data` param is a subset of larger dataset that has been zoommed
+  * @returns {Array} an array of data, a subset of data param
+  */
+export declare function downsample(data: any, maxPoints: any, startingIndex?: number): any;
+/**
+ * Returns formatted data. Data accessors are applied, and string values are replaced.
+ * @param {Array} dataset: the original domain
+ * @param {Object} props: the props object
+ * @param {Array} expectedKeys: an array of expected data keys
+ * @returns {Array} the formatted data
+ */
+export declare function formatData(dataset: any[], props: any, expectedKeys?: string[]): any;
+/**
+ * Returns generated x and y data based on domain and sample from props
+ * @param {Object} props: the props object
+ * @returns {Array} an array of data
+ */
+export declare function generateData(props: any): {
+    x: number;
+    y: number;
+}[];
+/**
+ * Returns an array of categories for a given axis
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} an array of categories
+ */
+export declare function getCategories(props: any, axis: any): any;
+/**
+ * Returns an array of formatted data
+ * @param {Object} props: the props object
+ * @returns {Array} an array of data
+ */
+export declare function getData(props: any): any;
+/**
+ * Returns an array of strings from axis tickValues for a given axis
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} an array of strings
+ */
+export declare function getStringsFromAxes(props: any, axis: any): any;
+/**
+ * Returns an array of strings from categories for a given axis
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} an array of strings
+ */
+export declare function getStringsFromCategories(props: any, axis: any): any;
+/**
+ * Returns an array of strings from data
+ * @param {Object} props: the props object
+ * @param {String} axis: the current axis
+ * @returns {Array} an array of strings
+ */
+export declare function getStringsFromData(props: any, axis: any): any;
+/**
+ * Checks whether a given component can be used to calculate data
+ * @param {Component} component: a React component instance
+ * @returns {Boolean} Returns true if the given component has a role included in the whitelist
+ */
+export declare function isDataComponent(component: any): boolean;
+//# sourceMappingURL=data.d.ts.map

package/es/victory-util/data.js

@@ -454,4 +454,5 @@ export function isDataComponent(component) {
 
   var whitelist = ["area", "bar", "boxplot", "candlestick", "errorbar", "group", "histogram", "line", "pie", "scatter", "stack", "voronoi"];
   return _includes(whitelist, role);
-}
+}
+//# sourceMappingURL=data.js.map

package/es/victory-util/default-transitions.d.ts

@@ -0,0 +1,5 @@
+import { AnimatePropTypeInterface } from "../types/prop-types";
+export declare function continuousTransitions(): AnimatePropTypeInterface;
+export declare function continuousPolarTransitions(): AnimatePropTypeInterface;
+export declare function discreteTransitions(): AnimatePropTypeInterface;
+//# sourceMappingURL=default-transitions.d.ts.map

package/es/victory-util/default-transitions.js

@@ -103,4 +103,5 @@ export function discreteTransitions() {
       }
     }
   };
-}
+}
+//# sourceMappingURL=default-transitions.js.map