victory-core 36.8.2 → 36.8.4

package/src/victory-util/axis.tsx

@@ -36,10 +36,14 @@ export function getAxis(props) {
  * @returns {Array} all axis components that pass the given predicate or []
  */
 export function findAxisComponents(childComponents, predicate?) {
-  predicate = predicate || identity;
+  const predicateFunction = predicate || identity;
   const findAxes = (children) => {
     return children.reduce((memo, child) => {
-      if (child.type && child.type.role === "axis" && predicate(child)) {
+      if (
+        child.type &&
+        child.type.role === "axis" &&
+        predicateFunction(child)
+      ) {
         return memo.concat(child);
       } else if (child.props && child.props.children) {
         return memo.concat(

package/src/victory-util/common-props.tsx

@@ -95,6 +95,7 @@ export interface VictoryCommonThemeProps {
   animate?: boolean | AnimatePropTypeInterface;
   colorScale?: ColorScalePropType;
   containerComponent?: React.ReactElement;
+  disableInlineStyles?: boolean;
   domainPadding?: DomainPaddingPropType;
   externalEventMutations?: EventCallbackInterface<
     string | string[],

package/src/victory-util/data.ts

@@ -58,11 +58,12 @@ function sortData(dataset, sortKey, sortOrder = "ascending") {
   }
 
   // Ensures previous VictoryLine api for sortKey prop stays consistent
+  let formattedSortKey = sortKey;
   if (sortKey === "x" || sortKey === "y") {
-    sortKey = `_${sortKey}`;
+    formattedSortKey = `_${sortKey}`;
   }
   const order = sortOrder === "ascending" ? "asc" : "desc";
-  return orderBy(dataset, sortKey, order);
+  return orderBy(dataset, formattedSortKey, order);
 }
 
 // This method will remove data points that break certain scales. (log scale only)
@@ -239,6 +240,9 @@ export function formatData(
   }
 
   const defaultKeys = ["x", "y", "y0"];
+  // TODO: We shouldn’t mutate the expectedKeys param here,
+  // but we need to figure out why changing it causes regressions in tests.
+  // eslint-disable-next-line no-param-reassign
   expectedKeys = Array.isArray(expectedKeys) ? expectedKeys : defaultKeys;
 
   const createAccessor = (name) => {
@@ -281,10 +285,10 @@ export function formatData(
     ? dataset
     : dataset.reduce((dataArr, datum, index) => {
         // eslint-disable-line complexity
-        datum = parseDatum(datum);
-        const fallbackValues = { x: index, y: datum };
+        const parsedDatum = parseDatum(datum);
+        const fallbackValues = { x: index, y: parsedDatum };
         const processedValues = expectedKeys!.reduce((memo, type) => {
-          const processedValue = accessor[type](datum);
+          const processedValue = accessor[type](parsedDatum);
           const value =
             processedValue !== undefined
               ? processedValue
@@ -300,7 +304,7 @@ export function formatData(
           return memo;
         }, {});
 
-        const formattedDatum = assign({}, processedValues, datum);
+        const formattedDatum = assign({}, processedValues, parsedDatum);
         if (!isEmpty(formattedDatum)) {
           dataArr.push(formattedDatum);
         }
@@ -408,8 +412,8 @@ export function getStringsFromData(props, axis) {
   const sortedData = sortData(data, props.sortKey, props.sortOrder);
   const dataStrings = sortedData
     .reduce((dataArr, datum) => {
-      datum = parseDatum(datum);
-      dataArr.push(accessor(datum));
+      const parsedDatum = parseDatum(datum);
+      dataArr.push(accessor(parsedDatum));
       return dataArr;
     }, [])
     .filter((datum) => typeof datum === "string");

package/src/victory-util/domain.ts

@@ -183,22 +183,22 @@ export function createDomainFunction(
   getDomainFromDataFunction?,
   formatDomainFunction?,
 ) {
-  getDomainFromDataFunction = isFunction(getDomainFromDataFunction)
+  const getDomainFromDataFn = isFunction(getDomainFromDataFunction)
     ? getDomainFromDataFunction
     : getDomainFromData;
-  formatDomainFunction = isFunction(formatDomainFunction)
+  const formatDomainFn = isFunction(formatDomainFunction)
     ? formatDomainFunction
     : formatDomain;
   return (props, axis) => {
     const propsDomain = getDomainFromProps(props, axis);
     if (propsDomain) {
-      return formatDomainFunction(propsDomain, props, axis);
+      return formatDomainFn(propsDomain, props, axis);
     }
     const categories = Data.getCategories(props, axis);
     const domain = categories
       ? getDomainFromCategories(props, axis, categories)
-      : getDomainFromDataFunction(props, axis);
-    return domain ? formatDomainFunction(domain, props, axis) : undefined;
+      : getDomainFromDataFn(props, axis);
+    return domain ? formatDomainFn(domain, props, axis) : undefined;
   };
 }
 
@@ -231,14 +231,14 @@ export function getDomain(props, axis) {
  * @returns {Array|undefined} returns a domain from categories or undefined
  */
 export function getDomainFromCategories(props, axis, categories?) {
-  categories = categories || Data.getCategories(props, axis);
+  const categoriesArray = categories || Data.getCategories(props, axis);
   const { polar, startAngle = 0, endAngle = 360 } = props;
-  if (!categories) {
+  if (!categoriesArray) {
     return undefined;
   }
   const minDomain = getMinFromProps(props, axis);
   const maxDomain = getMaxFromProps(props, axis);
-  const stringArray = Collection.containsStrings(categories)
+  const stringArray = Collection.containsStrings(categoriesArray)
     ? Data.getStringsFromCategories(props, axis)
     : [];
   const stringMap =
@@ -249,8 +249,8 @@ export function getDomainFromCategories(props, axis, categories?) {
           return memo;
         }, {});
   const categoryValues = stringMap
-    ? categories.map((value) => stringMap[value])
-    : categories;
+    ? categoriesArray.map((value) => stringMap[value])
+    : categoriesArray;
   const min =
     minDomain !== undefined
       ? minDomain
@@ -273,11 +273,11 @@ export function getDomainFromCategories(props, axis, categories?) {
  * @returns {Array} the domain based on data
  */
 export function getDomainFromData(props, axis, dataset) {
-  dataset = dataset || Data.getData(props);
+  const datasetArray = dataset || Data.getData(props);
   const { polar, startAngle = 0, endAngle = 360 } = props;
   const minDomain = getMinFromProps(props, axis);
   const maxDomain = getMaxFromProps(props, axis);
-  if (dataset.length < 1) {
+  if (datasetArray.length < 1) {
     return minDomain !== undefined && maxDomain !== undefined
       ? getDomainFromMinMax(minDomain, maxDomain)
       : undefined;
@@ -285,14 +285,14 @@ export function getDomainFromData(props, axis, dataset) {
   const min =
     minDomain !== undefined
       ? minDomain
-      : getExtremeFromData(dataset, axis, "min");
+      : getExtremeFromData(datasetArray, axis, "min");
   const max =
     maxDomain !== undefined
       ? maxDomain
-      : getExtremeFromData(dataset, axis, "max");
+      : getExtremeFromData(datasetArray, axis, "max");
   const domain = getDomainFromMinMax(min, max);
   return polar && axis === "x" && Math.abs(startAngle - endAngle) === 360
-    ? getSymmetricDomain(domain, getFlatData(dataset, axis))
+    ? getSymmetricDomain(domain, getFlatData(datasetArray, axis))
     : domain;
 }
 

package/src/victory-util/events.ts

@@ -48,10 +48,10 @@ interface ComponentWithEvents extends EventMixinCalculatedValues {
 export function getEvents(
   this: ComponentWithEvents,
   props,
-  target,
-  eventKey,
+  target?,
+  eventKey?,
   // eslint-disable-next-line no-shadow
-  getScopedEvents,
+  getScopedEvents?,
 ) {
   // Returns all events that apply to a particular target element
   const getEventsByTarget = (events: Array<ComponentEvent>) => {
@@ -137,12 +137,12 @@ export function getScopedEvents(
 
   // Mandatory usage: `getScopedEvents.bind(this)`
   // eslint-disable-next-line no-invalid-this
-  baseProps = baseProps || this.baseProps;
+  const newBaseProps = baseProps || this.baseProps;
   // returns the original base props or base state of a given target element
   const getTargetProps = (identifier, type) => {
     const { childName, target, key } = identifier;
     // eslint-disable-next-line no-invalid-this
-    const baseType = type === "props" ? baseProps : this.state || {};
+    const baseType = type === "props" ? newBaseProps : this.state || {};
     const base =
       childName === undefined || childName === null || !baseType[childName]
         ? baseType
@@ -165,13 +165,13 @@ export function getScopedEvents(
         return "parent";
       }
       if (eventReturn.eventKey === "all") {
-        return baseProps[childName]
-          ? without(keys(baseProps[childName]), "parent")
-          : without(keys(baseProps), "parent");
+        return newBaseProps[childName]
+          ? without(keys(newBaseProps[childName]), "parent")
+          : without(keys(newBaseProps), "parent");
       } else if (eventReturn.eventKey === undefined && eventKey === "parent") {
-        return baseProps[childName]
-          ? keys(baseProps[childName])
-          : keys(baseProps);
+        return newBaseProps[childName]
+          ? keys(newBaseProps[childName])
+          : keys(newBaseProps);
       }
       return eventReturn.eventKey !== undefined
         ? eventReturn.eventKey
@@ -195,7 +195,7 @@ export function getScopedEvents(
       );
       const mutatedProps = eventReturn.mutation(
         assign({}, mutationTargetProps, mutationTargetState),
-        baseProps,
+        newBaseProps,
       );
       const childState = baseState[childName] || {};
 
@@ -238,7 +238,7 @@ export function getScopedEvents(
 
     // returns an entire mutated state for all children
     const allChildNames =
-      childNames === "all" ? without(keys(baseProps), "parent") : childNames;
+      childNames === "all" ? without(keys(newBaseProps), "parent") : childNames;
     return Array.isArray(allChildNames)
       ? allChildNames.reduce((memo, childName) => {
           return assign(memo, getReturnByChild(childName));
@@ -249,10 +249,10 @@ export function getScopedEvents(
   // Parses an array of event returns into a single state mutation
   const parseEventReturn = (eventReturn, eventKey) => {
     return Array.isArray(eventReturn)
-      ? eventReturn.reduce((memo, props) => {
-          memo = assign({}, memo, parseEvent(props, eventKey));
-          return memo;
-        }, {})
+      ? eventReturn.reduce(
+          (memo, props) => assign({}, memo, parseEvent(props, eventKey)),
+          {},
+        )
       : parseEvent(eventReturn, eventKey);
   };
 
@@ -347,13 +347,10 @@ export function getEventState(
 // eslint-disable-next-line max-params
 export function getExternalMutationsWithChildren(
   mutations,
-  baseProps,
-  baseState,
+  baseProps = {},
+  baseState = {},
   childNames,
 ) {
-  baseProps = baseProps || {};
-  baseState = baseState || {};
-
   return childNames.reduce((memo, childName) => {
     const childState = baseState[childName];
     const mutation = getExternalMutations(
@@ -380,13 +377,10 @@ export function getExternalMutationsWithChildren(
 // eslint-disable-next-line max-params
 export function getExternalMutations(
   mutations,
-  baseProps,
-  baseState,
+  baseProps = {},
+  baseState = {},
   childName?,
 ) {
-  baseProps = baseProps || {};
-  baseState = baseState || {};
-
   const eventKeys = keys(baseProps);
   return eventKeys.reduce((memo, eventKey) => {
     const keyState = baseState[eventKey] || {};
@@ -452,8 +446,7 @@ export function getExternalMutation(
     return false;
   };
 
-  mutations = Array.isArray(mutations) ? mutations : [mutations];
-  let scopedMutations = mutations;
+  let scopedMutations = Array.isArray(mutations) ? mutations : [mutations];
   if (identifier.childName) {
     scopedMutations = mutations.filter((m) => filterMutations(m, "childName"));
   }
@@ -491,10 +484,9 @@ export function getComponentEvents(props, components) {
       const componentEvents = isFunction(defaultEvents)
         ? defaultEvents(component.props)
         : defaultEvents;
-      memo = Array.isArray(componentEvents)
+      return Array.isArray(componentEvents)
         ? memo.concat(...componentEvents)
         : memo;
-      return memo;
     }, [] as ComponentEvent[]);
   return events && events.length ? events : undefined;
 }

package/src/victory-util/helpers.ts

@@ -258,6 +258,7 @@ export function reduceChildren<
   ];
   const traverseChildren = (childArray, names, parent?) => {
     return childArray.reduce((memo, child, index) => {
+      let newMemo = memo;
       const childRole = child.type && child.type.role;
       const childName = child.props.name || `${childRole}-${names[index]}`;
       if (child.props && child.props.children) {
@@ -291,14 +292,14 @@ export function reduceChildren<
           childNames,
           child,
         );
-        memo = combine(memo, nestedResults);
+        newMemo = combine(newMemo, nestedResults);
       } else {
         const result = iteratee(child, childName, parent);
         if (result) {
-          memo = combine(memo, result);
+          newMemo = combine(newMemo, result);
         }
       }
-      return memo;
+      return newMemo;
     }, initialMemo);
   };
 
@@ -320,8 +321,7 @@ export function isHorizontal(props) {
     return childArray.reduce((memo, child) => {
       const childProps = child.props || {};
       if (memo || childProps.horizontal || !childProps.children) {
-        memo = memo || childProps.horizontal;
-        return memo;
+        return memo || childProps.horizontal;
       }
       return traverseChildren(React.Children.toArray(childProps.children));
     }, false);

package/src/victory-util/immutable.ts

@@ -31,10 +31,11 @@ export function shallowToJS(x, whitelist?: Record<string, boolean | unknown>) {
   return isIterable(x)
     ? x.reduce(
         (result: any, curr: any, key: any) => {
+          let newCurr = curr;
           if (whitelist && whitelist[key]) {
-            curr = shallowToJS(curr);
+            newCurr = shallowToJS(curr);
           }
-          result[key] = curr;
+          result[key] = newCurr;
           return result;
         },
         isList(x) ? [] : {},

package/src/victory-util/label-helpers.ts

@@ -1,11 +1,11 @@
 /* eslint-disable no-use-before-define */
+import { VictoryLabelProps } from "../victory-label/victory-label";
 import * as Helpers from "./helpers";
 import { defaults } from "lodash";
 
 // Private Functions
 
-function getVerticalAnchor(props, datum) {
-  datum = datum || {};
+function getVerticalAnchor(props, datum: VictoryLabelProps["datum"] = {}) {
   const sign = datum._y >= 0 ? 1 : -1;
   const labelStyle = (props.style && props.style.labels) || {};
   if (datum.verticalAnchor || labelStyle.verticalAnchor) {
@@ -16,8 +16,7 @@ function getVerticalAnchor(props, datum) {
   return "middle";
 }
 
-function getTextAnchor(props, datum) {
-  datum = datum || {};
+function getTextAnchor(props, datum: VictoryLabelProps["datum"] = {}) {
   const { style, horizontal } = props;
   const sign = datum._y >= 0 ? 1 : -1;
   const labelStyle = (style && style.labels) || {};
@@ -29,14 +28,12 @@ function getTextAnchor(props, datum) {
   return sign >= 0 ? "start" : "end";
 }
 
-function getAngle(props, datum) {
-  datum = datum || {};
+function getAngle(props, datum: VictoryLabelProps["datum"] = {}) {
   const labelStyle = (props.style && props.style.labels) || {};
   return datum.angle === undefined ? labelStyle.angle : datum.angle;
 }
 
-function getPadding(props, datum) {
-  datum = datum || {};
+function getPadding(props, datum: VictoryLabelProps["datum"] = {}) {
   const { horizontal, style } = props;
   const labelStyle = style.labels || {};
   const defaultPadding = Helpers.evaluateProp(labelStyle.padding, props) || 0;
@@ -109,8 +106,7 @@ function getPolarOrientation(degrees) {
 
 // Exported Functions
 
-export function getText(props, datum, index) {
-  datum = datum || {};
+export function getText(props, datum: VictoryLabelProps["datum"] = {}, index) {
   if (datum.label !== undefined) {
     return datum.label;
   }

package/src/victory-util/selection.ts

@@ -73,8 +73,9 @@ export function getSVGEventCoordinates(
   const location = isReactTouchEvent(evt)
     ? evt.changedTouches[0]
     : (evt as React.MouseEvent);
-  svg = svg || getParentSVG(location);
-  const matrix = getTransformationMatrix(svg as SVGGraphicsElement);
+  const matrix = getTransformationMatrix(
+    (svg as SVGGraphicsElement) || getParentSVG(location),
+  );
   return {
     x: transformTarget(location.clientX, matrix, "x"),
     y: transformTarget(location.clientY, matrix, "y"),

package/src/victory-util/timer.ts

@@ -47,11 +47,10 @@ export default class Timer {
   }
 
   subscribe(callback: TimerCallback, duration: number) {
-    duration = this.shouldAnimate ? duration : 0;
     const subscriptionID = this.subscribers.push({
       startTime: now(),
       callback,
-      duration,
+      duration: this.shouldAnimate ? duration : 0,
     });
     this.activeSubscriptions++;
     this.start();

package/src/victory-util/transitions.ts

@@ -137,34 +137,39 @@ function getInitialChildProps(animate, data): TransitionProps {
 
 // eslint-disable-next-line max-params
 function getChildBeforeLoad(animate, child, data, cb): TransitionProps {
-  animate = assign({}, animate, { onEnd: cb });
-  if (animate && animate.onLoad && !animate.onLoad.duration) {
-    return { animate, data };
+  const newAnimate = assign({}, animate, { onEnd: cb });
+
+  if (newAnimate && newAnimate.onLoad && !newAnimate.onLoad.duration) {
+    return { animate: newAnimate, data };
   }
   const before =
-    animate.onLoad && animate.onLoad.before ? animate.onLoad.before : identity;
+    newAnimate.onLoad && newAnimate.onLoad.before
+      ? newAnimate.onLoad.before
+      : identity;
   // If nodes need to exit, transform them with the provided onLoad.before function.
-  data = data.map((datum, idx) => {
+  const newData = data.map((datum, idx) => {
     return assign({}, datum, before(datum, idx, data));
   });
 
-  return { animate, data, clipWidth: 0 };
+  return { animate: newAnimate, data: newData, clipWidth: 0 };
 }
 
 // eslint-disable-next-line max-params
 function getChildOnLoad(animate, data, cb): TransitionProps {
-  animate = assign({}, animate, { onEnd: cb });
-  if (animate && animate.onLoad && !animate.onLoad.duration) {
+  const newAnimate = assign({}, animate, { onEnd: cb });
+  let newData = data;
+
+  if (newAnimate && newAnimate.onLoad && !newAnimate.onLoad.duration) {
     return { animate, data };
   }
   const after =
     animate.onLoad && animate.onLoad.after ? animate.onLoad.after : identity;
   // If nodes need to exit, transform them with the provided onLoad.after function.
-  data = data.map((datum, idx) => {
+  newData = data.map((datum, idx) => {
     return assign({}, datum, after(datum, idx, data));
   });
 
-  return { animate, data };
+  return { animate: newAnimate, data: newData };
 }
 
 // eslint-disable-next-line max-params, max-len
@@ -178,7 +183,8 @@ function getChildPropsOnExit(
   // Whether or not _this_ child has exiting nodes, we want the exit-
   // transition for all children to have the same duration, delay, etc.
   const onExit = animate && animate.onExit;
-  animate = assign({}, animate, onExit);
+  const newAnimate = assign({}, animate, onExit);
+  let newData = data;
 
   if (exitingNodes) {
     // After the exit transition occurs, trigger the animations for
@@ -189,7 +195,7 @@ function getChildPropsOnExit(
         ? animate.onExit.before
         : identity;
     // If nodes need to exit, transform them with the provided onExit.before function.
-    data = data.map((datum, idx) => {
+    newData = data.map((datum, idx) => {
       const key = (datum.key || idx).toString();
       return exitingNodes[key]
         ? assign({}, datum, before(datum, idx, data))
@@ -197,7 +203,7 @@ function getChildPropsOnExit(
     });
   }
 
-  return { animate, data };
+  return { animate: newAnimate, data: newData };
 }
 
 // eslint-disable-next-line max-params,max-len
@@ -208,10 +214,12 @@ function getChildPropsBeforeEnter(
   enteringNodes,
   cb,
 ): TransitionProps {
+  let newAnimate = animate;
+  let newData = data;
   if (enteringNodes) {
     // Perform a normal animation here, except - when it finishes - trigger
     // the transition for entering nodes.
-    animate = assign({}, animate, { onEnd: cb });
+    newAnimate = assign({}, animate, { onEnd: cb });
     const before =
       animate.onEnter && animate.onEnter.before
         ? animate.onEnter.before
@@ -219,7 +227,7 @@ function getChildPropsBeforeEnter(
     // 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.
-    data = data.map((datum, idx) => {
+    newData = data.map((datum, idx) => {
       const key = (datum.key || idx).toString();
       return enteringNodes[key]
         ? assign({}, datum, before(datum, idx, data))
@@ -227,7 +235,7 @@ function getChildPropsBeforeEnter(
     });
   }
 
-  return { animate, data };
+  return { animate: newAnimate, data: newData };
 }
 
 // eslint-disable-next-line max-params, max-len
@@ -240,25 +248,26 @@ function getChildPropsOnEnter(
   // Whether or not _this_ child has entering nodes, we want the entering-
   // transition for all children to have the same duration, delay, etc.
   const onEnter = animate && animate.onEnter;
-  animate = assign({}, animate, onEnter);
+  const newAnimate = 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.
-    animate.onEnd = cb;
+    newAnimate.onEnd = cb;
     const after =
-      animate.onEnter && animate.onEnter.after
-        ? animate.onEnter.after
+      newAnimate.onEnter && newAnimate.onEnter.after
+        ? newAnimate.onEnter.after
         : identity;
-    data = data.map((datum, idx) => {
+    newData = data.map((datum, idx) => {
       const key = getDatumKey(datum, idx);
       return enteringNodes[key]
         ? assign({}, datum, after(datum, idx, data))
         : datum;
     });
   }
-  return { animate, data };
+  return { animate: newAnimate, data: newData };
 }
 
 /**

package/src/victory-util/user-props.ts

@@ -55,6 +55,20 @@ const testIfSafeProp = (key: string): key is SafeAttribute => {
   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<T>(
+  value: T,
+  message?: string,
+): asserts value is NonNullable<T> {
+  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