victory-core 36.4.1 → 36.5.2

package/lib/victory-util/type-helpers.d.ts

@@ -0,0 +1,10 @@
+import { ForAxes, AxisType, Tuple, Datum, DatumValue } from "../types/prop-types";
+export declare function hasValueForAxis<T = unknown>(value: unknown | ForAxes<T>, axis: AxisType): value is ForAxes<T>;
+export declare function isTuple<T = unknown>(value: unknown): value is Tuple<T>;
+export declare function getValueForAxis<T = unknown>(value: T | ForAxes<T> | undefined, axis: AxisType): T | undefined;
+export declare function isFunction<T = Function>(func?: unknown): func is T;
+export declare function isDate(value: unknown): value is Date;
+export declare function isKeyValueObject(datum: Datum): datum is {
+    [key: string]: DatumValue;
+};
+//# sourceMappingURL=type-helpers.d.ts.map

package/lib/victory-util/type-helpers.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValueForAxis = getValueForAxis;
+exports.hasValueForAxis = hasValueForAxis;
+exports.isDate = isDate;
+exports.isFunction = isFunction;
+exports.isKeyValueObject = isKeyValueObject;
+exports.isTuple = isTuple;
+
+function hasValueForAxis(value, axis) {
+  if (typeof value === "object" && value !== null) {
+    return axis in value;
+  }
+
+  return false;
+}
+
+function isTuple(value) {
+  return Array.isArray(value) && value.length === 2;
+}
+
+function getValueForAxis(value, axis) {
+  if (hasValueForAxis(value, axis)) {
+    return value[axis];
+  }
+
+  return value;
+} // eslint-disable-next-line @typescript-eslint/ban-types
+
+
+function isFunction(func) {
+  return typeof func === "function";
+}
+
+function isDate(value) {
+  return value instanceof Date;
+}
+
+function isKeyValueObject(datum) {
+  return typeof datum === "object" && !Array.isArray(datum) && !(datum instanceof Date);
+}
+//# sourceMappingURL=type-helpers.js.map

package/lib/victory-util/user-props.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+declare type SafeAttribute = `data-${string}` | `aria-${string}`;
+/**
+ * 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
+ * object.
+ *
+ * @param {Object} props: props to be filtered against USER_PROPS_SAFELIST
+ * @returns {Object}: object containing remaining acceptable props
+ */
+export declare const getSafeUserProps: <T>(props: T) => Record<SafeAttribute, string>;
+/**
+ * Wraps a component and adds safe user props
+ *
+ * @param {ReactElement} component: parent component
+ * @param {Object} props: props to be filtered
+ * @returns {ReactElement} modified component
+ */
+export declare const withSafeUserProps: (component: React.ReactElement, props: any) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export {};
+//# sourceMappingURL=user-props.d.ts.map

package/lib/victory-util/user-props.js

@@ -31,7 +31,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 /*
   USER_PROPS_SAFELIST is to contain any string deemed safe for user props.
-  The startsWidth array will contain the start of any accepted user-prop that 
+  The startsWidth array will contain the start of any accepted user-prop that
   starts with these characters.
   The exactMatch will contain a list of exact prop names that are accepted.
 */
@@ -39,6 +39,7 @@ var USER_PROPS_SAFELIST = {
   startsWith: ["data-", "aria-"],
   exactMatch: []
 };
+
 /**
  * doesPropStartWith: Function that takes a prop's key and runs it against all
  * options in the USER_PROPS_SAFELIST and checks to see if it starts with any
@@ -47,7 +48,6 @@ var USER_PROPS_SAFELIST = {
  * @returns {Boolean}: returns true if the key starts with an option or false if
  * otherwise
  */
