victory-core 36.5.0 → 36.5.3

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}

@@ -13,7 +13,7 @@ import {
   isEqual,
   includes,
   isUndefined,
-  omitBy
+  omitBy,
 } from "lodash";
 import * as Helpers from "./helpers";
 import * as Collection from "./collection";
@@ -25,7 +25,7 @@ import * as Immutable from "./immutable";
 function parseDatum(datum) {
   const immutableDatumWhitelist = {
     errorX: true,
-    errorY: true
+    errorY: true,
   };
 
   return Immutable.isImmutable(datum)
@@ -70,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;
@@ -188,7 +188,7 @@ export function createStringMap(props, axis) {
   const allStrings = uniq([
     ...stringsFromAxes,
     ...stringsFromCategories,
-    ...stringsFromData
+    ...stringsFromData,
   ]);
   return allStrings.length === 0
     ? null
@@ -215,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;
@@ -228,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) {
@@ -240,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,
     );
   };
 
@@ -270,7 +274,7 @@ export function formatData(dataset, props, expectedKeys) {
       y0:
         expectedKeys.indexOf("y0") !== -1
           ? createStringMap(props, "y")
-          : undefined
+          : undefined,
     };
   }
 
@@ -280,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
@@ -446,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,23 +1,25 @@
-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,
@@ -29,9 +31,9 @@ export function continuousPolarTransitions() {
         return {
           _x: adjacent("_x"),
           _y: adjacent("_y"),
-          _y0: adjacent("_y0")
+          _y0: adjacent("_y0"),
         };
-      }
+      },
     },
     onEnter: {
       duration: 500,
@@ -43,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,
+    },
   };
 }

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

@@ -6,7 +6,7 @@ import {
   sortedUniq,
   isFunction,
   includes,
-  isDate
+  isDate,
 } from "lodash";
 import * as Data from "./data";
 import * as Scale from "./scale";
