victory-core 36.4.1 → 36.5.2

package/src/victory-util/{axis.js → axis.tsx}

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 import React from "react";
 import {
   assign,
@@ -12,11 +11,12 @@ import {
   orderBy,
   values,
   includes,
-  without
+  without,
 } from "lodash";
 import * as Collection from "./collection";
 import * as Domain from "./domain";
 import * as Helpers from "./helpers";
+import { D3Scale } from "../types/prop-types";
 
 /**
  * Returns the axis (x or y) of a particular axis component
@@ -35,7 +35,7 @@ export function getAxis(props) {
  * @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) {
+export function findAxisComponents(childComponents, predicate?) {
   predicate = predicate || identity;
   const findAxes = (children) => {
     return children.reduce((memo, child) => {
@@ -43,7 +43,7 @@ export function findAxisComponents(childComponents, predicate) {
         return memo.concat(child);
       } else if (child.props && child.props.children) {
         return memo.concat(
-          findAxes(React.Children.toArray(child.props.children))
+          findAxes(React.Children.toArray(child.props.children)),
         );
       }
       return memo;
@@ -87,7 +87,7 @@ export function getAxisComponentsWithParent(childComponents, type) {
         return memo.concat(child);
       } else if (child.props && child.props.children) {
         const childAxis = findComponents(
-          React.Children.toArray(child.props.children)
+          React.Children.toArray(child.props.children),
         );
         return childAxis.length > 0 ? memo.concat(child) : memo;
       }
@@ -111,7 +111,7 @@ export function getOrigin(domain) {
       : getSingleOrigin(domain.x),
     y: Collection.containsDates(domain.y)
       ? new Date(Math.min(...domain.y))
-      : getSingleOrigin(domain.y)
+      : getSingleOrigin(domain.y),
   };
 }
 
@@ -202,9 +202,9 @@ function getTickArray(props) {
       ? tickValues.map((tick) => stringMap[tick])
       : range(1, tickValues.length + 1);
   }
-  const tickArray = ticks ? uniq(ticks) : getTicksFromFormat(props);
-  const buildTickArray = (arr) => {
-    const newTickArray = [];
+  const tickArray = ticks ? uniq(ticks) : getTicksFromFormat();
+  const buildTickArray = (arr: number[]) => {
+    const newTickArray = [] as Array<{ value: number; index: number }>;
     const domain = (props.domain && props.domain[axis]) || props.domain;
     if (arr) {
       arr.forEach(function (t, index) {
@@ -215,13 +215,13 @@ function getTickArray(props) {
           ) {
             newTickArray.push({
               value: t,
-              index
+              index,
             });
           }
         } else {
           newTickArray.push({
             value: t,
-            index
+            index,
           });
         }
       });
@@ -249,11 +249,9 @@ export function getTickFormat(props, scale) {
     return defaultTickFormat || scaleTickFormat;
   } else if (tickFormat && Array.isArray(tickFormat)) {
     const tickArray = getTickArray(props);
-    const tickArrayIndices = tickArray
-      ? tickArray.map((v) => v.index)
-      : undefined;
+    const tickArrayIndices = tickArray?.map((v) => v.index);
     const filteredTickFormat = tickFormat.filter((t, index) =>
-      tickArrayIndices.includes(index)
+      tickArrayIndices?.includes(index),
     );
     return (x, index) => filteredTickFormat[index];
   } else if (tickFormat && isFunction(tickFormat)) {
@@ -268,7 +266,7 @@ export function getTickFormat(props, scale) {
   }
 }
 
-function downsampleTicks(ticks, tickCount) {
+function downsampleTicks(ticks: number[], tickCount: number) {
   if (!tickCount || !Array.isArray(ticks) || ticks.length <= tickCount) {
     return ticks;
   }
@@ -276,7 +274,7 @@ function downsampleTicks(ticks, tickCount) {
   return ticks.filter((d, i) => i % k === 0);
 }
 
-export function getTicks(props, scale, filterZero) {
+export function getTicks(props, scale: D3Scale, filterZero = false) {
   const { tickCount } = props;
   const tickArray = getTickArray(props);
   const tickValues = tickArray ? tickArray.map((v) => v.value) : undefined;
@@ -336,7 +334,7 @@ function getDomainFromData(props, axis) {
 }
 
 // exposed for use by VictoryChart
-export function getDomain(props, axis) {
+export function getDomain(props, axis?) {
   const inherentAxis = getAxis(props);
   if (axis && axis !== inherentAxis) {
     return undefined;
@@ -383,6 +381,6 @@ export function modifyProps(props, fallbackProps) {
   return Helpers.modifyProps(
     assign({}, props, { theme }),
     fallbackProps,
-    "axis"
+    "axis",
   );
 }

package/src/victory-util/{collection.js → collection.tsx}

@@ -1,18 +1,15 @@
-/* eslint-disable func-style */
-/* eslint-disable no-use-before-define */
-
 function isNonEmptyArray(collection) {
   return Array.isArray(collection) && collection.length > 0;
 }
 
-export function containsStrings(collection) {
+export function containsStrings<T>(collection: Array<T>) {
   return (
     Array.isArray(collection) &&
     collection.some((value) => typeof value === "string")
   );
 }
 
-export function containsDates(collection) {
+export function containsDates(collection: Array<number | Date>): boolean {
   return (
     Array.isArray(collection) &&
     collection.some((value) => value instanceof Date)
@@ -41,16 +38,22 @@ export function removeUndefined(arr) {
   return arr.filter((el) => el !== undefined);
 }
 
-export function getMaxValue(arr, ...values) {
-  const array = arr.concat(values);
+export function getMaxValue(
+  arr: Array<number | Date>,
+  ...values: Array<number | Date>
+): number | Date {
+  const array = arr.concat(values) as number[];
   return containsDates(array)
-    ? new Date(Math.max(...array))
+    ? new Date(Math.max(...array)) // Dates will be coerced to numbers
     : Math.max(...array);
 }
 
-export function getMinValue(arr, ...values) {
-  const array = arr.concat(values);
+export function getMinValue(
+  arr: Array<number | Date>,
+  ...values: Array<number | Date>
+): number | Date {
+  const array = arr.concat(values) as number[];
   return containsDates(array)
-    ? new Date(Math.min(...array))
+    ? new Date(Math.min(...array)) // Dates will be coerced to numbers
     : Math.min(...array);
 }

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

@@ -0,0 +1,307 @@
+import PropTypes from "prop-types";
+import * as CustomPropTypes from "./prop-types";
+import * as React from "react";
+import { OriginType } from "../victory-label/victory-label";
+import { PaddingProps, VictoryThemeDefinition } from "../victory-theme/types";
+import {
+  AnimatePropTypeInterface,
+  CategoryPropType,
+  ColorScalePropType,
+  D3Scale,
+  DataGetterPropType,
+  DomainPaddingPropType,
+  DomainPropType,
+  EventCallbackInterface,
+  RangePropType,
+  ScalePropType,
+  SortOrderPropType,
+  StringOrNumberOrList,
+} from "../types/prop-types";
+import { NumberOrCallback, StringOrCallback } from "../types/callbacks";
+
+export interface VictoryDatableProps {
+  categories?: CategoryPropType;
+  data?: readonly any[];
+  dataComponent?: React.ReactElement;
+  domain?: DomainPropType;
+  domainPadding?: DomainPaddingPropType;
+  samples?: number;
+  sortKey?: DataGetterPropType;
+  sortOrder?: SortOrderPropType;
+  x?: DataGetterPropType;
+  y?: DataGetterPropType;
+  y0?: DataGetterPropType;
+}
+const dataProps: React.WeakValidationMap<VictoryDatableProps> = {
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  categories: PropTypes.oneOfType([
+    PropTypes.arrayOf(PropTypes.string),
+    PropTypes.shape({
+      x: PropTypes.arrayOf(PropTypes.string),
+      y: PropTypes.arrayOf(PropTypes.string),
+    }),
+  ]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  data: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),
+  dataComponent: PropTypes.element,
+  disableInlineStyles: PropTypes.bool,
+  labelComponent: PropTypes.element,
+  labels: PropTypes.oneOfType([PropTypes.func, PropTypes.array]),
+  samples: CustomPropTypes.nonNegative,
+  sortKey: PropTypes.oneOfType([
+    PropTypes.func,
+    CustomPropTypes.allOfType([
+      CustomPropTypes.integer,
+      CustomPropTypes.nonNegative,
+    ]),
+    PropTypes.string,
+    PropTypes.arrayOf(PropTypes.string.isRequired),
+  ]),
+  sortOrder: PropTypes.oneOf(["ascending", "descending"]),
+  style: PropTypes.shape({
+    parent: PropTypes.object,
+    data: PropTypes.object,
+    labels: PropTypes.object,
+  }),
+  x: PropTypes.oneOfType([
+    PropTypes.func,
+    CustomPropTypes.allOfType([
+      CustomPropTypes.integer,
+      CustomPropTypes.nonNegative,
+    ]),
+    PropTypes.string,
+    PropTypes.arrayOf(PropTypes.string.isRequired),
+  ]),
+  y: PropTypes.oneOfType([
+    PropTypes.func,
+    CustomPropTypes.allOfType([
+      CustomPropTypes.integer,
+      CustomPropTypes.nonNegative,
+    ]),
+    PropTypes.string,
+    PropTypes.arrayOf(PropTypes.string.isRequired),
+  ]),
+  y0: PropTypes.oneOfType([
+    PropTypes.func,
+    CustomPropTypes.allOfType([
+      CustomPropTypes.integer,
+      CustomPropTypes.nonNegative,
+    ]),
+    PropTypes.string,
+    PropTypes.arrayOf(PropTypes.string.isRequired),
+  ]),
+};
+export interface VictoryCommonThemeProps {
+  animate?: boolean | AnimatePropTypeInterface;
+  colorScale?: ColorScalePropType;
+  containerComponent?: React.ReactElement;
+  domainPadding?: DomainPaddingPropType;
+  externalEventMutations?: EventCallbackInterface<
+    string | string[],
+    StringOrNumberOrList
+  >[];
+  groupComponent?: React.ReactElement;
+  height?: number;
+  horizontal?: boolean;
+  maxDomain?: number | { x?: number; y?: number };
+  minDomain?: number | { x?: number; y?: number };
+  name?: string;
+  origin?: OriginType;
+  padding?: PaddingProps;
+  polar?: boolean;
+  range?: RangePropType;
+  scale?:
+    | ScalePropType
+    | D3Scale
+    | {
+        x?: ScalePropType | D3Scale;
+        y?: ScalePropType | D3Scale;
+      };
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  sharedEvents?: { events: any[]; getEventState: Function };
+  singleQuadrantDomainPadding?: boolean | { x?: boolean; y?: boolean };
+  standalone?: boolean;
+  width?: number;
+}
+export interface VictoryCommonProps extends VictoryCommonThemeProps {
+  theme?: VictoryThemeDefinition;
+}
+const baseProps: React.WeakValidationMap<VictoryCommonProps> = {
+  animate: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
+  containerComponent: PropTypes.element,
+  domain: PropTypes.oneOfType([
+    CustomPropTypes.domain,
+    PropTypes.shape({ x: CustomPropTypes.domain, y: CustomPropTypes.domain }),
+  ]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  maxDomain: PropTypes.oneOfType([
+    PropTypes.number,
+    PropTypes.instanceOf(Date),
+    PropTypes.shape({
+      x: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
+      y: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
+    }),
+  ]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  minDomain: PropTypes.oneOfType([
+    PropTypes.number,
+    PropTypes.instanceOf(Date),
+    PropTypes.shape({
+      x: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
+      y: PropTypes.oneOfType([PropTypes.number, PropTypes.instanceOf(Date)]),
+    }),
+  ]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  domainPadding: PropTypes.oneOfType([
+    PropTypes.shape({
+      x: PropTypes.oneOfType([
+        PropTypes.number,
+        PropTypes.arrayOf(PropTypes.number),
+      ]),
+      y: PropTypes.oneOfType([
+        PropTypes.number,
+        PropTypes.arrayOf(PropTypes.number),
+      ]),
+    }),
+    PropTypes.number,
+    PropTypes.arrayOf(PropTypes.number),
+  ]),
+  eventKey: PropTypes.oneOfType([
+    PropTypes.func,
+    CustomPropTypes.allOfType([
+      CustomPropTypes.integer,
+      CustomPropTypes.nonNegative,
+    ]),
+    PropTypes.string,
+  ]),
+  events: PropTypes.arrayOf(
+    PropTypes.shape({
+      target: PropTypes.oneOf(["data", "labels", "parent"]),
+      eventKey: PropTypes.oneOfType([
+        PropTypes.array,
+        CustomPropTypes.allOfType([
+          CustomPropTypes.integer,
+          CustomPropTypes.nonNegative,
+        ]),
+        PropTypes.string,
+      ]),
+      eventHandlers: PropTypes.object,
+    }),
+  ),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  externalEventMutations: PropTypes.arrayOf(
+    PropTypes.shape({
+      callback: PropTypes.func,
+      childName: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
+      eventKey: PropTypes.oneOfType([
+        PropTypes.array,
+        CustomPropTypes.allOfType([
+          CustomPropTypes.integer,
+          CustomPropTypes.nonNegative,
+        ]),
+        PropTypes.string,
+      ]),
+      mutation: PropTypes.func,
+      target: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
+    }),
+  ),
+  groupComponent: PropTypes.element,
+  height: CustomPropTypes.nonNegative,
+  name: PropTypes.string,
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  origin: PropTypes.shape({ x: PropTypes.number, y: PropTypes.number }),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  padding: PropTypes.oneOfType([
+    PropTypes.number,
+    PropTypes.shape({
+      top: PropTypes.number,
+      bottom: PropTypes.number,
+      left: PropTypes.number,
+      right: PropTypes.number,
+    }),
+  ]),
+  polar: PropTypes.bool,
+  range: PropTypes.oneOfType([
+    CustomPropTypes.domain,
+    PropTypes.shape({
+      x: CustomPropTypes.domain.isRequired,
+      y: CustomPropTypes.domain.isRequired,
+    }),
+  ]),
+  scale: PropTypes.oneOfType([
+    CustomPropTypes.scale,
+    PropTypes.shape({
+      x: CustomPropTypes.scale.isRequired,
+      y: CustomPropTypes.scale.isRequired,
+    }),
+  ]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  sharedEvents: PropTypes.shape({
+    events: PropTypes.array,
+    getEventState: PropTypes.func,
+  }),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  singleQuadrantDomainPadding: PropTypes.oneOfType([
+    PropTypes.bool,
+    PropTypes.shape({
+      x: PropTypes.oneOfType([PropTypes.bool]),
+      y: PropTypes.oneOfType([PropTypes.bool]),
+    }),
+  ]),
+  standalone: PropTypes.bool,
+  theme: PropTypes.object,
+  width: CustomPropTypes.nonNegative,
+};
+
+export interface VictoryCommonPrimitiveProps {
+  active?: boolean;
+  ariaLabel?: StringOrCallback;
+  className?: string;
+  clipPath?: string;
+  data?: any;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  desc?: string | Function;
+  disableInlineStyles?: boolean;
+  events?: object;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  id?: number | string | Function;
+  index?: number | string;
+  origin?: OriginType;
+  polar?: boolean;
+  role?: string;
+  scale?: any;
+  shapeRendering?: string;
+  style?: any;
+  tabIndex?: NumberOrCallback;
+  transform?: string;
+}
+const primitiveProps: React.WeakValidationMap<VictoryCommonPrimitiveProps> = {
+  active: PropTypes.bool,
+  ariaLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+  className: PropTypes.string,
+  clipPath: PropTypes.string,
+  data: PropTypes.oneOfType([PropTypes.array, PropTypes.object]),
+  desc: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
+  disableInlineStyles: PropTypes.bool,
+  events: PropTypes.object,
+  id: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.func]),
+  index: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  // @ts-expect-error TODO: synchronize the type with this PropTypes
+  origin: PropTypes.shape({ x: PropTypes.number, y: PropTypes.number }),
+  polar: PropTypes.bool,
+  role: PropTypes.string,
+  scale: PropTypes.oneOfType([
+    CustomPropTypes.scale,
+    PropTypes.shape({ x: CustomPropTypes.scale, y: CustomPropTypes.scale }),
+  ]),
+  shapeRendering: PropTypes.string,
+  style: PropTypes.object,
+  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
+  transform: PropTypes.string,
+};
+
+export const CommonProps = {
+  dataProps,
+  baseProps,
+  primitiveProps,
+};

package/src/victory-util/{data.js → data.ts}

@@ -1,4 +1,3 @@
-/* eslint-disable func-style */
 /* eslint-disable no-use-before-define */
 import React from "react";
 import {
@@ -14,7 +13,7 @@ import {
   isEqual,
   includes,
   isUndefined,
-  omitBy
+  omitBy,
 } from "lodash";
 import * as Helpers from "./helpers";
 import * as Collection from "./collection";
@@ -26,7 +25,7 @@ import * as Immutable from "./immutable";
 function parseDatum(datum) {
   const immutableDatumWhitelist = {
     errorX: true,
-    errorY: true
+    errorY: true,
   };
 
   return Immutable.isImmutable(datum)
@@ -71,7 +70,7 @@ function cleanData(dataset, props) {
   const smallNumber = 1 / Number.MAX_SAFE_INTEGER;
   const scaleType = {
     x: Scale.getScaleType(props, "x"),
-    y: Scale.getScaleType(props, "y")
+    y: Scale.getScaleType(props, "y"),
   };
   if (scaleType.x !== "log" && scaleType.y !== "log") {
     return dataset;
@@ -189,7 +188,7 @@ export function createStringMap(props, axis) {
   const allStrings = uniq([
     ...stringsFromAxes,
     ...stringsFromCategories,
-    ...stringsFromData
+    ...stringsFromData,
   ]);
   return allStrings.length === 0
     ? null
@@ -216,7 +215,7 @@ export 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;
@@ -229,7 +228,11 @@ export function downsample(data, maxPoints, startingIndex = 0) {
  * @param {Array} expectedKeys: an array of expected data keys
  * @returns {Array} the formatted data
  */
-export function formatData(dataset, props, expectedKeys) {
+export function formatData(
+  dataset: any[],
+  props: any,
+  expectedKeys?: string[],
+) {
   const isArrayOrIterable =
     Array.isArray(dataset) || Immutable.isIterable(dataset);
   if (!isArrayOrIterable || getLength(dataset) < 1) {
@@ -241,7 +244,7 @@ export function formatData(dataset, props, expectedKeys) {
 
   const createAccessor = (name) => {
     return Helpers.createAccessor(
-      props[name] !== undefined ? props[name] : name
+      props[name] !== undefined ? props[name] : name,
     );
   };
 
@@ -271,7 +274,7 @@ export function formatData(dataset, props, expectedKeys) {
       y0:
         expectedKeys.indexOf("y0") !== -1
           ? createStringMap(props, "y")
-          : undefined
+          : undefined,
     };
   }
 
@@ -281,7 +284,7 @@ export function formatData(dataset, props, expectedKeys) {
         // eslint-disable-line complexity
         datum = parseDatum(datum);
         const fallbackValues = { x: index, y: datum };
-        const processedValues = expectedKeys.reduce((memo, type) => {
+        const processedValues = expectedKeys!.reduce((memo, type) => {
           const processedValue = accessor[type](datum);
           const value =
             processedValue !== undefined
@@ -447,7 +450,7 @@ export function isDataComponent(component) {
     "pie",
     "scatter",
     "stack",
-    "voronoi"
+    "voronoi",
   ];
   return includes(whitelist, role);
 }

package/src/victory-util/{default-transitions.js → default-transitions.ts}

@@ -1,24 +1,25 @@
-/* eslint-disable func-style */
-export function continuousTransitions() {
+import { AnimatePropTypeInterface } from "../types/prop-types";
+
+export function continuousTransitions(): AnimatePropTypeInterface {
   return {
     onLoad: {
-      duration: 2000
+      duration: 2000,
     },
     onExit: {
-      duration: 500
+      duration: 500,
     },
     onEnter: {
-      duration: 500
-    }
+      duration: 500,
+    },
   };
 }
 
-export function continuousPolarTransitions() {
+export function continuousPolarTransitions(): AnimatePropTypeInterface {
   return {
     onLoad: {
       duration: 2000,
       before: () => ({ _y: 0, _y1: 0, _y0: 0 }),
-      after: (datum) => ({ _y: datum._y, _y1: datum._y1, _y0: datum._y0 })
+      after: (datum) => ({ _y: datum._y, _y1: datum._y1, _y0: datum._y0 }),
     },
     onExit: {
       duration: 500,
@@ -30,9 +31,9 @@ export function continuousPolarTransitions() {
         return {
           _x: adjacent("_x"),
           _y: adjacent("_y"),
-          _y0: adjacent("_y0")
+          _y0: adjacent("_y0"),
         };
-      }
+      },
     },
     onEnter: {
       duration: 500,
@@ -44,34 +45,34 @@ export function continuousPolarTransitions() {
         return {
           _x: adjacent("_x"),
           _y: adjacent("_y"),
-          _y0: adjacent("_y0")
+          _y0: adjacent("_y0"),
         };
       },
       after: (datum) => ({
         _x: datum._x,
         _y: datum._y,
         _y1: datum._y1,
-        _y0: datum._y0
-      })
-    }
+        _y0: datum._y0,
+      }),
+    },
   };
 }
 
-export function discreteTransitions() {
+export function discreteTransitions(): AnimatePropTypeInterface {
   return {
     onLoad: {
       duration: 2000,
       before: () => ({ opacity: 0 }),
-      after: (datum) => datum
+      after: (datum) => datum,
     },
     onExit: {
       duration: 600,
-      before: () => ({ opacity: 0 })
+      before: () => ({ opacity: 0 }),
     },
     onEnter: {
       duration: 600,
       before: () => ({ opacity: 0 }),
-      after: (datum) => datum
-    }
+      after: (datum) => datum,
+    },
   };
 }