victory-core 36.9.2 → 37.0.0

package/es/victory-util/axis.js

@@ -2,24 +2,10 @@ import _orderBy from "lodash/orderBy";
 import _uniq from "lodash/uniq";
 import _isObject from "lodash/isObject";
 import _defaults from "lodash/defaults";
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-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; }
-
 import React from "react";
 import * as Collection from "./collection";
 import * as Domain from "./domain";
 import * as Helpers from "./helpers";
-
 /**
  * Returns the first argument it receives
  * @param value The value to return
@@ -28,57 +14,55 @@ import * as Helpers from "./helpers";
 function identity(value) {
   return value;
 }
+
 /**
  * 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;
+  const {
+    dependentAxis
+  } = props;
   return dependentAxis ? "y" : "x";
 }
+
 /**
  * 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 function findAxisComponents(childComponents, predicate) {
-  var predicateFunction = predicate || identity;
-
-  var findAxes = function (children) {
-    return children.reduce(function (memo, child) {
+  const predicateFunction = predicate || identity;
+  const findAxes = children => {
+    return children.reduce((memo, child) => {
       if (child.type && child.type.role === "axis" && predicateFunction(child)) {
         return memo.concat(child);
       } else if (child.props && child.props.children) {
         return memo.concat(findAxes(React.Children.toArray(child.props.children)));
       }
-
       return memo;
     }, []);
   };
-
   return findAxes(childComponents);
 }
+
 /**
  * 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 function getAxisComponent(childComponents, axis) {
-  var matchesAxis = function (component) {
-    var type = component.type.getAxis(component.props);
+  const matchesAxis = component => {
+    const type = component.type.getAxis(component.props);
     return type === axis;
   };
-
   return findAxisComponents(childComponents, matchesAxis)[0];
 }
+
 /**
  * Returns all axis components of the desired axis type (x or y) along with any
  * parent components excluding VictoryChart
@@ -86,54 +70,48 @@ export function getAxisComponent(childComponents, axis) {
  * @param {String} type: desired axis either "dependent" or "independent".
  * @returns {ReactComponent} an axis component of the desired type or undefined
  */
