victory-core 36.9.2 → 37.0.0

package/es/victory-util/transitions.js

@@ -1,31 +1,28 @@
 import _identity from "lodash/identity";
 import _defaults from "lodash/defaults";
 import React from "react";
-
 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
@@ -39,24 +36,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.
@@ -73,21 +67,17 @@ function getChildData(child) {
  *                                    - childrenTransitions
  *                                    - nodesShouldEnter
  */
-
-
 export 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 {
@@ -95,23 +85,20 @@ export 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.Children.toArray(old[idx].props.children), React.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.Children.toArray(oldChildren), React.Children.toArray(nextChildren));
+  const childrenTransitions = getTransitionsFromChildren(React.Children.toArray(oldChildren), React.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
@@ -120,32 +107,27 @@ export function getInitialTransitionState(oldChildren, nextChildren) {
     nodesShouldEnter: false
   };
 }
-
 function getInitialChildProps(animate, data) {
-  var after = animate.onEnter && animate.onEnter.after ? animate.onEnter.after : _identity;
+  const after = animate.onEnter && animate.onEnter.after ? animate.onEnter.after : _identity;
   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 : _identity; // 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 : _identity;
+  // 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 {
@@ -153,111 +135,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 : _identity; // 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 : _identity;
+  // 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 : _identity; // 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 : _identity;
+    // 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 : _identity; // We want the entering nodes to be included in the transition target
+    const before = animate.onEnter && animate.onEnter.before ? animate.onEnter.before : _identity;
+    // 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 : _identity;
-    newData = data.map(function (datum, idx) {
-      var key = getDatumKey(datum, idx);
+    const after = newAnimate.onEnter && newAnimate.onEnter.after ? newAnimate.onEnter.after : _identity;
+    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
@@ -276,120 +251,106 @@ function getChildPropsOnEnter(animate, data, enteringNodes, cb) {
  *
  * @return {Function}              Child-prop transformation function.
  */
-
-
 export 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 = _defaults({}, 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 = _defaults({}, props.animate, child.props.animate);
+    const defaultTransitions = child.props.polar ? child.type.defaultPolarTransitions || child.type.defaultTransitions : child.type.defaultTransitions;
     animate.onExit = _defaults({}, animate.onExit, defaultTransitions && defaultTransitions.onExit);
     animate.onEnter = _defaults({}, animate.onEnter, defaultTransitions && defaultTransitions.onEnter);
     animate.onLoad = _defaults({}, 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
@@ -402,10 +363,9 @@ export function getTransitionPropsFactory(props, state, setState) {
       //
       return getInitialChildProps(animate, data);
     }
-
     return {
-      animate: animate,
-      data: data
+      animate,
+      data
     };
   };
 }

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

@@ -2,7 +2,6 @@ export function hasValueForAxis(value, axis) {
   if (typeof value === "object" && value !== null) {
     return axis in value;
   }
-
   return false;
 }
 export function isTuple(value) {
@@ -12,10 +11,10 @@ export 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
 export function isFunction(func) {
   return typeof func === "function";
 }

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

@@ -1,34 +1,18 @@
-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; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-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 React from "react";
 import { evaluateProp } from "./helpers";
+
 /*
   USER_PROPS_SAFELIST is to contain any string deemed safe for user props.
   The startsWidth array will contain the start of any accepted user-prop that
   starts with these characters.
   The exactMatch will contain a list of exact prop names that are accepted.
 */
-
-var USER_PROPS_SAFELIST = {
+const USER_PROPS_SAFELIST = {
   startsWith: ["data-", "aria-"],
   exactMatch: []
-}; // Normally we'd use Template Literal Types, but we're avoiding it to maximize TS compatibility with TS < 4.1
+};
+
+// Normally we'd use Template Literal Types, but we're avoiding it to maximize TS compatibility with TS < 4.1
 
 // `data-${string}` | `aria-${string}`;
 
@@ -40,14 +24,15 @@ var USER_PROPS_SAFELIST = {
  * @returns {Boolean}: returns true if the key starts with an option or false if
  * otherwise
  */
-var doesPropStartWith = function (key) {
-  var startsWith = false;
-  USER_PROPS_SAFELIST.startsWith.forEach(function (starterString) {
-    var regex = new RegExp("\\b(".concat(starterString, ")(\\w|-)+"), "g");
+const doesPropStartWith = key => {
+  let startsWith = false;
+  USER_PROPS_SAFELIST.startsWith.forEach(starterString => {
+    const regex = new RegExp(`\\b(${starterString})(\\w|-)+`, "g");
     if (regex.test(key)) startsWith = true;
   });
   return startsWith;
 };
+
 /**
  * isExactMatch: checks to see if the given key matches any of the 'exactMatch'
  * items in the whitelist
@@ -56,34 +41,29 @@ var doesPropStartWith = function (key) {
  * @returns {Boolean}: return true if whitelist contains that key, otherwise
  * returns false.
  */
+const isExactMatch = key => USER_PROPS_SAFELIST.exactMatch.includes(key);
 
-
-var isExactMatch = function (key) {
-  return USER_PROPS_SAFELIST.exactMatch.includes(key);
-};
 /**
  * testIfSafeProp: tests prop's key against both startsWith and exactMatch values
  * @param {String} key: prop key to be tested against the whitelist
  * @returns {Boolean}: returns true if found in whitelist, otherwise returns false
  */
-
-
-var testIfSafeProp = function (key) {
+const testIfSafeProp = key => {
   if (doesPropStartWith(key) || isExactMatch(key)) return true;
   return false;
 };
+
 /**
  * Asserts that value is not null or undefined, throwing an error if it is.
  * @param value The value to assert
  * @param message The error message to throw
  */
-
-
 export function assert(value, message) {
   if (value === undefined || value === null) {
     throw new Error(message);
   }
 }
+
 /**
  * getSafeUserProps - function that takes in a props object and removes any
  * key-value entries that do not match filter strings in the USER_PROPS_SAFELIST
@@ -92,23 +72,19 @@ export function assert(value, message) {
  * @param {Object} props: props to be filtered against USER_PROPS_SAFELIST
  * @returns {Object}: object containing remaining acceptable props
  */
-
-export var getSafeUserProps = function (props) {
-  var propsToFilter = _objectSpread({}, props);
-
-  return Object.fromEntries(Object.entries(propsToFilter).filter(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 1),
-        key = _ref2[0];
-
+export const getSafeUserProps = props => {
+  const propsToFilter = {
+    ...props
+  };
+  return Object.fromEntries(Object.entries(propsToFilter).filter(_ref => {
+    let [key] = _ref;
     return testIfSafeProp(key);
-  }).map(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-        key = _ref4[0],
-        value = _ref4[1];
-
+  }).map(_ref2 => {
+    let [key, value] = _ref2;
     return [key, evaluateProp(value, props)];
   }));
 };
+
 /**
  * Wraps a component and adds safe user props
  *
@@ -116,7 +92,6 @@ export var getSafeUserProps = function (props) {
  * @param {Object} props: props to be filtered
  * @returns {ReactElement} modified component
  */
-
-export var withSafeUserProps = function (component, props) {
+export const withSafeUserProps = (component, props) => {
   return /*#__PURE__*/React.cloneElement(component, getSafeUserProps(props));
 };