victory-core 30.6.1 → 31.2.0

package/src/victory-util/data.js

@@ -2,14 +2,23 @@
 /* eslint-disable no-use-before-define */
 import React from "react";
 import {
-  assign, uniq, range, last, isFunction, isPlainObject, property, orderBy, isEmpty, includes
+  assign,
+  uniq,
+  range,
+  last,
+  isFunction,
+  isPlainObject,
+  property,
+  orderBy,
+  isEmpty,
+  isEqual,
+  includes
 } from "lodash";
 import Helpers from "./helpers";
 import Collection from "./collection";
 import Scale from "./scale";
 import Immutable from "./immutable";
 
-
 // Private Functions
 
 function parseDatum(datum) {
@@ -85,10 +94,17 @@ function getEventKey(key) {
 
 // Returns data with an eventKey prop added to each datum
 function addEventKeys(props, data) {
+  const hasEventKeyAccessor = !!props.eventKey;
   const eventKeyAccessor = getEventKey(props.eventKey);
-  return data.map((datum, index) => {
-    const eventKey = datum.eventKey || eventKeyAccessor(datum) || index;
-    return assign({ eventKey }, datum);
+  return data.map((datum) => {
+    if (datum.eventKey !== undefined) {
+      return datum;
+    } else if (hasEventKeyAccessor) {
+      const eventKey = eventKeyAccessor(datum);
+      return eventKey !== undefined ? assign({ eventKey }, datum) : datum;
+    } else {
+      return datum;
+    }
   });
 }
 
@@ -107,11 +123,12 @@ function createStringMap(props, axis) {
   const stringsFromData = getStringsFromData(props, axis);
 
   const allStrings = uniq([...stringsFromAxes, ...stringsFromCategories, ...stringsFromData]);
-  return allStrings.length === 0 ? null :
-    allStrings.reduce((memo, string, index) => {
-      memo[string] = index + 1;
-      return memo;
-    }, {});
+  return allStrings.length === 0
+    ? null
+    : allStrings.reduce((memo, string, index) => {
+        memo[string] = index + 1;
+        return memo;
+      }, {});
 }
 
 /**
@@ -131,7 +148,7 @@ function downsample(data, maxPoints, startingIndex = 0) {
     const k = Math.pow(2, Math.ceil(Math.log2(dataLength / maxPoints)));
     return data.filter(
       // ensure modulo is always calculated from same reference: i + startingIndex
-      (d, i) => (((i + startingIndex) % k) === 0)
+      (d, i) => (i + startingIndex) % k === 0
     );
   }
   return data;
@@ -150,7 +167,8 @@ function formatData(dataset, props, expectedKeys) {
     return [];
   }
 
-  expectedKeys = Array.isArray(expectedKeys) ? expectedKeys : ["x", "y", "y0"];
+  const defaultKeys = ["x", "y", "y0"];
+  expectedKeys = Array.isArray(expectedKeys) ? expectedKeys : defaultKeys;
 
   const stringMap = {
     x: expectedKeys.indexOf("x") !== -1 ? createStringMap(props, "x") : undefined,
@@ -167,31 +185,39 @@ function formatData(dataset, props, expectedKeys) {
     return memo;
   }, {});
 
-
-  const data = dataset.reduce((dataArr, datum, index) => { // eslint-disable-line complexity
-    datum = parseDatum(datum);
-    const fallbackValues = { x: index, y: datum };
-    const processedValues = expectedKeys.reduce((memo, type) => {
-      const processedValue = accessor[type](datum);
-      const value = processedValue !== undefined ? processedValue : fallbackValues[type];
-      if (value !== undefined) {
-        if (typeof value === "string" && stringMap[type]) {
-          memo[`${type}Name`] = value;
-          memo[`_${type}`] = stringMap[type][value];
-        } else {
-          memo[`_${type}`] = value;
+  const preformattedData =
+    isEqual(expectedKeys, defaultKeys) &&
+    props.x === "_x" &&
+    props.y === "_y" &&
+    props.y0 === "_y0";
+
+  const data = preformattedData
+    ? dataset
+    : dataset.reduce((dataArr, datum, index) => {
+        // eslint-disable-line complexity
+        datum = parseDatum(datum);
+        const fallbackValues = { x: index, y: datum };
+        const processedValues = expectedKeys.reduce((memo, type) => {
+          const processedValue = accessor[type](datum);
+          const value = processedValue !== undefined ? processedValue : fallbackValues[type];
+          if (value !== undefined) {
+            if (typeof value === "string" && stringMap[type]) {
+              memo[`${type}Name`] = value;
+              memo[`_${type}`] = stringMap[type][value];
+            } else {
+              memo[`_${type}`] = value;
+            }
+          }
+          return memo;
+        }, {});
+
+        const formattedDatum = assign({}, processedValues, datum);
+        if (!isEmpty(formattedDatum)) {
+          dataArr.push(formattedDatum);
         }
-      }
-      return memo;
-    }, {});
-
-    const formattedDatum = assign({}, processedValues, datum);
-    if (!isEmpty(formattedDatum)) {
-      dataArr.push(formattedDatum);
-    }
 
-    return dataArr;
-  }, []);
+        return dataArr;
+      }, []);
 
   const sortedData = sortData(data, props.sortKey, props.sortOrder);
   const cleanedData = cleanData(sortedData, props);
@@ -220,8 +246,9 @@ function generateData(props) {
  */
 function getCategories(props, axis) {
   const currentAxis = Helpers.getCurrentAxis(axis, props.horizontal);
-  return props.categories && !Array.isArray(props.categories) ?
-    props.categories[currentAxis] : props.categories;
+  return props.categories && !Array.isArray(props.categories)
+    ? props.categories[currentAxis]
+    : props.categories;
 }
 
 /**
@@ -280,12 +307,20 @@ function getStringsFromData(props, axis) {
   const key = props[axis] === undefined ? axis : props[axis];
   const accessor = Helpers.createAccessor(key);
 
-  const sortedData = sortData(props.data, props.sortKey, props.sortOrder);
-  const dataStrings = sortedData.reduce((dataArr, datum) => {
-    datum = parseDatum(datum);
-    dataArr.push(accessor(datum));
-    return dataArr;
-  }, []).filter((datum) => typeof datum === "string");
+  // support immutable data
+  const data = props.data.reduce((memo, d) => {
+    memo.push(parseDatum(d));
+    return memo;
+  }, []);
+
+  const sortedData = sortData(data, props.sortKey, props.sortOrder);
+  const dataStrings = sortedData
+    .reduce((dataArr, datum) => {
+      datum = parseDatum(datum);
+      dataArr.push(accessor(datum));
+      return dataArr;
+    }, [])
+    .filter((datum) => typeof datum === "string");
 
   // return a unique set of strings
   return dataStrings.reduce((prev, curr) => {

package/src/victory-util/domain.js

@@ -17,8 +17,8 @@ function cleanDomain(domain, props, axis) {
   }
 
   const rules = (dom) => {
-    const almostZero = dom[0] < 0 || dom[1] < 0 ? -1 / Number.MAX_SAFE_INTEGER
-    : 1 / Number.MAX_SAFE_INTEGER;
+    const almostZero =
+      dom[0] < 0 || dom[1] < 0 ? -1 / Number.MAX_SAFE_INTEGER : 1 / Number.MAX_SAFE_INTEGER;
     const domainOne = dom[0] === 0 ? almostZero : dom[0];
     const domainTwo = dom[1] === 0 ? almostZero : dom[1];
     return [domainOne, domainTwo];
@@ -29,23 +29,26 @@ function cleanDomain(domain, props, axis) {
 
 function getDomainPadding(props, axis) {
   const formatPadding = (padding) => {
-    return Array.isArray(padding) ?
-      { left: padding[0], right: padding[1] } : { left: padding, right: padding };
+    return Array.isArray(padding)
+      ? { left: padding[0], right: padding[1] }
+      : { left: padding, right: padding };
   };
 
-  return isPlainObject(props.domainPadding) ?
-    formatPadding(props.domainPadding[axis]) : formatPadding(props.domainPadding);
+  return isPlainObject(props.domainPadding)
+    ? formatPadding(props.domainPadding[axis])
+    : formatPadding(props.domainPadding);
 }
 
 function getFlatData(dataset, axis) {
   return flatten(dataset).map((datum) => {
-    return datum[`_${axis}`] && datum[`_${axis}`][1] !== undefined ?
-      datum[`_${axis}`][1] : datum[`_${axis}`];
+    return datum[`_${axis}`] && datum[`_${axis}`][1] !== undefined
+      ? datum[`_${axis}`][1]
+      : datum[`_${axis}`];
   });
 }
 
 function getExtremeFromData(dataset, axis, type = "min") {
-  const getExtreme = (arr) => type === "max" ? Math.max(...arr) : Math.min(...arr);
+  const getExtreme = (arr) => (type === "max" ? Math.max(...arr) : Math.min(...arr));
   const initialValue = type === "max" ? -Infinity : Infinity;
   let containsDate = false;
   const result = flatten(dataset).reduce((memo, datum) => {
@@ -78,19 +81,20 @@ function padDomain(domain, props, axis) {
 
   // Naive initial padding calculation
   const initialPadding = {
-    left: Math.abs(max - min) * padding.left / rangeExtent,
-    right: Math.abs(max - min) * padding.right / rangeExtent
+    left: (Math.abs(max - min) * padding.left) / rangeExtent,
+    right: (Math.abs(max - min) * padding.right) / rangeExtent
   };
 
-  const singleQuadrantDomainPadding = isPlainObject(props.singleQuadrantDomainPadding) ?
-    props.singleQuadrantDomainPadding[axis] : props.singleQuadrantDomainPadding;
+  const singleQuadrantDomainPadding = isPlainObject(props.singleQuadrantDomainPadding)
+    ? props.singleQuadrantDomainPadding[axis]
+    : props.singleQuadrantDomainPadding;
 
   const adjust = (val, type) => {
     if (singleQuadrantDomainPadding === false) {
       return val;
     }
-    const coerce = (type === "min" && min >= 0 && val <= 0) ||
-      (type === "max" && max <= 0 && val >= 0);
+    const coerce =
+      (type === "min" && min >= 0 && val <= 0) || (type === "max" && max <= 0 && val >= 0);
     return coerce ? 0 : val;
   };
 
@@ -102,8 +106,8 @@ function padDomain(domain, props, axis) {
 
   // re-calculate padding, taking the adjusted domain into account
   const finalPadding = {
-    left: Math.abs(adjustedDomain.max - adjustedDomain.min) * padding.left / rangeExtent,
-    right: Math.abs(adjustedDomain.max - adjustedDomain.min) * padding.right / rangeExtent
+    left: (Math.abs(adjustedDomain.max - adjustedDomain.min) * padding.left) / rangeExtent,
+    right: (Math.abs(adjustedDomain.max - adjustedDomain.min) * padding.right) / rangeExtent
   };
 
   // Adjust the domain by the final padding
@@ -118,9 +122,9 @@ function padDomain(domain, props, axis) {
     max: maxDomain !== undefined ? maxDomain : paddedDomain.max
   };
 
-  return min instanceof Date || max instanceof Date ?
-    getDomainFromMinMax(new Date(finalDomain.min), new Date(finalDomain.max)) :
-    getDomainFromMinMax(finalDomain.min, finalDomain.max);
+  return min instanceof Date || max instanceof Date
+    ? getDomainFromMinMax(new Date(finalDomain.min), new Date(finalDomain.max))
+    : getDomainFromMinMax(finalDomain.min, finalDomain.max);
 }
 
 // Public Methods
@@ -134,18 +138,19 @@ function padDomain(domain, props, axis) {
  * @returns {Function} a function that takes props and axis and returns a formatted domain
  */
 function createDomainFunction(getDomainFromDataFunction, formatDomainFunction) {
-  getDomainFromDataFunction = isFunction(getDomainFromDataFunction) ?
-    getDomainFromDataFunction : getDomainFromData;
-  formatDomainFunction = isFunction(formatDomainFunction) ?
-    formatDomainFunction : formatDomain;
+  getDomainFromDataFunction = isFunction(getDomainFromDataFunction)
+    ? getDomainFromDataFunction
+    : getDomainFromData;
+  formatDomainFunction = isFunction(formatDomainFunction) ? formatDomainFunction : formatDomain;
   return (props, axis) => {
     const propsDomain = getDomainFromProps(props, axis);
     if (propsDomain) {
       return formatDomainFunction(propsDomain, props, axis);
     }
     const categories = Data.getCategories(props, axis);
-    const domain = categories ?
-      getDomainFromCategories(props, axis, categories) : getDomainFromDataFunction(props, axis);
+    const domain = categories
+      ? getDomainFromCategories(props, axis, categories)
+      : getDomainFromDataFunction(props, axis);
     return formatDomainFunction(domain, props, axis);
   };
 }
@@ -186,20 +191,23 @@ function getDomainFromCategories(props, axis, categories) {
   }
   const minDomain = getMinFromProps(props, axis);
   const maxDomain = getMaxFromProps(props, axis);
-  const stringArray = Collection.containsStrings(categories) ?
-    Data.getStringsFromCategories(props, axis) : [];
-  const stringMap = stringArray.length === 0 ? null :
-    stringArray.reduce((memo, string, index) => {
-      memo[string] = index + 1;
-      return memo;
-    }, {});
-  const categoryValues = stringMap ?
-    categories.map((value) => stringMap[value]) : categories;
+  const stringArray = Collection.containsStrings(categories)
+    ? Data.getStringsFromCategories(props, axis)
+    : [];
+  const stringMap =
+    stringArray.length === 0
+      ? null
+      : stringArray.reduce((memo, string, index) => {
+          memo[string] = index + 1;
+          return memo;
+        }, {});
+  const categoryValues = stringMap ? categories.map((value) => stringMap[value]) : categories;
   const min = minDomain !== undefined ? minDomain : Collection.getMinValue(categoryValues);
   const max = maxDomain !== undefined ? maxDomain : Collection.getMaxValue(categoryValues);
   const categoryDomain = getDomainFromMinMax(min, max);
-  return polar && axis === "x" && Math.abs(startAngle - endAngle) === 360 ?
-    getSymmetricDomain(categoryDomain, categoryValues) : categoryDomain;
+  return polar && axis === "x" && Math.abs(startAngle - endAngle) === 360
+    ? getSymmetricDomain(categoryDomain, categoryValues)
+    : categoryDomain;
 }
 
 /**
@@ -226,8 +234,9 @@ function getDomainFromData(props, axis, dataset) {
   const max = maxDomain !== undefined ? maxDomain : getExtremeFromData(dataset, currentAxis, "max");
   const domain = getDomainFromMinMax(min, max);
 
-  return polar && axis === "x" && Math.abs(startAngle - endAngle) === 360 ?
-    getSymmetricDomain(domain, getFlatData(dataset, currentAxis)) : domain;
+  return polar && axis === "x" && Math.abs(startAngle - endAngle) === 360
+    ? getSymmetricDomain(domain, getFlatData(dataset, currentAxis))
+    : domain;
 }
 
 /**
@@ -280,23 +289,36 @@ function getDomainWithZero(props, axis) {
   if (propsDomain) {
     return propsDomain;
   }
+
+  const dataset = Data.getData(props);
+  const y0Min = dataset.reduce((min, datum) => (datum._y0 < min ? datum._y0 : min), Infinity);
+
   const ensureZero = (domain) => {
     const currentAxis = Helpers.getCurrentAxis(axis, props.horizontal);
-    const minDomain = getMinFromProps(props, axis);
-    const maxDomain = getMaxFromProps(props, axis);
     if (currentAxis === "x") {
       return domain;
     }
-    const defaultMin = minDomain || 0;
-    const defaultMax = maxDomain || 0;
-    const min = minDomain !== undefined ? minDomain : Collection.getMinValue(domain, defaultMin);
-    const max = maxDomain !== undefined ? maxDomain : Collection.getMaxValue(domain, defaultMax);
+
+    const defaultMin = y0Min !== Infinity ? y0Min : 0;
+    const maxDomainProp = getMaxFromProps(props, axis);
+    const minDomainProp = getMinFromProps(props, axis);
+    const max =
+      maxDomainProp !== undefined ? maxDomainProp : Collection.getMaxValue(domain, defaultMin);
+    const min =
+      minDomainProp !== undefined ? minDomainProp : Collection.getMinValue(domain, defaultMin);
+
     return getDomainFromMinMax(min, max);
   };
+
+  const getDomainFunction = () => {
+    return getDomainFromData(props, axis, dataset);
+  };
+
   const formatDomainFunction = (domain) => {
     return formatDomain(ensureZero(domain), props, axis);
   };
-  return createDomainFunction(null, formatDomainFunction)(props, axis);
+
+  return createDomainFunction(getDomainFunction, formatDomainFunction)(props, axis);
 }
 
 /**