victory-core 36.5.0 → 36.5.3

package/es/victory-util/prop-types.d.ts

@@ -0,0 +1,51 @@
+import PropTypes from "prop-types";
+import { D3Scale, ScaleName } from "../types/prop-types";
+/**
+ * Return a new validator based on `propType` but which logs a `console.error`
+ * with `explanation` if used.
+ * @param {Function} propType The old, deprecated propType.
+ * @param {String} explanation The message to provide the user of the deprecated propType.
+ * @returns {Function} Validator which logs usage of this propType
+ */
+export declare function deprecated<T>(propType: PropTypes.Validator<T>, explanation: string): PropTypes.Validator<T>;
+/**
+ * Return a new validator which returns true
+ * if and only if all validators passed as arguments return true.
+ * Like React.propTypes.oneOfType, except "all" instead of "any"
+ * @param {Array} validators Validation functions.
+ * @returns {Function} Combined validator function
+ */
+export declare function allOfType<T>(validators: Array<PropTypes.Validator<T>>): PropTypes.Requireable<T | undefined>;
+/**
+ * Check that the value is a non-negative number.
+ */
+export declare const nonNegative: PropTypes.Requireable<number | undefined>;
+/**
+ * Check that the value is an integer.
+ */
+export declare const integer: PropTypes.Requireable<number | undefined>;
+/**
+ * Check that the value is greater than zero.
+ */
+export declare const greaterThanZero: PropTypes.Requireable<number | undefined>;
+/**
+ * Check that the value is an Array of two unique values.
+ */
+export declare const domain: PropTypes.Requireable<[number, number] | undefined>;
+/**
+ * Check that the value looks like a d3 `scale` function.
+ */
+export declare const scale: PropTypes.Requireable<ScaleName | D3Scale<any> | undefined>;
+/**
+ * Check that an array contains items of the same type.
+ */
+export declare const homogeneousArray: PropTypes.Requireable<unknown[] | undefined>;
+/**
+ * Check that array prop length matches props.data.length
+ */
+export declare const matchDataLength: PropTypes.Requireable<unknown[] | undefined>;
+/**
+ * Check that the value is a regular expression
+ */
+export declare const regExp: PropTypes.Requireable<RegExp | undefined>;
+//# sourceMappingURL=prop-types.d.ts.map

package/es/victory-util/prop-types.js

@@ -1,11 +1,12 @@
 import _isRegExp from "lodash/isRegExp";
 import _find from "lodash/find";
-import _isFunction from "lodash/isFunction";
 
 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; }
 
 import * as Log from "./log";
 import PropTypes from "prop-types";
+import * as Scale from "./scale";
+
 /**
  * Return a new validator based on `validator` but with the option to chain
  * `isRequired` onto the validation. This is nearly identical to how React
@@ -13,30 +14,30 @@ import PropTypes from "prop-types";
  * @param {Function} validator Validation function.
  * @returns {Function} Validator with `isRequired` option.
  */
-
 var makeChainable = function (validator) {
-  /* eslint-disable max-params */
-  var _chainable = function (isRequired, props, propName, componentName) {
-    var value = props[propName];
+  var createChainable = function (isRequired) {
+    return function (props, propName, componentName) {
+      var value = props[propName];
 
-    if (value === undefined || value === null) {
-      if (isRequired) {
-        return new Error("Required `".concat(propName, "` was not specified in `").concat(componentName, "`."));
-      }
+      if (value === undefined || value === null) {
+        if (isRequired) {
+          return new Error("Required `".concat(propName, "` was not specified in `").concat(componentName, "`."));
+        }
 
-      return null;
-    }
+        return null;
+      }
 
-    for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
-      rest[_key - 4] = arguments[_key];
-    }
+      for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+        rest[_key - 3] = arguments[_key];
+      }
 
-    return validator.apply(void 0, [props, propName, componentName].concat(rest));
+      return validator.apply(void 0, [props, propName, componentName].concat(rest));
+    };
   };
 
-  var chainable = _chainable.bind(null, false);
-
-  chainable.isRequired = _chainable.bind(null, true);
+  var chainable = Object.assign(createChainable(false), {
+    isRequired: createChainable(true)
+  });
   return chainable;
 };
 