-
 export function getAxisComponentsWithParent(childComponents, type) {
-  var matchesType = function (child) {
+  const matchesType = child => {
     return type === "dependent" ? child.props.dependentAxis : !child.props.dependentAxis;
   };
-
-  var findComponents = function (children) {
-    return children.reduce(function (memo, child) {
+  const findComponents = children => {
+    return children.reduce((memo, child) => {
       if (child.type && child.type.role === "axis" && matchesType(child)) {
         return memo.concat(child);
       } else if (child.props && child.props.children) {
-        var childAxis = findComponents(React.Children.toArray(child.props.children));
+        const childAxis = findComponents(React.Children.toArray(child.props.children));
         return childAxis.length > 0 ? memo.concat(child) : memo;
       }
-
       return memo;
     }, []);
   };
-
   return findComponents(childComponents);
 }
 export function getOrigin(domain) {
-  var getSingleOrigin = function (d) {
-    var domainMin = Math.min.apply(Math, _toConsumableArray(d));
-    var domainMax = Math.max.apply(Math, _toConsumableArray(d));
+  const getSingleOrigin = d => {
+    const domainMin = Math.min(...d);
+    const domainMax = Math.max(...d);
     return domainMax < 0 ? domainMax : Math.max(0, domainMin);
   };
-
   return {
-    x: Collection.containsDates(domain.x) ? new Date(Math.min.apply(Math, _toConsumableArray(domain.x))) : getSingleOrigin(domain.x),
-    y: Collection.containsDates(domain.y) ? new Date(Math.min.apply(Math, _toConsumableArray(domain.y))) : getSingleOrigin(domain.y)
+    x: Collection.containsDates(domain.x) ? new Date(Math.min(...domain.x)) : getSingleOrigin(domain.x),
+    y: Collection.containsDates(domain.y) ? new Date(Math.min(...domain.y)) : getSingleOrigin(domain.y)
   };
 }
 export function getOriginSign(origin, domain) {
-  var getSign = function () {
-    return origin <= 0 && Math.max.apply(Math, _toConsumableArray(domain)) <= 0 ? "negative" : "positive";
+  const getSign = () => {
+    return origin <= 0 && Math.max(...domain) <= 0 ? "negative" : "positive";
   };
-
   return Collection.containsDates(domain) ? "positive" : getSign();
 }
+
 /**
  * @param {Object} props: axis component props
  * @returns {Boolean} true when the axis is vertical
  */
-
 export function isVertical(props) {
-  var orientation = props.orientation || (props.dependentAxis ? "left" : "bottom");
-  var vertical = {
+  const orientation = props.orientation || (props.dependentAxis ? "left" : "bottom");
+  const vertical = {
     top: false,
     bottom: false,
     left: true,
@@ -141,207 +119,152 @@ export function isVertical(props) {
   };
   return vertical[orientation];
 }
+
 /**
  * @param {Object} props: axis component props
  * @returns {Boolean} true when tickValues contain strings
  */
-
 export function stringTicks(props) {
   return props.tickValues !== undefined && Collection.containsStrings(props.tickValues);
 }
-
 function getDefaultTickFormat(props) {
-  var tickValues = props.tickValues;
-  var axis = getAxis(props);
-  var stringMap = props.stringMap && props.stringMap[axis];
-  var fallbackFormat = tickValues && !Collection.containsDates(tickValues) ? function (x) {
-    return x;
-  } : undefined;
-
+  const {
+    tickValues
+  } = props;
+  const axis = getAxis(props);
+  const stringMap = props.stringMap && props.stringMap[axis];
+  const fallbackFormat = tickValues && !Collection.containsDates(tickValues) ? x => x : undefined;
   if (!stringMap) {
-    return stringTicks(props) ? function (x, index) {
-      return tickValues[index];
-    } : fallbackFormat;
+    return stringTicks(props) ? (x, index) => tickValues[index] : fallbackFormat;
   }
-
-  var invertedStringMap = stringMap && Helpers.invert(stringMap);
-
-  var tickValueArray = _orderBy(Object.values(stringMap), function (n) {
-    return n;
-  });
-
-  var dataNames = tickValueArray.map(function (tick) {
-    return invertedStringMap[tick];
-  }); // string ticks should have one tick of padding at the beginning
-
-  var dataTicks = [""].concat(_toConsumableArray(dataNames), [""]);
-  return function (x) {
-    return dataTicks[x];
-  };
+  const invertedStringMap = stringMap && Helpers.invert(stringMap);
+  const tickValueArray = _orderBy(Object.values(stringMap), n => n);
+  const dataNames = tickValueArray.map(tick => invertedStringMap[tick]);
+  // string ticks should have one tick of padding at the beginning
+  const dataTicks = ["", ...dataNames, ""];
+  return x => dataTicks[x];
 }
-
 function getStringTicks(props) {
-  var axis = getAxis(props);
-  var stringMap = props.stringMap && props.stringMap[axis];
-  var categories = Array.isArray(props.categories) ? props.categories : props.categories && props.categories[axis];
-  var ticksFromCategories = categories && Collection.containsOnlyStrings(categories) ? categories.map(function (tick) {
-    return stringMap[tick];
-  }) : undefined;
-  var ticksFromStringMap = stringMap && Object.values(stringMap);
+  const axis = getAxis(props);
+  const stringMap = props.stringMap && props.stringMap[axis];
+  const categories = Array.isArray(props.categories) ? props.categories : props.categories && props.categories[axis];
+  const ticksFromCategories = categories && Collection.containsOnlyStrings(categories) ? categories.map(tick => stringMap[tick]) : undefined;
+  const ticksFromStringMap = stringMap && Object.values(stringMap);
   return ticksFromCategories && ticksFromCategories.length !== 0 ? ticksFromCategories : ticksFromStringMap;
 }
-
 function getTickArray(props) {
-  var tickValues = props.tickValues,
-      tickFormat = props.tickFormat;
-
-  if ((tickValues === null || tickValues === void 0 ? void 0 : tickValues.length) === 0) {
+  const {
+    tickValues,
+    tickFormat
+  } = props;
+  if (tickValues?.length === 0) {
     return [];
   }
-
-  var axis = getAxis(props);
-  var stringMap = props.stringMap && props.stringMap[axis];
-
-  var getTicksFromFormat = function () {
+  const axis = getAxis(props);
+  const stringMap = props.stringMap && props.stringMap[axis];
+  const getTicksFromFormat = () => {
     if (!tickFormat || !Array.isArray(tickFormat)) {
       return undefined;
     }
-
-    return Collection.containsStrings(tickFormat) ? tickFormat.map(function (t, i) {
-      return i;
-    }) : tickFormat;
+    return Collection.containsStrings(tickFormat) ? tickFormat.map((t, i) => i) : tickFormat;
   };
-
-  var ticks = tickValues;
-
+  let ticks = tickValues;
   if (stringMap) {
     ticks = getStringTicks(props);
   }
-
   if (tickValues && Collection.containsStrings(tickValues)) {
-    ticks = stringMap ? tickValues.map(function (tick) {
-      return stringMap[tick];
-    }) : Helpers.range(1, tickValues.length + 1);
+    ticks = stringMap ? tickValues.map(tick => stringMap[tick]) : Helpers.range(1, tickValues.length + 1);
   }
-
-  var tickArray = ticks ? _uniq(ticks) : getTicksFromFormat();
-
-  var buildTickArray = function (arr) {
-    var newTickArray = [];
-    var domain = props.domain && props.domain[axis] || props.domain;
-
+  const tickArray = ticks ? _uniq(ticks) : getTicksFromFormat();
+  const buildTickArray = arr => {
+    const newTickArray = [];
+    const domain = props.domain && props.domain[axis] || props.domain;
     if (arr) {
-      arr.forEach(function (t, index) {
+      arr.forEach((t, index) => {
         if (Array.isArray(domain)) {
           if (t >= Collection.getMinValue(domain) && t <= Collection.getMaxValue(domain)) {
             newTickArray.push({
               value: t,
-              index: index
+              index
             });
           }
         } else {
           newTickArray.push({
             value: t,
-            index: index
+            index
           });
         }
       });
       return newTickArray;
     }
-
     return undefined;
   };
-
   return Array.isArray(tickArray) && tickArray.length ? buildTickArray(tickArray) : undefined;
 }
-
 export function getTickFormat(props, scale) {
-  var tickFormat = props.tickFormat;
-  var axis = getAxis(props);
-  var stringMap = props.stringMap && props.stringMap[axis];
-
+  const {
+    tickFormat
+  } = props;
+  const axis = getAxis(props);
+  const stringMap = props.stringMap && props.stringMap[axis];
   if (!tickFormat) {
-    var defaultTickFormat = getDefaultTickFormat(props); // If there is no user-provided tick format, we use d3's tickFormat function
+    const defaultTickFormat = getDefaultTickFormat(props);
+    // If there is no user-provided tick format, we use d3's tickFormat function
     // by default. This changed the default formatting for some scale types when
     // we upgraded to d3-scale@4..
-
-    var scaleTickFormat = scale.tickFormat && Helpers.isFunction(scale.tickFormat) ? scale.tickFormat() : function (x) {
-      return x;
-    };
+    const scaleTickFormat = scale.tickFormat && Helpers.isFunction(scale.tickFormat) ? scale.tickFormat() : x => x;
     return defaultTickFormat || scaleTickFormat;
   } else if (tickFormat && Array.isArray(tickFormat)) {
-    var tickArray = getTickArray(props);
-    var tickArrayIndices = tickArray === null || tickArray === void 0 ? void 0 : tickArray.map(function (v) {
-      return v.index;
-    });
-    var filteredTickFormat = tickFormat.filter(function (t, index) {
-      return tickArrayIndices === null || tickArrayIndices === void 0 ? void 0 : tickArrayIndices.includes(index);
-    });
-    return function (x, index) {
-      return filteredTickFormat[index];
-    };
+    const tickArray = getTickArray(props);
+    const tickArrayIndices = tickArray?.map(v => v.index);
+    const filteredTickFormat = tickFormat.filter((t, index) => tickArrayIndices?.includes(index));
+    return (x, index) => filteredTickFormat[index];
   } else if (tickFormat && Helpers.isFunction(tickFormat)) {
-    var applyStringTicks = function (tick, index, ticks) {
-      var invertedStringMap = Helpers.invert(stringMap);
-      var stringTickArray = ticks.map(function (t) {
-        return invertedStringMap[t];
-      });
+    const applyStringTicks = (tick, index, ticks) => {
+      const invertedStringMap = Helpers.invert(stringMap);
+      const stringTickArray = ticks.map(t => invertedStringMap[t]);
       return props.tickFormat(invertedStringMap[tick], index, stringTickArray);
     };
-
     return stringMap ? applyStringTicks : tickFormat;
   }
-
-  return function (x) {
-    return x;
-  };
+  return x => x;
 }
-
 function downsampleTicks(ticks, tickCount) {
   if (!tickCount || !Array.isArray(ticks) || ticks.length <= tickCount) {
     return ticks;
   }
-
-  var k = Math.floor(ticks.length / tickCount);
-  return ticks.filter(function (d, i) {
-    return i % k === 0;
-  });
+  const k = Math.floor(ticks.length / tickCount);
+  return ticks.filter((d, i) => i % k === 0);
 }
-
-export function getTicks(props, scale) {
-  var filterZero = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var tickCount = props.tickCount;
-  var tickArray = getTickArray(props);
-
-  if ((tickArray === null || tickArray === void 0 ? void 0 : tickArray.length) === 0) {
+export function getTicks(props, scale, filterZero) {
+  if (filterZero === void 0) {
+    filterZero = false;
+  }
+  const {
+    tickCount
+  } = props;
+  const tickArray = getTickArray(props);
+  if (tickArray?.length === 0) {
     return [""];
   }
-
-  var tickValues = tickArray ? tickArray.map(function (v) {
-    return v.value;
-  }) : undefined;
-
+  const tickValues = tickArray ? tickArray.map(v => v.value) : undefined;
   if (tickValues) {
     return downsampleTicks(tickValues, tickCount);
   } else if (scale.ticks && Helpers.isFunction(scale.ticks)) {
     // eslint-disable-next-line no-magic-numbers
-    var defaultTickCount = tickCount || 5;
-    var scaleTicks = scale.ticks(defaultTickCount);
-    var scaledTickArray = Array.isArray(scaleTicks) && scaleTicks.length ? scaleTicks : scale.domain();
-    var ticks = downsampleTicks(scaledTickArray, tickCount);
-
+    const defaultTickCount = tickCount || 5;
+    const scaleTicks = scale.ticks(defaultTickCount);
+    const scaledTickArray = Array.isArray(scaleTicks) && scaleTicks.length ? scaleTicks : scale.domain();
+    const ticks = downsampleTicks(scaledTickArray, tickCount);
     if (filterZero) {
-      var filteredTicks = ticks.filter(function (value) {
-        return value !== 0;
-      });
+      const filteredTicks = ticks.filter(value => value !== 0);
       return filteredTicks.length ? filteredTicks : ticks;
     }
-
     return ticks;
   }
-
   return scale.domain();
 }
+
 /**
  * Returns a domain based tickValues
  * @param {Object} props: the props object
@@ -349,92 +272,73 @@ export function getTicks(props, scale) {
  * @returns {Array} returns a domain from tickValues
  */
 // eslint-disable-next-line max-statements
-
 function getDomainFromData(props, axis) {
-  var polar = props.polar,
-      _props$startAngle = props.startAngle,
-      startAngle = _props$startAngle === void 0 ? 0 : _props$startAngle,
-      _props$endAngle = props.endAngle,
-      endAngle = _props$endAngle === void 0 ? 360 : _props$endAngle;
-  var tickArray = getTickArray(props);
-  var tickValues = tickArray && (tickArray === null || tickArray === void 0 ? void 0 : tickArray.length) !== 0 ? tickArray.map(function (v) {
-    return v.value;
-  }) : undefined;
-
+  const {
+    polar,
+    startAngle = 0,
+    endAngle = 360
+  } = props;
+  const tickArray = getTickArray(props);
+  const tickValues = tickArray && tickArray?.length !== 0 ? tickArray.map(v => v.value) : undefined;
   if (!Array.isArray(tickValues)) {
     return undefined;
   }
-
-  var minDomain = Domain.getMinFromProps(props, axis);
-  var maxDomain = Domain.getMaxFromProps(props, axis);
-  var tickStrings = stringTicks(props);
-  var ticks = tickValues.map(function (value) {
-    return Number(value);
-  });
-  var defaultMin = tickStrings ? 1 : Collection.getMinValue(ticks);
-  var defaultMax = tickStrings ? tickValues.length : Collection.getMaxValue(ticks);
-  var min = minDomain !== undefined ? minDomain : defaultMin;
-  var max = maxDomain !== undefined ? maxDomain : defaultMax;
-  var initialDomain = Domain.getDomainFromMinMax(min, max);
-  var domain = polar && axis === "x" && Math.abs(startAngle - endAngle) === 360 ? Domain.getSymmetricDomain(initialDomain, ticks) : initialDomain;
-
+  const minDomain = Domain.getMinFromProps(props, axis);
+  const maxDomain = Domain.getMaxFromProps(props, axis);
+  const tickStrings = stringTicks(props);
+  const ticks = tickValues.map(value => Number(value));
+  const defaultMin = tickStrings ? 1 : Collection.getMinValue(ticks);
+  const defaultMax = tickStrings ? tickValues.length : Collection.getMaxValue(ticks);
+  const min = minDomain !== undefined ? minDomain : defaultMin;
+  const max = maxDomain !== undefined ? maxDomain : defaultMax;
+  const initialDomain = Domain.getDomainFromMinMax(min, max);
+  const domain = polar && axis === "x" && Math.abs(startAngle - endAngle) === 360 ? Domain.getSymmetricDomain(initialDomain, ticks) : initialDomain;
   if (isVertical(props) && !polar) {
     domain.reverse();
   }
-
   return domain;
-} // exposed for use by VictoryChart
-
+}
 
+// exposed for use by VictoryChart
 export function getDomain(props, axis) {
-  var inherentAxis = getAxis(props);
-
+  const inherentAxis = getAxis(props);
   if (axis && axis !== inherentAxis) {
     return undefined;
   }
-
   return Domain.createDomainFunction(getDomainFromData)(props, inherentAxis);
 }
 export function getAxisValue(props, axis) {
   if (!props.axisValue) {
     return undefined;
   }
-
-  var scaleAxis = axis === "x" ? "y" : "x";
-  var scale = _isObject(props.scale) && Helpers.isFunction(props.scale[scaleAxis]) ? props.scale[scaleAxis] : undefined;
-
+  const scaleAxis = axis === "x" ? "y" : "x";
+  const scale = _isObject(props.scale) && Helpers.isFunction(props.scale[scaleAxis]) ? props.scale[scaleAxis] : undefined;
   if (!scale) {
     return undefined;
   }
-
-  var stringMapAxis = axis === "x" ? "y" : "x";
-  var stringMap = _isObject(props.stringMap) && props.stringMap[stringMapAxis];
-  var axisValue = stringMap && typeof props.axisValue === "string" ? stringMap[props.axisValue] : props.axisValue;
+  const stringMapAxis = axis === "x" ? "y" : "x";
+  const stringMap = _isObject(props.stringMap) && props.stringMap[stringMapAxis];
+  const axisValue = stringMap && typeof props.axisValue === "string" ? stringMap[props.axisValue] : props.axisValue;
   return scale(axisValue);
 }
 export function modifyProps(props, fallbackProps) {
   if (!_isObject(props.theme)) {
     return Helpers.modifyProps(props, fallbackProps, "axis");
   }
-
-  var role = "axis";
-
+  let role = "axis";
   if (props.dependentAxis && props.theme.dependentAxis) {
     role = "dependentAxis";
   } else if (!props.dependentAxis && props.theme.independentAxis) {
     role = "independentAxis";
   }
-
   if (role === "axis") {
     return Helpers.modifyProps(props, fallbackProps, "axis");
   }
-
-  var axisTheme = _defaults({}, props.theme[role], props.theme.axis);
-
-  var theme = Object.assign({}, props.theme, {
+  const axisTheme = _defaults({}, props.theme[role], props.theme.axis);
+  const theme = Object.assign({}, props.theme, {
     axis: axisTheme
   });
   return Helpers.modifyProps(Object.assign({}, props, {
-    theme: theme
+    theme
   }), fallbackProps, "axis");
 }

package/es/victory-util/collection.js

@@ -1,78 +1,50 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-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 isNonEmptyArray(collection) {
   return Array.isArray(collection) && collection.length > 0;
 }
-
 export function containsStrings(collection) {
-  return Array.isArray(collection) && collection.some(function (value) {
-    return typeof value === "string";
-  });
+  return Array.isArray(collection) && collection.some(value => typeof value === "string");
 }
 export function containsDates(collection) {
-  return Array.isArray(collection) && collection.some(function (value) {
-    return value instanceof Date;
-  });
+  return Array.isArray(collection) && collection.some(value => value instanceof Date);
 }
 export function containsNumbers(collection) {
-  return Array.isArray(collection) && collection.some(function (value) {
-    return typeof value === "number";
-  });
+  return Array.isArray(collection) && collection.some(value => typeof value === "number");
 }
 export function containsOnlyStrings(collection) {
-  return isNonEmptyArray(collection) && collection.every(function (value) {
-    return typeof value === "string";
-  });
+  return isNonEmptyArray(collection) && collection.every(value => typeof value === "string");
 }
+
 /**
  * Creates an array of array values not included in the other given arrays
  * @param a The array to inspect
  * @param b The values to exclude
  * @returns The new array of filtered values
  */
-
 export function difference(a, b) {
   if (a && b) {
-    return a.filter(function (value) {
-      return !b.includes(value);
-    });
+    return a.filter(value => !b.includes(value));
   }
-
   return [];
 }
 export function isArrayOfArrays(collection) {
   return isNonEmptyArray(collection) && collection.every(Array.isArray);
 }
 export function removeUndefined(arr) {
-  return arr.filter(function (el) {
-    return el !== undefined;
-  });
+  return arr.filter(el => el !== undefined);
 }
 export function getMaxValue(arr) {
   for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     values[_key - 1] = arguments[_key];
   }
-
-  var array = arr.concat(values);
-  return containsDates(array) ? new Date(Math.max.apply(Math, _toConsumableArray(array))) // Dates will be coerced to numbers
-  : Math.max.apply(Math, _toConsumableArray(array));
+  const array = arr.concat(values);
+  return containsDates(array) ? new Date(Math.max(...array)) // Dates will be coerced to numbers
+  : Math.max(...array);
 }
 export function getMinValue(arr) {
   for (var _len2 = arguments.length, values = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
     values[_key2 - 1] = arguments[_key2];
   }
-
-  var array = arr.concat(values);
-  return containsDates(array) ? new Date(Math.min.apply(Math, _toConsumableArray(array))) // Dates will be coerced to numbers
-  : Math.min.apply(Math, _toConsumableArray(array));
+  const array = arr.concat(values);
+  return containsDates(array) ? new Date(Math.min(...array)) // Dates will be coerced to numbers
+  : Math.min(...array);
 }