victory-core 36.9.2 → 37.0.0

package/es/victory-accessible-group/victory-accessible-group.js

@@ -1,19 +1,13 @@
-var _excluded = ["desc", "children", "tabIndex", "className"];
-
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-
 import React from "react";
-export var VictoryAccessibleGroup = function (_ref) {
-  var desc = _ref.desc,
-      children = _ref.children,
-      tabIndex = _ref.tabIndex,
-      _ref$className = _ref.className,
-      className = _ref$className === void 0 ? "VictoryAccessibleGroup" : _ref$className,
-      props = _objectWithoutProperties(_ref, _excluded);
-
-  var descId = desc && (props["aria-describedby"] || desc.split(" ").join("-"));
+export const VictoryAccessibleGroup = _ref => {
+  let {
+    desc,
+    children,
+    tabIndex,
+    className = "VictoryAccessibleGroup",
+    ...props
+  } = _ref;
+  const descId = desc && (props["aria-describedby"] || desc.split(" ").join("-"));
   return desc ? /*#__PURE__*/React.createElement("g", {
     "aria-label": props["aria-label"],
     "aria-describedby": descId,

package/es/victory-animation/util.js

@@ -1,33 +1,28 @@
 import _orderBy from "lodash/orderBy";
 import _isPlainObject from "lodash/isPlainObject";
 import { interpolate } from "victory-vendor/d3-interpolate";
-export var isInterpolatable = function (obj) {
+export const isInterpolatable = function (obj) {
   // d3 turns null into 0 and undefined into NaN, which we don't want.
   if (obj !== null) {
     switch (typeof obj) {
       case "undefined":
         return false;
-
       case "number":
         // The standard `isNaN` is fine in this case since we already know the
         // type is number.
         return !isNaN(obj) && obj !== Number.POSITIVE_INFINITY && obj !== Number.NEGATIVE_INFINITY;
-
       case "string":
         // d3 might not *actually* be able to interpolate the string, but it
         // won't cause any issues to let it try.
         return true;
-
       case "boolean":
         // d3 turns Booleans into integers, which we don't want. Sure, we could
         // interpolate from 0 -> 1, but we'd be sending a non-Boolean to
         // something expecting a Boolean.
         return false;
-
       case "object":
         // Don't try to interpolate class instances (except Date or Array).
         return obj instanceof Date || Array.isArray(obj) || _isPlainObject(obj);
-
       case "function":
         // Careful! There may be extra properties on function objects that the
         // component expects to access - for instance, it may be a `d3.scale()`
@@ -42,9 +37,9 @@ export var isInterpolatable = function (obj) {
         return true;
     }
   }
-
   return false;
 };
+
 /**
  * Interpolate immediately to the end value at the given step `when`.
  * Some nicer default behavior might be to jump at the halfway point or return
@@ -60,13 +55,15 @@ export var isInterpolatable = function (obj) {
  * @param {Number} when - Step value (0 to 1) at which to jump to `b`.
  * @returns {Function} An interpolation function.
  */
-
-export var interpolateImmediate = function (a, b) {
-  var when = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+export const interpolateImmediate = function (a, b, when) {
+  if (when === void 0) {
+    when = 0;
+  }
   return function (t) {
     return t < when ? a : b;
   };
 };
+
 /**
  * Interpolate to or from a function. The interpolated value will be a function
  * that calls `a` (if it's a function) and `b` (if it's a function) and calls
@@ -79,21 +76,20 @@ export var interpolateImmediate = function (a, b) {
  * @param {any} b - End value.
  * @returns {Function} An interpolation function.
  */
-
-export var interpolateFunction = function (a, b) {
+export const interpolateFunction = function (a, b) {
   return function (t) {
     if (t >= 1) {
       return b;
     }
-
     return function () {
       /* eslint-disable no-invalid-this, prefer-rest-params */
-      var aval = typeof a === "function" ? a.apply(this, arguments) : a;
-      var bval = typeof b === "function" ? b.apply(this, arguments) : b;
+      const aval = typeof a === "function" ? a.apply(this, arguments) : a;
+      const bval = typeof b === "function" ? b.apply(this, arguments) : b;
       return interpolate(aval, bval)(t);
     };
   };
 };
+
 /**
  * Interpolate to or from an object. This method is a modification of the object interpolator in
  * d3-interpolate https://github.com/d3/d3-interpolate/blob/master/src/object.js. This interpolator
@@ -104,44 +100,36 @@ export var interpolateFunction = function (a, b) {
  * @param {any} endValue - End value.
  * @returns {Function} An interpolation function.
  */
-
-export var interpolateObject = function (startValue, endValue) {
-  var interpolateTypes = function (x, y) {
+export const interpolateObject = function (startValue, endValue) {
+  const interpolateTypes = (x, y) => {
     if (x === y || !isInterpolatable(x) || !isInterpolatable(y)) {
       return interpolateImmediate(x, y);
     }
-
     if (typeof x === "function" || typeof y === "function") {
       return interpolateFunction(x, y);
     }
-
     if (typeof x === "object" && _isPlainObject(x) || typeof y === "object" && _isPlainObject(y)) {
       return interpolateObject(x, y);
     }
-
     return interpolate(x, y);
-  }; // When the value is an array, attempt to sort by "key" so that animating nodes may be identified
-  // based on "key" instead of index
-
+  };
 
-  var keyData = function (val) {
+  // When the value is an array, attempt to sort by "key" so that animating nodes may be identified
+  // based on "key" instead of index
+  const keyData = val => {
     return Array.isArray(val) ? _orderBy(val, "key") : val;
   };
-
-  var i = {};
-  var c = {};
-  var a = startValue;
-  var b = endValue;
-  var k;
-
+  const i = {};
+  const c = {};
+  let a = startValue;
+  let b = endValue;
+  let k;
   if (a === null || typeof a !== "object") {
     a = {};
   }
-
   if (b === null || typeof b !== "object") {
     b = {};
   }
-
   for (k in b) {
     if (k in a) {
       i[k] = interpolateTypes(keyData(a[k]), keyData(b[k]));
@@ -149,22 +137,20 @@ export var interpolateObject = function (startValue, endValue) {
       c[k] = b[k];
     }
   }
-
   return function (t) {
     for (k in i) {
       c[k] = i[k](t);
     }
-
     return c;
   };
 };
-export var interpolateString = function (a, b) {
-  var format = function (val) {
+export const interpolateString = function (a, b) {
+  const format = val => {
     return typeof val === "string" ? val.replace(/,/g, "") : val;
   };
-
   return interpolate(format(a), format(b));
 };
+
 /**
  * By default, the list of interpolators used by `d3.interpolate` has a few
  * downsides:
@@ -188,28 +174,23 @@ export var interpolateString = function (a, b) {
  * @param {any} b - End value.
  * @returns {Function|undefined} An interpolation function, if necessary.
  */
-
-export var victoryInterpolator = function (a, b) {
+export const victoryInterpolator = function (a, b) {
   // If the values are strictly equal, or either value is not interpolatable,
   // just use either the start value `a` or end value `b` at every step, as
   // there is no reasonable in-between value.
   if (a === b || !isInterpolatable(a) || !isInterpolatable(b)) {
     return interpolateImmediate(a, b);
   }
-
   if (typeof a === "function" || typeof b === "function") {
     return interpolateFunction(a, b);
   }
-
   if (_isPlainObject(a) || _isPlainObject(b)) {
     // @ts-expect-error These generics are tough, but they work :)
     return interpolateObject(a, b);
   }
-
   if (typeof a === "string" || typeof b === "string") {
     return interpolateString(a, b);
-  } // @ts-expect-error These generics are tough, but they work :)
-
-
+  }
+  // @ts-expect-error These generics are tough, but they work :)
   return interpolate(a, b);
 };

package/es/victory-animation/victory-animation.js

@@ -1,73 +1,60 @@
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-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; }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
 import React from "react";
 import * as d3Ease from "victory-vendor/d3-ease";
 import { victoryInterpolator } from "./util";
 import TimerContext from "../victory-util/timer-context";
+
 /**
  * Single animation object to interpolate
  */
 
+/**
+ * Animation styles to interpolate
+ */
+
 /** d3-ease changed the naming scheme for ease from "linear" -> "easeLinear" etc. */
-var formatAnimationName = function (name) {
-  var capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
-  return "ease".concat(capitalizedName);
+const formatAnimationName = name => {
+  const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+  return `ease${capitalizedName}`;
 };
-
-var DEFAULT_DURATION = 1000;
-export var VictoryAnimation = function (_ref) {
-  var _ref$duration = _ref.duration,
-      duration = _ref$duration === void 0 ? DEFAULT_DURATION : _ref$duration,
-      _ref$easing = _ref.easing,
-      easing = _ref$easing === void 0 ? "quadInOut" : _ref$easing,
-      _ref$delay = _ref.delay,
-      delay = _ref$delay === void 0 ? 0 : _ref$delay,
-      data = _ref.data,
-      children = _ref.children,
-      onEnd = _ref.onEnd;
-
-  var _React$useState = React.useState({
+const DEFAULT_DURATION = 1000;
+export const VictoryAnimation = _ref => {
+  let {
+    duration = DEFAULT_DURATION,
+    easing = "quadInOut",
+    delay = 0,
+    data,
+    children,
+    onEnd
+  } = _ref;
+  const [state, setState] = React.useState({
     data: Array.isArray(data) ? data[0] : data,
     animationInfo: {
       progress: 0,
       animating: false
     }
-  }),
-      _React$useState2 = _slicedToArray(_React$useState, 2),
-      state = _React$useState2[0],
-      setState = _React$useState2[1];
-
-  var timer = React.useContext(TimerContext).animationTimer;
-  var queue = React.useRef(Array.isArray(data) ? data.slice(1) : []);
-  var interpolator = React.useRef(null);
-  var loopID = React.useRef(undefined);
-  var ease = d3Ease[formatAnimationName(easing)];
-  React.useEffect(function () {
+  });
+  const timer = React.useContext(TimerContext).animationTimer;
+  const queue = React.useRef(Array.isArray(data) ? data.slice(1) : []);
+  const interpolator = React.useRef(null);
+  const loopID = React.useRef(undefined);
+  const ease = d3Ease[formatAnimationName(easing)];
+  React.useEffect(() => {
     // Length check prevents us from triggering `onEnd` in `traverseQueue`.
     if (queue.current.length) {
       traverseQueue();
-    } // Clean up the animation loop
-
+    }
 
-    return function () {
+    // Clean up the animation loop
+    return () => {
       if (loopID.current) {
         timer.unsubscribe(loopID.current);
       } else {
         timer.stop();
       }
-    }; // eslint-disable-next-line react-hooks/exhaustive-deps
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
-  React.useEffect(function () {
+  React.useEffect(() => {
     // If the previous animation didn't finish, force it to complete before starting a new one
     if (interpolator.current && state.animationInfo && state.animationInfo.progress < 1) {
       setState({
@@ -80,23 +67,24 @@ export var VictoryAnimation = function (_ref) {
       });
     } else {
       // Cancel existing loop if it exists
-      timer.unsubscribe(loopID.current); // Set the tween queue to the new data
-
-      queue.current = Array.isArray(data) ? data : [data]; // Start traversing the tween queue
-
+      timer.unsubscribe(loopID.current);
+      // Set the tween queue to the new data
+      queue.current = Array.isArray(data) ? data : [data];
+      // Start traversing the tween queue
       traverseQueue();
-    } // eslint-disable-next-line react-hooks/exhaustive-deps
-
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [data]);
-
-  var traverseQueue = function () {
+  const traverseQueue = () => {
     if (queue.current.length) {
-      var nextData = queue.current[0]; // Compare cached version to next props
+      const nextData = queue.current[0];
 
-      interpolator.current = victoryInterpolator(state.data, nextData); // Reset step to zero
+      // Compare cached version to next props
+      interpolator.current = victoryInterpolator(state.data, nextData);
 
+      // Reset step to zero
       if (delay) {
-        setTimeout(function () {
+        setTimeout(() => {
           loopID.current = timer.subscribe(functionToBeRunEachFrame, duration);
         }, delay);
       } else {
@@ -106,13 +94,12 @@ export var VictoryAnimation = function (_ref) {
       onEnd();
     }
   };
+  const functionToBeRunEachFrame = elapsed => {
+    if (!interpolator.current) return;
 
-  var functionToBeRunEachFrame = function (elapsed) {
-    if (!interpolator.current) return; // Step can generate imprecise values, sometimes greater than 1
+    // Step can generate imprecise values, sometimes greater than 1
     // if this happens set the state to 1 and return, cancelling the timer
-
-    var step = duration ? elapsed / duration : 1;
-
+    const step = duration ? elapsed / duration : 1;
     if (step >= 1) {
       setState({
         data: interpolator.current(1),
@@ -122,19 +109,17 @@ export var VictoryAnimation = function (_ref) {
           terminating: true
         }
       });
-
       if (loopID.current) {
         timer.unsubscribe(loopID.current);
       }
-
       queue.current.shift();
       traverseQueue();
       return;
-    } // If we're not at the end of the timer, set the state by passing
+    }
+
+    // If we're not at the end of the timer, set the state by passing
     // current step value that's transformed by the ease function to the
     // interpolator, which is cached for performance whenever props are received
-
-
     setState({
       data: interpolator.current(ease(step)),
       animationInfo: {
@@ -143,6 +128,5 @@ export var VictoryAnimation = function (_ref) {
       }
     });
   };
-
   return children(state.data, state.animationInfo);
 };