@@ -66,7 +67,7 @@ var getConstructor = function (value) {
 };
 /**
  * Get the name of the constructor used to create `value`, using
- * `Object.protoype.toString`. If the value is null or undefined, return
+ * `Object.prototype.toString`. If the value is null or undefined, return
  * "null" or "undefined", respectively.
  * @param {*} value Instance to return the constructor name of.
  * @returns {String} Name of the constructor.
@@ -99,7 +100,8 @@ export function deprecated(propType, explanation) {
       Log.warn("\"".concat(propName, "\" property of \"").concat(componentName, "\" has been deprecated ").concat(explanation));
     }
 
-    return PropTypes.checkPropTypes(_defineProperty({}, propName, propType), props, propName, componentName);
+    PropTypes.checkPropTypes(_defineProperty({}, propName, propType), props, propName, componentName);
+    return null;
   };
 }
 /**
@@ -118,7 +120,7 @@ export function allOfType(validators) {
 
     return validators.reduce(function (result, validator) {
       return result || validator.apply(void 0, [props, propName, componentName].concat(rest));
-    }, undefined);
+    }, null);
   });
 }
 /**
@@ -132,7 +134,7 @@ export var nonNegative = makeChainable(function (props, propName, componentName)
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be a non-negative number."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that the value is an integer.
@@ -145,7 +147,7 @@ export var integer = makeChainable(function (props, propName, componentName) {
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be an integer."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that the value is greater than zero.
@@ -158,7 +160,7 @@ export var greaterThanZero = makeChainable(function (props, propName, componentN
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be a number greater than zero."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that the value is an Array of two unique values.
@@ -171,32 +173,20 @@ export var domain = makeChainable(function (props, propName, componentName) {
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be an array of two unique numeric values."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that the value looks like a d3 `scale` function.
  */
 
 export var scale = makeChainable(function (props, propName, componentName) {
-  var supportedScaleStrings = ["linear", "time", "log", "sqrt"];
-
-  var validScale = function (scl) {
-    if (_isFunction(scl)) {
-      return _isFunction(scl.copy) && _isFunction(scl.domain) && _isFunction(scl.range);
-    } else if (typeof scl === "string") {
-      return supportedScaleStrings.indexOf(scl) !== -1;
-    }
-
-    return false;
-  };
-
   var value = props[propName];
 
-  if (!validScale(value)) {
+  if (!Scale.validScale(value)) {
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be a d3 scale."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that an array contains items of the same type.
@@ -210,7 +200,7 @@ export var homogeneousArray = makeChainable(function (props, propName, component
   }
 
   if (values.length < 2) {
-    return undefined;
+    return null;
   }
 
   var comparisonConstructor = getConstructor(values[0]);
@@ -225,7 +215,7 @@ export var homogeneousArray = makeChainable(function (props, propName, component
     return new Error("Expected `".concat(propName, "` in `").concat(componentName, "` to be a ") + "homogeneous array, but found types `".concat(constructorName, "` and ") + "`".concat(otherConstructorName, "`."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that array prop length matches props.data.length
@@ -236,7 +226,7 @@ export var matchDataLength = makeChainable(function (props, propName) {
     return new Error("Length of data and ".concat(propName, " arrays must match."));
   }
 
-  return undefined;
+  return null;
 });
 /**
  * Check that the value is a regular expression
@@ -247,5 +237,6 @@ export var regExp = makeChainable(function (props, propName, componentName) {
     return new Error("`".concat(propName, "` in `").concat(componentName, "` must be a regular expression."));
   }
 
-  return undefined;
-});
+  return null;
+});
+//# sourceMappingURL=prop-types.js.map

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

@@ -0,0 +1,10 @@
+import * as d3Scale from "victory-vendor/d3-scale";
+import { D3Scale, ScaleName } from "../types/prop-types";
+export declare function validScale(scale: string | D3Scale): scale is ScaleName | D3Scale;
+export declare function getScaleFromName(name: ScaleName | string): D3Scale;
+export declare function getBaseScale(props: any, axis: "x" | "y"): D3Scale<any>;
+export declare function getDefaultScale(): d3Scale.ScaleLinear<number, number, never>;
+export declare function getScaleFromProps(props: any, axis: any): D3Scale | undefined;
+export declare function getScaleType(props: any, axis: any): string;
+export declare function getType(scale: any): string | undefined;
+//# sourceMappingURL=scale.d.ts.map

package/es/victory-util/scale.js

@@ -4,8 +4,9 @@ import _includes from "lodash/includes";
 import * as Helpers from "./helpers";
 import * as Collection from "./collection";
 import * as d3Scale from "victory-vendor/d3-scale";
-var supportedScaleStrings = ["linear", "time", "log", "sqrt"]; // Private Functions
+var supportedScaleStrings = ["linear", "time", "log", "sqrt"];
 
+// Private Functions
 function toNewName(scale) {
   // d3 scale changed the naming scheme for scale from "linear" -> "scaleLinear" etc.
   var capitalize = function (s) {
@@ -15,7 +16,7 @@ function toNewName(scale) {
   return "scale".concat(capitalize(scale));
 }
 
-function validScale(scale) {
+export function validScale(scale) {
   if (typeof scale === "function") {
     return _isFunction(scale.copy) && _isFunction(scale.domain) && _isFunction(scale.range);
   } else if (typeof scale === "string") {
@@ -75,7 +76,13 @@ function getScaleTypeFromData(props, axis) {
 
 
 export function getScaleFromName(name) {
-  return validScale(name) ? d3Scale[toNewName(name)]() : d3Scale.scaleLinear();
+  if (validScale(name)) {
+    var methodName = toNewName(name); // @ts-expect-error scaleTime is not directly compatible with our D3Scale definition
+
+    return d3Scale[methodName]();
+  }
+
+  return d3Scale.scaleLinear();
 }
 export function getBaseScale(props, axis) {
   var scale = getScaleFromProps(props, axis);
@@ -85,7 +92,7 @@ export function getBaseScale(props, axis) {
   }
 
   var defaultScale = getScaleFromDomain(props, axis) || getScaleTypeFromData(props, axis);
-  return d3Scale[toNewName(defaultScale)]();
+  return getScaleFromName(defaultScale);
 }
 export function getDefaultScale() {
   return d3Scale.scaleLinear();
@@ -98,7 +105,7 @@ export function getScaleFromProps(props, axis) {
   var scale = props.scale[axis] || props.scale;
 
   if (validScale(scale)) {
-    return _isFunction(scale) ? scale : d3Scale[toNewName(scale)]();
+    return _isFunction(scale) ? scale : getScaleFromName(scale);
   }
 
   return undefined;
@@ -132,4 +139,5 @@ export function getType(scale) {
     return scale[type.method] !== undefined;
   })[0];
   return scaleType ? scaleType.name : undefined;
-}
+}
+//# sourceMappingURL=scale.js.map

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

@@ -1,23 +1,25 @@
-import * as React from "react";
-import { DomainPropType, ScalePropType, SVGCoordinateType } from "./types";
-
-export function getParentSVG(evt: React.SyntheticEvent): string;
-
-export function getSVGEventCoordinates(
-  evt: React.SyntheticEvent,
-  svg?: SVGElement
-): SVGCoordinateType;
-
-export function getDomainCoordinates(
-  props: any,
-  domain?: DomainPropType
-): DomainPropType;
-
-export function getDataCoordinates(
-  props: any,
-  scale: ScalePropType,
-  x: number,
-  y: number
-): SVGCoordinateType;
-
-export function getBounds(props: any): SVGCoordinateType;
+import React from "react";
+import { VictoryCommonProps } from "./index";
+import type { DomainPropType, ScaleXYPropType } from "../types/prop-types";
+export declare function getParentSVG(evt: Pick<React.SyntheticEvent, "target"> & Partial<Pick<React.SyntheticEvent, "nativeEvent">>): SVGElement;
+export declare function getSVGEventCoordinates(evt: React.SyntheticEvent, svg?: SVGElement): SVGCoordinateType;
+export declare function getDomainCoordinates(props: Pick<VictoryCommonProps, "scale" | "horizontal">, domain?: DomainPropType): DomainPropType;
+export declare function getDataCoordinates(props: any, scale: ScaleXYPropType, x: number, y: number): SVGCoordinateType;
+export declare function getBounds(props: ComputedCommonProps): SVGCoordinateBounds;
+export declare type SVGCoordinateType = {
+    x: number;
+    y: number;
+};
+export declare type SVGCoordinateBounds = {
+    x: readonly [number, number];
+    y: readonly [number, number];
+};
+declare type ComputedCommonProps = {
+    scale: ScaleXYPropType;
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+};
+export {};
+//# sourceMappingURL=selection.d.ts.map

package/es/victory-util/selection.js

@@ -1,6 +1,6 @@
-/* eslint-disable no-use-before-define */
-import * as Collection from "./collection"; // Private Functions
+import { Collection } from "./index";
 
+// Private Functions
 function transformTarget(target, matrix, dimension) {
   var a = matrix.a,
       d = matrix.d,
@@ -11,11 +11,20 @@ function transformTarget(target, matrix, dimension) {
 
 function getTransformationMatrix(svg) {
   return svg.getScreenCTM().inverse();
+}
+
+function isNativeTouchEvent(nativeEvent) {
+  return !!(nativeEvent && nativeEvent.identifier !== undefined);
+}
+
+function isReactTouchEvent(evt) {
+  return evt.changedTouches && evt.changedTouches.length > 0;
 } // Exported Functions
 
 
 export function getParentSVG(evt) {
-  if (evt.nativeEvent && evt.nativeEvent.identifier !== undefined) {
+  if (isNativeTouchEvent(evt.nativeEvent)) {
+    // @ts-expect-error Seems like a superfluous check.
     return undefined;
   }
 
@@ -30,7 +39,7 @@ export function getParentSVG(evt) {
   return getParent(evt.target);
 }
 export function getSVGEventCoordinates(evt, svg) {
-  if (evt.nativeEvent && evt.nativeEvent.identifier !== undefined) {
+  if (isNativeTouchEvent(evt.nativeEvent)) {
     // react-native override. relies on the RN.View being the _exact_ same size as its child SVG.
     // this should be fine: the svg is the only child of View and the View shirks to its children
     return {
@@ -39,24 +48,25 @@ export function getSVGEventCoordinates(evt, svg) {
     };
   }
 
-  evt = evt.changedTouches && evt.changedTouches.length ? evt.changedTouches[0] : evt;
-  svg = svg || getParentSVG(evt);
+  var location = isReactTouchEvent(evt) ? evt.changedTouches[0] : evt;
+  svg = svg || getParentSVG(location);
   var matrix = getTransformationMatrix(svg);
   return {
-    x: transformTarget(evt.clientX, matrix, "x"),
-    y: transformTarget(evt.clientY, matrix, "y")
+    x: transformTarget(location.clientX, matrix, "x"),
+    y: transformTarget(location.clientY, matrix, "y")
   };
 }
 export function getDomainCoordinates(props, domain) {
-  var scale = props.scale,
-      horizontal = props.horizontal;
-  domain = domain || {
+  var horizontal = props.horizontal;
+  var scale = props.scale; // FIXME: add support for DomainTuple: [number, number]
+
+  var domainObj = domain || {
     x: scale.x.domain(),
     y: scale.y.domain()
   };
   return {
-    x: horizontal ? [scale.y(domain.y[0]), scale.y(domain.y[1])] : [scale.x(domain.x[0]), scale.x(domain.x[1])],
-    y: horizontal ? [scale.x(domain.x[0]), scale.x(domain.x[1])] : [scale.y(domain.y[0]), scale.y(domain.y[1])]
+    x: horizontal ? [scale.y(domainObj.y[0]), scale.y(domainObj.y[1])] : [scale.x(domainObj.x[0]), scale.x(domainObj.x[1])],
+    y: horizontal ? [scale.x(domainObj.x[0]), scale.x(domainObj.x[1])] : [scale.y(domainObj.y[0]), scale.y(domainObj.y[1])]
   };
 } // eslint-disable-next-line max-params
 
@@ -101,4 +111,5 @@ export function getBounds(props) {
     x: makeBound(point1.x, point2.x),
     y: makeBound(point1.y, point2.y)
   };
-}
+}
+//# sourceMappingURL=selection.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * Given an object with CSS/SVG transform definitions, return the string value
+ * for use with the `transform` CSS property or SVG attribute. Note that we
+ * can't always guarantee the order will match the author's intended order, so
+ * authors should only use the object notation if they know that their transform
+ * is commutative or that there is only one.
+ * @param {Object} obj An object of transform definitions.
+ * @returns {String} The generated transform string.
+ */
+export declare const toTransformString: (obj: any, ...more: any[]) => any;
+/**
+ * Given the name of a color scale, getColorScale will return an array
+ * of 5 hex string values in that color scale. If no 'name' parameter
+ * is given, it will return the Victory default grayscale.
+ * @param {String} name The name of the color scale to return (optional).
+ * @returns {Array} An array of 5 hex string values composing a color scale.
+ */
+export declare function getColorScale(name: any): any;
+//# sourceMappingURL=style.d.ts.map

package/es/victory-util/style.js

@@ -53,4 +53,5 @@ export function getColorScale(name) {
     green: ["#354722", "#466631", "#649146", "#8AB25C", "#A9C97E"]
   };
   return name ? scales[name] : scales.grayscale;
-}
+}
+//# sourceMappingURL=style.js.map

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

@@ -1,8 +1,37 @@
-import { TextSizeStyleInterface } from "./types";
-
-export function approximateTextSize(
-  text: string,
-  style?: TextSizeStyleInterface
-): { width: number; height: number };
-
-export function convertLengthToPixels(length: string, fontSize: number): number;
+/**
+ * Convert length-type parameters from specific measurement units to pixels
+ * @param  {string} length Css length string value.
+ * @param  {number} fontSize Current text font-size.
+ * @returns {number} Approximate Css length in pixels.
+ */
+export declare const convertLengthToPixels: (length: string, fontSize?: number) => number;
+export interface TextSizeStyleInterface {
+    angle?: number;
+    characterConstant?: string;
+    fontFamily?: string;
+    fontSize?: number | string;
+    letterSpacing?: string;
+    lineHeight?: number;
+}
+export declare const _approximateTextSizeInternal: {
+    impl: (text: string | string[], style?: TextSizeStyleInterface) => {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Predict text size by font params.
+ * @param {string|string[]} text Content for width calculation.
+ * @param {Object} style Text styles, ,fontFamily, fontSize, etc.
+ * @param {string} style.fontFamily Text fontFamily.
+ * @param {(number|string)} style.fontSize Text fontSize.
+ * @param {number} style.angle Text rotate angle.
+ * @param {string} style.letterSpacing Text letterSpacing(space between letters).
+ * @param {number} style.lineHeight Line height coefficient.
+ * @returns {number} Approximate text label height.
+ */
+export declare const approximateTextSize: (text: string | string[], style?: TextSizeStyleInterface) => {
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=textsize.d.ts.map

package/es/victory-util/textsize.js

@@ -182,8 +182,10 @@ var _getSizeWithRotate = function (axisSize, dependentSize, angle) {
 
 
 export var convertLengthToPixels = function (length, fontSize) {
-  var attribute = length.match(/[a-zA-Z%]+/) && length.match(/[a-zA-Z%]+/)[0];
-  var value = length.match(/[0-9.,]+/);
+  var _length$match;
+
+  var attribute = (_length$match = length.match(/[a-zA-Z%]+/)) === null || _length$match === void 0 ? void 0 : _length$match[0];
+  var value = Number(length.match(/[0-9.,]+/));
   var result;
 
   if (!attribute) {
@@ -249,9 +251,9 @@ var _approximateTextHeightInternal = function (text, style) {
     var height = containsCaps ? lineStyle.fontSize * coefficients.lineCapitalCoef : lineStyle.fontSize;
     return total + lineStyle.lineHeight * height;
   }, 0);
-}; // Stubbable implementation.
-
+};
 
+// Stubbable implementation.
 export var _approximateTextSizeInternal = {
   impl: function (text, style) {
     var angle = Array.isArray(style) ? style[0] && style[0].angle : style && style.angle;
@@ -270,7 +272,7 @@ export var _approximateTextSizeInternal = {
 };
 /**
  * Predict text size by font params.
- * @param {string} text Content for width calculation.
+ * @param {string|string[]} text Content for width calculation.
  * @param {Object} style Text styles, ,fontFamily, fontSize, etc.
  * @param {string} style.fontFamily Text fontFamily.
  * @param {(number|string)} style.fontSize Text fontSize.
@@ -282,4 +284,5 @@ export var _approximateTextSizeInternal = {
 
 export var approximateTextSize = function (text, style) {
   return _approximateTextSizeInternal.impl(text, style);
-};
+};
+//# sourceMappingURL=textsize.js.map

package/es/victory-util/timer-context.d.ts

@@ -9,3 +9,4 @@ declare const TimerContext: React.Context<{
     animationTimer: Timer;
 }>;
 export default TimerContext;
+//# sourceMappingURL=timer-context.d.ts.map

package/es/victory-util/timer-context.js

@@ -10,4 +10,5 @@ var TimerContext = /*#__PURE__*/React.createContext({
   animationTimer: new Timer()
 });
 TimerContext.displayName = "TimerContext";
-export default TimerContext;
+export default TimerContext;
+//# sourceMappingURL=timer-context.js.map

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

@@ -1,4 +1,4 @@
-declare type Callback = (elapsed: number, duration: number) => void;
+declare type TimerCallback = (elapsed: number, duration: number) => void;
 export default class Timer {
     private shouldAnimate;
     private readonly subscribers;
@@ -10,7 +10,8 @@ export default class Timer {
     loop: () => void;
     start(): void;
     stop(): void;
-    subscribe(callback: Callback, duration: number): number;
+    subscribe(callback: TimerCallback, duration: number): number;
     unsubscribe(id: any): void;
 }
 export {};
+//# sourceMappingURL=timer.d.ts.map

package/es/victory-util/timer.js

@@ -84,4 +84,5 @@ var Timer = /*#__PURE__*/function () {
   return Timer;
 }();
 
-export { Timer as default };
+export { Timer as default };
+//# sourceMappingURL=timer.js.map

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

@@ -0,0 +1,49 @@
+import { AnimatePropTypeInterface } from "../types/prop-types";
+/**
+ * If a parent component has animation enabled, calculate the transitions
+ * for any data of any child component that supports data transitions.
+ * Data transitions are defined as any two datasets where data nodes exist
+ * in the first set and not the second, in the second and not the first,
+ * or both.
+ *
+ * @param  {Children}  oldChildren   this.props.children from old props
+ * @param  {Children}  nextChildren  this.props.children from next props
+ *
+ * @return {Object}                  Object with the following properties:
+ *                                    - nodesWillExit
+ *                                    - nodesWillEnter
+ *                                    - childrenTransitions
+ *                                    - nodesShouldEnter
+ */
+export declare function getInitialTransitionState(oldChildren: any, nextChildren: any): {
+    nodesWillExit: boolean;
+    nodesWillEnter: boolean;
+    childrenTransitions: any;
+    nodesShouldEnter: boolean;
+};
+declare type TransitionProps = {
+    data: any;
+    animate?: AnimatePropTypeInterface;
+    clipWidth?: number;
+};
+/**
+ * getTransitionPropsFactory - putting the Java in JavaScript.  This will return a
+ * function that returns prop transformations for a child, given that child's props
+ * and its index in the parent's children array.
+ *
+ * In particular, this will include an `animate` object that is set appropriately
+ * so that each child will be synchronized for each stage of a transition
+ * animation.  It will also include a transformed `data` object, where each datum
+ * is transformed by `animate.onExit` and `animate.onEnter` `before` and `after`
+ * functions.
+ *
+ * @param  {Object}  props       `this.props` for the parent component.
+ * @param  {Object} state        `this.state` for the parent component.
+ * @param  {Function} setState    Function that, when called, will `this.setState` on
+ *                                 the parent component with the provided object.
+ *
+ * @return {Function}              Child-prop transformation function.
+ */
+export declare function getTransitionPropsFactory(props: any, state: any, setState: any): (child: any, index: any) => TransitionProps;
+export {};
+//# sourceMappingURL=transitions.d.ts.map