@@ -47,11 +47,12 @@ function getDomainPadding(props, 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}`];
+function getFlatData(dataset, axis: "x" | "y") {
+  const axisKey = `_${axis}`;
+  return flatten(dataset).map((datum: any) => {
+    return datum[axisKey] && datum[axisKey][1] !== undefined
+      ? datum[axisKey][1]
+      : datum[axisKey];
   });
 }
 
@@ -60,7 +61,7 @@ function getExtremeFromData(dataset, axis, type = "min") {
     type === "max" ? Math.max(...arr) : Math.min(...arr);
   const initialValue = type === "max" ? -Infinity : Infinity;
   let containsDate = false;
-  const result = flatten(dataset).reduce((memo, datum) => {
+  const result = flatten(dataset).reduce((memo: number, datum: any) => {
     const current0 =
       datum[`_${axis}0`] !== undefined ? datum[`_${axis}0`] : datum[`_${axis}`];
     const current1 =
@@ -94,23 +95,23 @@ function padDomain(domain, props, axis) {
 
   const paddedRangeExtent = Math.max(
     rangeExtent - padding.left - padding.right,
-    1
+    1,
   );
   const paddedDomainExtent =
     (Math.abs(max.valueOf() - min.valueOf()) / paddedRangeExtent) * rangeExtent;
 
   const simplePadding = {
     left: (paddedDomainExtent * padding.left) / rangeExtent,
-    right: (paddedDomainExtent * padding.right) / rangeExtent
+    right: (paddedDomainExtent * padding.right) / rangeExtent,
   };
 
   let paddedDomain = {
     min: min.valueOf() - simplePadding.left,
-    max: max.valueOf() + simplePadding.right
+    max: max.valueOf() + simplePadding.right,
   };
 
   const singleQuadrantDomainPadding = isPlainObject(
-    props.singleQuadrantDomainPadding
+    props.singleQuadrantDomainPadding,
   )
     ? props.singleQuadrantDomainPadding[axis]
     : props.singleQuadrantDomainPadding;
@@ -128,14 +129,16 @@ function padDomain(domain, props, axis) {
   if (addsQuadrants && singleQuadrantDomainPadding !== false) {
     // Naive initial padding calculation
     const initialPadding = {
+      // @ts-expect-error `max/min` might be dates
       left: (Math.abs(max - min) * padding.left) / rangeExtent,
-      right: (Math.abs(max - min) * padding.right) / rangeExtent
+      // @ts-expect-error `max/min` might be dates
+      right: (Math.abs(max - min) * padding.right) / rangeExtent,
     };
 
     // Adjust the domain by the initial padding
     const adjustedDomain = {
       min: adjust(min.valueOf() - initialPadding.left, "min"),
-      max: adjust(max.valueOf() + initialPadding.right, "max")
+      max: adjust(max.valueOf() + initialPadding.right, "max"),
     };
 
     // re-calculate padding, taking the adjusted domain into account
@@ -145,20 +148,20 @@ function padDomain(domain, props, axis) {
         rangeExtent,
       right:
         (Math.abs(adjustedDomain.max - adjustedDomain.min) * padding.right) /
-        rangeExtent
+        rangeExtent,
     };
 
     // Adjust the domain by the final padding
     paddedDomain = {
       min: adjust(min.valueOf() - finalPadding.left, "min"),
-      max: adjust(max.valueOf() + finalPadding.right, "max")
+      max: adjust(max.valueOf() + finalPadding.right, "max"),
     };
   }
 
   // default to minDomain / maxDomain if they exist
   const finalDomain = {
     min: minDomain !== undefined ? minDomain : paddedDomain.min,
-    max: maxDomain !== undefined ? maxDomain : paddedDomain.max
+    max: maxDomain !== undefined ? maxDomain : paddedDomain.max,
   };
 
   return min instanceof Date || max instanceof Date
@@ -177,8 +180,8 @@ function padDomain(domain, props, axis) {
  * @returns {Function} a function that takes props and axis and returns a formatted domain
  */
 export function createDomainFunction(
-  getDomainFromDataFunction,
-  formatDomainFunction
+  getDomainFromDataFunction?,
+  formatDomainFunction?,
 ) {
   getDomainFromDataFunction = isFunction(getDomainFromDataFunction)
     ? getDomainFromDataFunction
@@ -227,7 +230,7 @@ export function getDomain(props, axis) {
  * @param {Array} categories: an array of categories corresponding to a given axis
  * @returns {Array|undefined} returns a domain from categories or undefined
  */
-export function getDomainFromCategories(props, axis, categories) {
+export function getDomainFromCategories(props, axis, categories?) {
   categories = categories || Data.getCategories(props, axis);
   const { polar, startAngle = 0, endAngle = 360 } = props;
   if (!categories) {
@@ -354,7 +357,7 @@ export function getDomainWithZero(props, axis) {
   const dataset = Data.getData(props);
   const y0Min = dataset.reduce(
     (min, datum) => (datum._y0 < min ? datum._y0 : min),
-    Infinity
+    Infinity,
   );
 
   const ensureZero = (domain) => {
@@ -387,7 +390,7 @@ export function getDomainWithZero(props, axis) {
 
   return createDomainFunction(getDomainFunction, formatDomainFunction)(
     props,
-    axis
+    axis,
   );
 }
 
@@ -428,7 +431,7 @@ export function getMinFromProps(props, axis) {
  * for a given dimension i.e. only x values.
  * @returns {Array} the symmetric domain
  */
-export function getSymmetricDomain(domain, values) {
+export function getSymmetricDomain(domain, values: number[]) {
   const processedData = sortedUniq(values.sort((a, b) => a - b));
   const step = processedData[1] - processedData[0];
   return [domain[0], domain[1] + step];
@@ -461,7 +464,7 @@ export function isDomainComponent(component) {
     "pie",
     "scatter",
     "stack",
-    "voronoi"
+    "voronoi",
   ];
   return includes(whitelist, role);
 }