-
 var doesPropStartWith = function (key) {
   var startsWith = false;
   USER_PROPS_SAFELIST.startsWith.forEach(function (starterString) {
@@ -124,9 +124,9 @@ var getSafeUserProps = function (props) {
 /**
  * Wraps a component and adds safe user props
  *
- * @param {ReactNode} component: parent component
+ * @param {ReactElement} component: parent component
  * @param {Object} props: props to be filtered
- * @returns {ReactNode} modified component
+ * @returns {ReactElement} modified component
  */
 
 
@@ -136,4 +136,5 @@ var withSafeUserProps = function (component, props) {
   return /*#__PURE__*/React.cloneElement(component, getSafeUserProps(props));
 };
 
-exports.withSafeUserProps = withSafeUserProps;
+exports.withSafeUserProps = withSafeUserProps;
+//# sourceMappingURL=user-props.js.map

package/lib/victory-util/with-container.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { VictoryProviderProps } from "victory-core";
+import { VictoryCommonProps } from "./common-props";
+export declare function withContainer<Props extends VictoryCommonProps>(WrappedComponent: (props: Props) => React.ReactElement, initialProviderProps?: Partial<VictoryProviderProps>): (props: Props) => JSX.Element;
+//# sourceMappingURL=with-container.d.ts.map

package/lib/victory-util/with-container.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withContainer = withContainer;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _victoryCore = require("victory-core");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var defaultProviderProps = {
+  width: 450,
+  height: 300,
+  padding: 50,
+  data: []
+};
+
+function withContainer(WrappedComponent) {
+  var initialProviderProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return function (props) {
+    var providerProps = _objectSpread(_objectSpread(_objectSpread({}, defaultProviderProps), initialProviderProps), props);
+
+    var _props$standalone = props.standalone,
+        standalone = _props$standalone === void 0 ? true : _props$standalone,
+        _props$containerCompo = props.containerComponent,
+        containerComponent = _props$containerCompo === void 0 ? /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryContainer, null) : _props$containerCompo;
+
+    if (standalone) {
+      return /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryProvider, providerProps, /*#__PURE__*/_react.default.cloneElement(containerComponent, providerProps, /*#__PURE__*/_react.default.createElement(WrappedComponent, props)));
+    }
+
+    return /*#__PURE__*/_react.default.createElement(WrappedComponent, props);
+  };
+}
+//# sourceMappingURL=with-container.js.map

package/lib/victory-util/wrapper.d.ts

@@ -0,0 +1,38 @@
+export declare function addBinsToParentPropsIfHistogram({ children, props, childComponents, parentProps, }: {
+    children: any;
+    props: any;
+    childComponents: any;
+    parentProps: any;
+}): any;
+export declare function getDataFromChildren(props: any, childComponents: any): any[][];
+export declare function getData(props: any, childComponents: any): any;
+export declare function getWidth(props: any, groupLength?: any, seriesLength?: any): number;
+export declare function getDefaultDomainPadding(props: any, axis: any, childComponents: any): {
+    x: number;
+} | undefined;
+export declare function getDomainFromChildren(props: any, axis: any, childComponents: any): (number | Date)[];
+export declare function getDomain(props: any, axis: any, childComponents: any): any;
+export declare function getScale(props: any, axis: any, childComponents?: any): import("..").D3Scale<any>;
+export declare function getAllEvents(props: any): any;
+export declare function getColor(calculatedProps: any, child: any, index: any): any;
+export declare function getStyle(theme: any, style: any, role: any): any;
+export declare function getChildStyle(child: any, index: any, calculatedProps: any): any[] | {
+    parent: any;
+    data: any;
+    labels: any;
+};
+export declare function getStringsFromCategories(childComponents: any, axis: any): any[];
+export declare function getStringsFromData(childComponents: any): {
+    x: number[];
+    y: number[];
+};
+export declare function getCategoryAndAxisStringsFromChildren(props: any, axis: any, childComponents: any): any[];
+export declare function getStringsFromChildren(props: any, childComponents: any): {
+    x: any[];
+    y: any[];
+};
+export declare function getCategories(props: any, childComponents: any, allStrings: any): {
+    x: any;
+    y: any;
+};
+//# sourceMappingURL=wrapper.d.ts.map

package/lib/victory-util/wrapper.js

@@ -199,7 +199,7 @@ function getData(props, childComponents) {
   }
 
   childComponents = childComponents || _react.default.Children.toArray(props.children);
-  return getDataFromChildren(childComponents);
+  return getDataFromChildren(props, childComponents);
 }
 
 function getWidth(props, groupLength, seriesLength) {
@@ -264,7 +264,7 @@ function getDefaultDomainPadding(props, axis, childComponents) {
 function getDomainFromChildren(props, axis, childComponents) {
   // eslint-disable-line max-statements, complexity, max-len
   var children = childComponents ? childComponents.slice(0) : _react.default.Children.toArray(props.children);
-  var parentData = props.data ? Data.getData(props, axis) : undefined;
+  var parentData = props.data ? Data.getData(props) : undefined;
   var polar = props.polar,
       startAngle = props.startAngle,
       endAngle = props.endAngle,
@@ -503,4 +503,5 @@ function getCategories(props, childComponents, allStrings) {
     x: xCategories.length > 0 ? xCategories : undefined,
     y: yCategories.length > 0 ? yCategories : undefined
   };
-}
+}
+//# sourceMappingURL=wrapper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-core",
-  "version": "36.4.1",
+  "version": "36.5.2",
   "description": "Victory Core",
   "keywords": [
     "data visualization",
@@ -22,14 +22,14 @@
     "lodash": "^4.17.21",
     "prop-types": "^15.8.1",
     "react-fast-compare": "^3.2.0",
-    "victory-vendor": "^36.4.0"
+    "victory-vendor": "^36.5.1"
   },
   "peerDependencies": {
-    "react": "^16.6.0 || ^17.0.0"
+    "react": ">=16.6.0"
   },
   "scripts": {
     "version": "yarn run nps build-libs && nps build-dists"
   },
   "sideEffects": false,
-  "gitHead": "aa44a22e5a93989773a560f765f83ac151f44c46"
+  "gitHead": "def218e9749ecafc159ef458dd03a8b92e227666"
 }

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./types/callbacks";
+export * from "./types/prop-types";
+export * from "./victory-accessible-group/victory-accessible-group";
+export * from "./victory-animation/victory-animation";
+export * from "./victory-container/victory-container";
+export * from "./victory-label/victory-label";
+export * from "./victory-transition/victory-transition";
+export * from "./victory-clip-container/victory-clip-container";
+export * from "./victory-theme/types";
+export * from "./victory-theme/victory-theme";
+export * from "./victory-portal/portal";
+export * from "./victory-portal/portal-context";
+export * from "./victory-portal/victory-portal";
+export * from "./victory-primitives";
+export { Border as Box } from "./victory-primitives";
+export * from "./victory-util";
+export * from "./victory-state";

package/src/types/callbacks.ts

@@ -0,0 +1,53 @@
+import { D3Scale, Datum, ID } from "./prop-types";
+import { BlockProps, OrientationTypes } from "../victory-theme/types";
+
+/**
+ * This is the first parameter of a callback when a callback is used to
+ * resolve the value of a property instead of a concrete value.
+ *
+ * Note that additional properties here like `scale`, `x`, `y`, etc are resolved
+ * values of properties from the VictoryXXXProps for each component.
+ */
+export interface CallbackArgs {
+  active?: boolean;
+  data?: Datum[];
+  datum?: Datum;
+  horizontal?: boolean;
+  index: ID;
+  x?: number;
+  y?: number;
+  scale?: {
+    x?: D3Scale;
+    y?: D3Scale;
+  };
+  tick?: any;
+  ticks?: any;
+  text?: any;
+}
+
+export type VictoryStringOrNumberCallback = (
+  args: CallbackArgs,
+) => string | number;
+
+export type VictoryStringCallback = (args: CallbackArgs) => string;
+export type StringOrNumberOrCallback =
+  | string
+  | number
+  | VictoryStringOrNumberCallback;
+export type StringOrCallback = string | VictoryStringCallback;
+export type SliceNumberOrCallback<
+  T,
+  P extends string | number | symbol = never,
+> = number | ((props: Omit<T, P>) => number);
+export type VictoryNumberCallback = (args: CallbackArgs) => number;
+export type VictoryPaddingCallback = (
+  args: CallbackArgs,
+) => number | BlockProps;
+export type VictoryOrientationCallback = (
+  args: CallbackArgs,
+) => OrientationTypes;
+export type NumberOrCallback = number | VictoryNumberCallback;
+export type PaddingOrCallback = number | BlockProps | VictoryPaddingCallback;
+export type OrientationOrCallback =
+  | OrientationTypes
+  | VictoryOrientationCallback;

package/src/types/prop-types.ts

@@ -0,0 +1,195 @@
+import * as React from "react";
+import {
+  ScaleLinear,
+  ScaleLogarithmic,
+  ScalePower,
+  ScaleTime,
+} from "victory-vendor/d3-scale";
+import {
+  AnimationEasing,
+  AnimationStyle,
+} from "../victory-animation/victory-animation";
+import { StringOrNumberOrCallback } from "./callbacks";
+
+export type AxisType = "x" | "y";
+export type DatumValue = number | string | Date | null | undefined;
+export type Datum = any;
+export type ForAxes<T> = T | { x?: T; y?: T };
+export type ID = number | string;
+export type ValueOrAccessor<ValueType = unknown, PropsType = object> =
+  | ValueType
+  | ((props: PropsType) => ValueType);
+export type Tuple<T> = [T, T];
+export type ValueOrAxes<T> = T | ForAxes<T>;
+
+export type DomainPaddingPropType = ValueOrAxes<PaddingType>;
+export type DomainPropType = ValueOrAxes<DomainTuple>;
+export type DomainValue = number | Date;
+// This should be a tuple type, but every time we use it, it fails with a type error.
+// type number[] is not assignable to type [number, number] | [Date, Date].
+export type DomainTuple = Tuple<number> | Tuple<Date>;
+export type PaddingType = number | Tuple<number>;
+export type RangePropType = ValueOrAxes<RangeTuple>;
+export type RangeTuple = number[];
+export type StringOrNumberOrList = string | number | (string | number)[];
+
+export interface Padding {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}
+
+export interface AnimatePropTypeInterface {
+  duration?: number;
+  onEnd?: () => void;
+  onExit?: {
+    duration?: number;
+    before?: (datum: Datum, index: number, data: Datum[]) => AnimationStyle;
+  };
+  onEnter?: {
+    duration?: number;
+    before?: (datum: Datum, index: number, data: Datum[]) => AnimationStyle;
+    after?: (datum: Datum, index: number, data: Datum[]) => AnimationStyle;
+  };
+  onLoad?: {
+    duration?: number;
+    before?: (datum: Datum, index: number, data: Datum[]) => AnimationStyle;
+    after?: (datum: Datum, index: number, data: Datum[]) => AnimationStyle;
+  };
+  easing?: AnimationEasing;
+  animationWhitelist?: string[];
+}
+
+export interface EventCallbackInterface<TTarget, TEventKey> {
+  childName?: string | string[];
+  target?: TTarget;
+  eventKey?: TEventKey;
+  mutation: (props: any) => any;
+  callback?: (props: any) => any;
+}
+
+export interface EventPropTypeInterface<TTarget, TEventKey> {
+  childName?: string | Array<StringOrNumberOrCallback>;
+  target: TTarget;
+  eventKey?: TEventKey;
+  eventHandlers: {
+    [key: string]:
+      | {
+          (
+            event: React.SyntheticEvent<any>,
+            props?: any,
+          ): EventCallbackInterface<TTarget, TEventKey>;
+        }
+      | {
+          (
+            event: React.SyntheticEvent<any>,
+            props?: any,
+          ): EventCallbackInterface<TTarget, TEventKey>[];
+        }
+      | {
+          (event: React.SyntheticEvent<any>, props?: any): void;
+        };
+  };
+}
+
+type NumberValue = number | { valueOf(): number };
+/**
+ * D3 scale function shape. Don't want to introduce typing dependency to d3
+ */
+export interface D3Scale<TRange = any> {
+  (numberValue: NumberValue): number;
+  base?: () => number;
+  ticks: (count?: number) => number[];
+  tickFormat: (count?: number) => (d: number) => string;
+  domain: {
+    (): number[];
+    (domain: NumberValue[]): D3Scale<TRange>;
+  };
+  range: {
+    (): TRange[];
+    (range: TRange): D3Scale<TRange>;
+  };
+  copy: () => this;
+  invert: (value: number) => number;
+}
+
+export type D3ScaleFn<TRange = any, TOutput = any> = () =>
+  | ScaleLinear<TRange, TOutput, unknown>
+  | ScaleLogarithmic<TRange, TOutput, unknown>
+  | ScaleTime<TRange, TOutput, unknown>
+  | ScalePower<TRange, TOutput, unknown>;
+
+export type ScaleName = "linear" | "time" | "log" | "sqrt";
+export type ScalePropType = ScaleName;
+export type ScaleXYPropType = {
+  x: D3Scale;
+  y: D3Scale;
+};
+
+export type CategoryPropType =
+  | string[]
+  | { x: string[] }
+  | { y: string[] }
+  | {
+      x: string[];
+      y: string[];
+    };
+
+export type DataGetterPropType = ValueOrAccessor<
+  string | string[] | number | number[]
+>;
+
+export type InterpolationPropType =
+  | "basis"
+  | "basisClosed"
+  | "basisOpen"
+  | "bundle"
+  | "cardinal"
+  | "cardinalClosed"
+  | "cardinalOpen"
+  | "catmullRom"
+  | "catmullRomClosed"
+  | "catmullRomOpen"
+  | "linear"
+  | "linearClosed"
+  | "monotoneX"
+  | "monotoneY"
+  | "natural"
+  | "radial"
+  | "step"
+  | "stepAfter"
+  | "stepBefore";
+
+export type ColorScalePropType =
+  | "grayscale"
+  | "qualitative"
+  | "heatmap"
+  | "warm"
+  | "cool"
+  | "red"
+  | "green"
+  | "blue"
+  | string[];
+
+export type SortOrderPropType = "ascending" | "descending";
+
+export interface VictoryLabelableProps {
+  labelComponent?: React.ReactElement;
+}
+
+export interface VictoryMultiLabelableProps extends VictoryLabelableProps {
+  labels?:
+    | string[]
+    | number[]
+    | { (data: any): string | string[] | number | number[] | null };
+}
+
+export interface VictorySingleLabelableProps extends VictoryLabelableProps {
+  label?: string | { (data: any): string | number | null };
+}
+
+export type CoordinatesPropType = {
+  x: number;
+  y: number;
+};

package/src/victory-accessible-group/{victory-accessible-group.js → victory-accessible-group.tsx}

@@ -1,22 +1,31 @@
 import React from "react";
 import PropTypes from "prop-types";
 
-class VictoryAccessibleGroup extends React.Component {
+export interface VictoryAccessibleGroupProps {
+  desc?: string;
+  "aria-describedby"?: string;
+  "aria-label"?: string;
+  children?: React.ReactElement | React.ReactElement[];
+  className?: string;
+  tabIndex?: number;
+}
+
+export class VictoryAccessibleGroup extends React.Component<VictoryAccessibleGroupProps> {
   static displayName = "VictoryAccessibleGroup";
   static propTypes = {
     "aria-describedby": PropTypes.string,
     "aria-label": PropTypes.string,
     children: PropTypes.oneOfType([
       PropTypes.arrayOf(PropTypes.node),
-      PropTypes.node
+      PropTypes.node,
     ]),
     className: PropTypes.string,
     desc: PropTypes.string,
-    tabIndex: PropTypes.number
+    tabIndex: PropTypes.number,
   };
 
   static defaultProps = {
-    className: "VictoryAccessibleGroup"
+    className: "VictoryAccessibleGroup",
   };
 
   render() {
@@ -46,5 +55,3 @@ class VictoryAccessibleGroup extends React.Component {
     );
   }
 }
-
-export default VictoryAccessibleGroup;

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

@@ -34,7 +34,7 @@ export const isInterpolatable = function (obj) {
         // component is only going to call the function (in which case it's
         // safely interpolatable) or if it's going to access special properties
         // (in which case our function generated from `interpolateFunction` will
-        // most likely cause an error. We could check for enumerable properties
+        // most likely cause an error). We could check for enumerable properties
         // on the function object here to see if it's a "plain" function, but
         // let's just require that components prevent such function props from
         // being animated in the first place.
@@ -82,8 +82,8 @@ export const interpolateFunction = function (a, b) {
     if (t >= 1) {
       return b;
     }
-    return function () {
-      /* eslint-disable no-invalid-this */
+    return function (this: unknown) {
+      /* eslint-disable no-invalid-this, prefer-rest-params */
       const aval = typeof a === "function" ? a.apply(this, arguments) : a;
       const bval = typeof b === "function" ? b.apply(this, arguments) : b;
       return interpolate(aval, bval)(t);
@@ -182,7 +182,7 @@ export const interpolateString = function (a, b) {
  * @param {any} b - End value.
  * @returns {Function|undefined} An interpolation function, if necessary.
  */
-export const victoryInterpolator = function (a, b) {
+export const victoryInterpolator = function <T>(a: T, b: T): (t: number) => T {
   // If the values are strictly equal, or either value is not interpolatable,
   // just use either the start value `a` or end value `b` at every step, as
   // there is no reasonable in-between value.
@@ -193,10 +193,12 @@ export const victoryInterpolator = function (a, b) {
     return interpolateFunction(a, b);
   }
   if (isPlainObject(a) || isPlainObject(b)) {
+    // @ts-expect-error These generics are tough, but they work :)
     return interpolateObject(a, b);
   }
   if (typeof a === "string" || typeof b === "string") {
     return interpolateString(a, b);
   }
+  // @ts-expect-error These generics are tough, but they work :)
   return interpolate(a, b);
 };