victory-core 36.9.2 → 37.0.0

package/lib/victory-util/transitions.js

@@ -5,39 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getInitialTransitionState = getInitialTransitionState;
 exports.getTransitionPropsFactory = getTransitionPropsFactory;
-
 var _identity2 = _interopRequireDefault(require("lodash/identity"));
-
 var _defaults2 = _interopRequireDefault(require("lodash/defaults"));
-
 var _react = _interopRequireDefault(require("react"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function getDatumKey(datum, idx) {
   return (datum.key || idx).toString();
 }
-
 function getKeyedData(data) {
-  return data.reduce(function (keyedData, datum, idx) {
-    var key = getDatumKey(datum, idx);
+  return data.reduce((keyedData, datum, idx) => {
+    const key = getDatumKey(datum, idx);
     keyedData[key] = datum;
     return keyedData;
   }, {});
 }
-
 function getKeyedDataDifference(a, b) {
-  var hasDifference = false;
-  var difference = Object.keys(a).reduce(function (_difference, key) {
+  let hasDifference = false;
+  const difference = Object.keys(a).reduce((_difference, key) => {
     if (!(key in b)) {
       hasDifference = true;
       _difference[key] = true;
     }
-
     return _difference;
   }, {});
   return hasDifference && difference;
 }
+
 /**
  * Calculate which data-points exist in oldData and not nextData -
  * these are the `exiting` data-points.  Also calculate which
@@ -51,24 +44,21 @@ function getKeyedDataDifference(a, b) {
  *                           entering[datum.key] will be true if the data is
  *                           entering, and similarly for `exiting`.
  */
-
-
 function getNodeTransitions(oldData, nextData) {
-  var oldDataKeyed = oldData && getKeyedData(oldData);
-  var nextDataKeyed = nextData && getKeyedData(nextData);
+  const oldDataKeyed = oldData && getKeyedData(oldData);
+  const nextDataKeyed = nextData && getKeyedData(nextData);
   return {
     entering: oldDataKeyed && getKeyedDataDifference(nextDataKeyed, oldDataKeyed),
     exiting: nextDataKeyed && getKeyedDataDifference(oldDataKeyed, nextDataKeyed)
   };
 }
-
 function getChildData(child) {
   if (child.type && child.type.getData) {
     return child.type.getData(child.props);
   }
-
   return child.props && child.props.data || false;
 }
+
 /**
  * If a parent component has animation enabled, calculate the transitions
  * for any data of any child component that supports data transitions.
@@ -85,21 +75,17 @@ function getChildData(child) {
  *                                    - childrenTransitions
  *                                    - nodesShouldEnter
  */
-
-
 function getInitialTransitionState(oldChildren, nextChildren) {
-  var nodesWillExit = false;
-  var nodesWillEnter = false;
-
-  var getTransition = function (oldChild, newChild) {
+  let nodesWillExit = false;
+  let nodesWillEnter = false;
+  const getTransition = (oldChild, newChild) => {
     if (!newChild || oldChild.type !== newChild.type) {
       return {};
     }
-
-    var _ref = getNodeTransitions(getChildData(oldChild), getChildData(newChild)) || {},
-        entering = _ref.entering,
-        exiting = _ref.exiting;
-
+    const {
+      entering,
+      exiting
+    } = getNodeTransitions(getChildData(oldChild), getChildData(newChild)) || {};
     nodesWillExit = nodesWillExit || !!exiting;
     nodesWillEnter = nodesWillEnter || !!entering;
     return {
@@ -107,23 +93,20 @@ function getInitialTransitionState(oldChildren, nextChildren) {
       exiting: exiting || false
     };
   };
-
-  var getTransitionsFromChildren = function (old, next) {
-    return old.map(function (child, idx) {
+  const getTransitionsFromChildren = (old, next) => {
+    return old.map((child, idx) => {
       if (child && child.props && child.props.children && next[idx]) {
         return getTransitionsFromChildren(_react.default.Children.toArray(old[idx].props.children), _react.default.Children.toArray(next[idx].props.children));
-      } // get Transition entering and exiting nodes
-
-
+      }
+      // get Transition entering and exiting nodes
       return getTransition(child, next[idx]);
     });
   };
-
-  var childrenTransitions = getTransitionsFromChildren(_react.default.Children.toArray(oldChildren), _react.default.Children.toArray(nextChildren));
+  const childrenTransitions = getTransitionsFromChildren(_react.default.Children.toArray(oldChildren), _react.default.Children.toArray(nextChildren));
   return {
-    nodesWillExit: nodesWillExit,
-    nodesWillEnter: nodesWillEnter,
-    childrenTransitions: childrenTransitions,
+    nodesWillExit,
+    nodesWillEnter,
+    childrenTransitions,
     // TODO: This may need to be refactored for the following situation.
     //       The component receives new props, and the data provided
     //       is a perfect match for the previous data and domain except
@@ -132,32 +115,27 @@ function getInitialTransitionState(oldChildren, nextChildren) {
     nodesShouldEnter: false
   };
 }
-
 function getInitialChildProps(animate, data) {
-  var after = animate.onEnter && animate.onEnter.after ? animate.onEnter.after : _identity2.default;
+  const after = animate.onEnter && animate.onEnter.after ? animate.onEnter.after : _identity2.default;
   return {
-    data: data.map(function (datum, idx) {
-      return Object.assign({}, datum, after(datum, idx, data));
-    })
+    data: data.map((datum, idx) => Object.assign({}, datum, after(datum, idx, data)))
   };
-} // eslint-disable-next-line max-params
-
+}
 
+// eslint-disable-next-line max-params
 function getChildBeforeLoad(animate, child, data, cb) {
-  var newAnimate = Object.assign({}, animate, {
+  const newAnimate = Object.assign({}, animate, {
     onEnd: cb
   });
-
   if (newAnimate && newAnimate.onLoad && !newAnimate.onLoad.duration) {
     return {
       animate: newAnimate,
-      data: data
+      data
     };
   }
-
-  var before = newAnimate.onLoad && newAnimate.onLoad.before ? newAnimate.onLoad.before : _identity2.default; // If nodes need to exit, transform them with the provided onLoad.before function.
-
-  var newData = data.map(function (datum, idx) {
+  const before = newAnimate.onLoad && newAnimate.onLoad.before ? newAnimate.onLoad.before : _identity2.default;
+  // If nodes need to exit, transform them with the provided onLoad.before function.
+  const newData = data.map((datum, idx) => {
     return Object.assign({}, datum, before(datum, idx, data));
   });
   return {
@@ -165,111 +143,104 @@ function getChildBeforeLoad(animate, child, data, cb) {
     data: newData,
     clipWidth: 0
   };
-} // eslint-disable-next-line max-params
-
+}
 
+// eslint-disable-next-line max-params
 function getChildOnLoad(animate, data, cb) {
-  var newAnimate = Object.assign({}, animate, {
+  const newAnimate = Object.assign({}, animate, {
     onEnd: cb
   });
-  var newData = data;
-
+  let newData = data;
   if (newAnimate && newAnimate.onLoad && !newAnimate.onLoad.duration) {
     return {
-      animate: animate,
-      data: data
+      animate,
+      data
     };
   }
-
-  var after = animate.onLoad && animate.onLoad.after ? animate.onLoad.after : _identity2.default; // If nodes need to exit, transform them with the provided onLoad.after function.
-
-  newData = data.map(function (datum, idx) {
+  const after = animate.onLoad && animate.onLoad.after ? animate.onLoad.after : _identity2.default;
+  // If nodes need to exit, transform them with the provided onLoad.after function.
+  newData = data.map((datum, idx) => {
     return Object.assign({}, datum, after(datum, idx, data));
   });
   return {
     animate: newAnimate,
     data: newData
   };
-} // eslint-disable-next-line max-params, max-len
-
+}
 
+// eslint-disable-next-line max-params, max-len
 function getChildPropsOnExit(animate, child, data, exitingNodes, cb) {
   // Whether or not _this_ child has exiting nodes, we want the exit-
   // transition for all children to have the same duration, delay, etc.
-  var onExit = animate && animate.onExit;
-  var newAnimate = Object.assign({}, animate, onExit);
-  var newData = data;
-
+  const onExit = animate && animate.onExit;
+  const newAnimate = Object.assign({}, animate, onExit);
+  let newData = data;
   if (exitingNodes) {
     // After the exit transition occurs, trigger the animations for
     // nodes that are neither exiting nor entering.
     animate.onEnd = cb;
-    var before = animate.onExit && animate.onExit.before ? animate.onExit.before : _identity2.default; // If nodes need to exit, transform them with the provided onExit.before function.
-
-    newData = data.map(function (datum, idx) {
-      var key = (datum.key || idx).toString();
+    const before = animate.onExit && animate.onExit.before ? animate.onExit.before : _identity2.default;
+    // If nodes need to exit, transform them with the provided onExit.before function.
+    newData = data.map((datum, idx) => {
+      const key = (datum.key || idx).toString();
       return exitingNodes[key] ? Object.assign({}, datum, before(datum, idx, data)) : datum;
     });
   }
-
   return {
     animate: newAnimate,
     data: newData
   };
-} // eslint-disable-next-line max-params,max-len
-
+}
 
+// eslint-disable-next-line max-params,max-len
 function getChildPropsBeforeEnter(animate, child, data, enteringNodes, cb) {
-  var newAnimate = animate;
-  var newData = data;
-
+  let newAnimate = animate;
+  let newData = data;
   if (enteringNodes) {
     // Perform a normal animation here, except - when it finishes - trigger
     // the transition for entering nodes.
     newAnimate = Object.assign({}, animate, {
       onEnd: cb
     });
-    var before = animate.onEnter && animate.onEnter.before ? animate.onEnter.before : _identity2.default; // We want the entering nodes to be included in the transition target
+    const before = animate.onEnter && animate.onEnter.before ? animate.onEnter.before : _identity2.default;
+    // We want the entering nodes to be included in the transition target
     // domain.  However, we may not want these nodes to be displayed initially,
     // so perform the `onEnter.before` transformation on each node.
-
-    newData = data.map(function (datum, idx) {
-      var key = (datum.key || idx).toString();
+    newData = data.map((datum, idx) => {
+      const key = (datum.key || idx).toString();
       return enteringNodes[key] ? Object.assign({}, datum, before(datum, idx, data)) : datum;
     });
   }
-
   return {
     animate: newAnimate,
     data: newData
   };
-} // eslint-disable-next-line max-params, max-len
-
+}
 
+// eslint-disable-next-line max-params, max-len
 function getChildPropsOnEnter(animate, data, enteringNodes, cb) {
   // Whether or not _this_ child has entering nodes, we want the entering-
   // transition for all children to have the same duration, delay, etc.
-  var onEnter = animate && animate.onEnter;
-  var newAnimate = Object.assign({}, animate, onEnter);
-  var newData = data;
-
+  const onEnter = animate && animate.onEnter;
+  const newAnimate = Object.assign({}, animate, onEnter);
+  let newData = data;
   if (enteringNodes) {
     // Old nodes have been transitioned to their new values, and the
     // domain should encompass the nodes that will now enter. So perform
     // the `onEnter.after` transformation on each node.
     newAnimate.onEnd = cb;
-    var after = newAnimate.onEnter && newAnimate.onEnter.after ? newAnimate.onEnter.after : _identity2.default;
-    newData = data.map(function (datum, idx) {
-      var key = getDatumKey(datum, idx);
+    const after = newAnimate.onEnter && newAnimate.onEnter.after ? newAnimate.onEnter.after : _identity2.default;
+    newData = data.map((datum, idx) => {
+      const key = getDatumKey(datum, idx);
       return enteringNodes[key] ? Object.assign({}, datum, after(datum, idx, data)) : datum;
     });
   }
-
   return {
     animate: newAnimate,
     data: newData
   };
 }
+
 /**
  * getTransitionPropsFactory - putting the Java in JavaScript.  This will return a
  * function that returns prop transformations for a child, given that child's props
@@ -288,118 +259,106 @@ function getChildPropsOnEnter(animate, data, enteringNodes, cb) {
  *
  * @return {Function}              Child-prop transformation function.
  */
-
-
 function getTransitionPropsFactory(props, state, setState) {
-  var nodesWillExit = state && state.nodesWillExit;
-  var nodesWillEnter = state && state.nodesWillEnter;
-  var nodesShouldEnter = state && state.nodesShouldEnter;
-  var nodesShouldLoad = state && state.nodesShouldLoad;
-  var nodesDoneLoad = state && state.nodesDoneLoad;
-  var childrenTransitions = state && state.childrenTransitions || [];
-  var transitionDurations = {
+  const nodesWillExit = state && state.nodesWillExit;
+  const nodesWillEnter = state && state.nodesWillEnter;
+  const nodesShouldEnter = state && state.nodesShouldEnter;
+  const nodesShouldLoad = state && state.nodesShouldLoad;
+  const nodesDoneLoad = state && state.nodesDoneLoad;
+  const childrenTransitions = state && state.childrenTransitions || [];
+  const transitionDurations = {
     enter: props.animate && props.animate.onEnter && props.animate.onEnter.duration,
     exit: props.animate && props.animate.onExit && props.animate.onExit.duration,
     load: props.animate && props.animate.onLoad && props.animate.onLoad.duration,
     move: props.animate && props.animate.duration
   };
-
-  var onLoad = function (child, data, animate) {
+  const onLoad = (child, data, animate) => {
     if (nodesShouldLoad) {
-      return getChildOnLoad(animate, data, function () {
+      return getChildOnLoad(animate, data, () => {
         setState({
           nodesShouldLoad: false,
           nodesDoneLoad: true
         });
       });
     }
-
-    return getChildBeforeLoad(animate, child, data, function () {
+    return getChildBeforeLoad(animate, child, data, () => {
       setState({
         nodesDoneLoad: true
       });
     });
-  }; // eslint-disable-next-line max-params
-
+  };
 
-  var onExit = function (nodes, child, data, animate) {
-    return getChildPropsOnExit(animate, child, data, nodes, function () {
+  // eslint-disable-next-line max-params
+  const onExit = (nodes, child, data, animate) => {
+    return getChildPropsOnExit(animate, child, data, nodes, () => {
       setState({
         nodesWillExit: false
       });
     });
-  }; // eslint-disable-next-line max-params
-
+  };
 
-  var onEnter = function (nodes, child, data, animate) {
+  // eslint-disable-next-line max-params
+  const onEnter = (nodes, child, data, animate) => {
     if (nodesShouldEnter) {
-      return getChildPropsOnEnter(animate, data, nodes, function () {
+      return getChildPropsOnEnter(animate, data, nodes, () => {
         setState({
           nodesWillEnter: false
         });
       });
     }
-
-    return getChildPropsBeforeEnter(animate, child, data, nodes, function () {
+    return getChildPropsBeforeEnter(animate, child, data, nodes, () => {
       setState({
         nodesShouldEnter: true
       });
     });
   };
-
-  var getChildTransitionDuration = function (child, type) {
-    var animate = child.props.animate;
-
+  const getChildTransitionDuration = function (child, type) {
+    const animate = child.props.animate;
     if (!child.type) {
       return {};
     }
-
-    var defaultTransitions = child.props && child.props.polar ? child.type.defaultPolarTransitions || child.type.defaultTransitions : child.type.defaultTransitions;
-
+    const defaultTransitions = child.props && child.props.polar ? child.type.defaultPolarTransitions || child.type.defaultTransitions : child.type.defaultTransitions;
     if (defaultTransitions) {
-      var animationDuration = animate[type] && animate[type].duration;
+      const animationDuration = animate[type] && animate[type].duration;
       return animationDuration !== undefined ? animationDuration : defaultTransitions[type] && defaultTransitions[type].duration;
     }
-
     return {};
-  }; // eslint-disable-next-line max-statements, complexity, max-len
-
+  };
 
+  // eslint-disable-next-line max-statements, complexity, max-len
   return function getTransitionProps(child, index) {
-    var data = getChildData(child) || [];
-    var animate = (0, _defaults2.default)({}, props.animate, child.props.animate);
-    var defaultTransitions = child.props.polar ? child.type.defaultPolarTransitions || child.type.defaultTransitions : child.type.defaultTransitions;
+    const data = getChildData(child) || [];
+    const animate = (0, _defaults2.default)({}, props.animate, child.props.animate);
+    const defaultTransitions = child.props.polar ? child.type.defaultPolarTransitions || child.type.defaultTransitions : child.type.defaultTransitions;
     animate.onExit = (0, _defaults2.default)({}, animate.onExit, defaultTransitions && defaultTransitions.onExit);
     animate.onEnter = (0, _defaults2.default)({}, animate.onEnter, defaultTransitions && defaultTransitions.onEnter);
     animate.onLoad = (0, _defaults2.default)({}, animate.onLoad, defaultTransitions && defaultTransitions.onLoad);
-    var childTransitions = childrenTransitions[index] || childrenTransitions[0];
-
+    const childTransitions = childrenTransitions[index] || childrenTransitions[0];
     if (!nodesDoneLoad) {
       // should do onLoad animation
-      var load = transitionDurations.load !== undefined ? transitionDurations.load : getChildTransitionDuration(child, "onLoad");
-      var animation = {
+      const load = transitionDurations.load !== undefined ? transitionDurations.load : getChildTransitionDuration(child, "onLoad");
+      const animation = {
         duration: load
       };
       return onLoad(child, data, Object.assign({}, animate, animation));
     } else if (nodesWillExit) {
-      var exitingNodes = childTransitions && childTransitions.exiting;
-      var exit = transitionDurations.exit !== undefined ? transitionDurations.exit : getChildTransitionDuration(child, "onExit"); // if nodesWillExit, but this child has no exiting nodes, set a delay instead of a duration
-
-      var _animation = exitingNodes ? {
+      const exitingNodes = childTransitions && childTransitions.exiting;
+      const exit = transitionDurations.exit !== undefined ? transitionDurations.exit : getChildTransitionDuration(child, "onExit");
+      // if nodesWillExit, but this child has no exiting nodes, set a delay instead of a duration
+      const animation = exitingNodes ? {
         duration: exit
       } : {
         delay: exit
       };
-
-      return onExit(exitingNodes, child, data, Object.assign({}, animate, _animation));
+      return onExit(exitingNodes, child, data, Object.assign({}, animate, animation));
     } else if (nodesWillEnter) {
-      var enteringNodes = childTransitions && childTransitions.entering;
-      var enter = transitionDurations.enter !== undefined ? transitionDurations.enter : getChildTransitionDuration(child, "onEnter");
-      var move = transitionDurations.move !== undefined ? transitionDurations.move : child.props.animate && child.props.animate.duration;
-      var _animation2 = {
+      const enteringNodes = childTransitions && childTransitions.entering;
+      const enter = transitionDurations.enter !== undefined ? transitionDurations.enter : getChildTransitionDuration(child, "onEnter");
+      const move = transitionDurations.move !== undefined ? transitionDurations.move : child.props.animate && child.props.animate.duration;
+      const animation = {
         duration: nodesShouldEnter && enteringNodes ? enter : move
       };
-      return onEnter(enteringNodes, child, data, Object.assign({}, animate, _animation2));
+      return onEnter(enteringNodes, child, data, Object.assign({}, animate, animation));
     } else if (!state && animate && animate.onExit) {
       // This is the initial render, and nodes may enter when props change. Because
       // animation interpolation is determined by old- and next- props, data may need
@@ -412,10 +371,9 @@ function getTransitionPropsFactory(props, state, setState) {
       //
       return getInitialChildProps(animate, data);
     }
-
     return {
-      animate: animate,
-      data: data
+      animate,
+      data
     };
   };
 }

package/lib/victory-util/type-helpers.js

@@ -9,36 +9,29 @@ exports.isDate = isDate;
 exports.isFunction = isFunction;
 exports.isKeyValueObject = isKeyValueObject;
 exports.isTuple = isTuple;
-
 function hasValueForAxis(value, axis) {
   if (typeof value === "object" && value !== null) {
     return axis in value;
   }
-
   return false;
 }
-
 function isTuple(value) {
   return Array.isArray(value) && value.length === 2;
 }
-
 function getValueForAxis(value, axis) {
   if (hasValueForAxis(value, axis)) {
     return value[axis];
   }
-
   return value;
-} // eslint-disable-next-line @typescript-eslint/ban-types
-
+}
 
+// eslint-disable-next-line @typescript-eslint/ban-types
 function isFunction(func) {
   return typeof func === "function";
 }
-
 function isDate(value) {
   return value instanceof Date;
 }
-
 function isKeyValueObject(datum) {
   return typeof datum === "object" && !Array.isArray(datum) && !(datum instanceof Date);
 }