victory-core 36.3.2 → 36.5.0

package/es/index.js

@@ -1,28 +1,19 @@
 // This rule doesn't play well with namespaced exports
 
 /* eslint-disable import/export */
-export { default as VictoryAccessibleGroup } from "./victory-accessible-group/victory-accessible-group";
-export { default as VictoryAnimation } from "./victory-animation/victory-animation";
-export { default as VictoryContainer } from "./victory-container/victory-container";
-export { default as VictoryLabel } from "./victory-label/victory-label";
-export { default as VictoryTransition } from "./victory-transition/victory-transition";
-export { default as VictoryClipContainer } from "./victory-clip-container/victory-clip-container";
-export { default as VictoryTheme } from "./victory-theme/victory-theme";
-export { default as VictoryPortal } from "./victory-portal/victory-portal";
-export { default as Portal } from "./victory-portal/portal";
-export { default as Arc } from "./victory-primitives/arc";
-export { default as Background } from "./victory-primitives/background";
-export { default as Border, default as Box } from "./victory-primitives/border";
-export { default as Circle } from "./victory-primitives/circle";
-export { default as ClipPath } from "./victory-primitives/clip-path";
-export { default as Line } from "./victory-primitives/line";
-export { default as LineSegment } from "./victory-primitives/line-segment";
-export { default as Path } from "./victory-primitives/path";
-export { default as Point } from "./victory-primitives/point";
-export { default as Rect } from "./victory-primitives/rect";
-export { default as Text } from "./victory-primitives/text";
-export { default as TSpan } from "./victory-primitives/tspan";
-export { default as Whisker } from "./victory-primitives/whisker";
+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/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"; // victory-util:
+
 export { default as addEvents } from "./victory-util/add-events";
 import * as _Collection from "./victory-util/collection";
 export { _Collection as Collection };
@@ -52,7 +43,6 @@ import * as _Style from "./victory-util/style";
 export { _Style as Style };
 import * as _TextSize from "./victory-util/textsize";
 export { _TextSize as TextSize };
-export { default as Timer } from "./victory-util/timer";
 import * as _Transitions from "./victory-util/transitions";
 export { _Transitions as Transitions };
 import * as _UserProps from "./victory-util/user-props";
@@ -63,11 +53,12 @@ import * as _Wrapper from "./victory-util/wrapper";
 export { _Wrapper as Wrapper };
 import * as _Axis from "./victory-util/axis";
 export { _Axis as Axis };
-export { default as TimerContext } from "./victory-util/timer-context";
-export { default as PortalContext } from "./victory-portal/portal-context";
 import * as _Hooks from "./victory-util/hooks";
 export { _Hooks as Hooks };
 import * as _LineHelpers from "./victory-util/line-helpers";
-export { _LineHelpers as LineHelpers }; // TODO: Fix this default export
-
-export { default as PointPathHelpers } from "./victory-util/point-path-helpers";
+export { _LineHelpers as LineHelpers };
+export { default as Timer } from "./victory-util/timer";
+import * as _PointPathHelpers from "./victory-util/point-path-helpers";
+export { _PointPathHelpers as PointPathHelpers };
+export { default as TimerContext } from "./victory-util/timer-context";
+export * from "./victory-util/types";

package/es/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+import type { D3Scale } from "./victory-util/types";
+export interface CallbackArgs {
+    active?: boolean;
+    data?: any;
+    datum?: any;
+    horizontal?: boolean;
+    index: number | string;
+    x?: number;
+    y?: number;
+    scale?: {
+        x?: D3Scale;
+        y?: D3Scale;
+    };
+    tick?: any;
+    ticks?: any;
+    text?: any;
+}
+export declare type VictoryStringOrNumberCallback = (args: CallbackArgs) => string | number;
+export declare type VictoryStringCallback = (args: CallbackArgs) => string;
+export declare type StringOrNumberOrCallback = string | number | VictoryStringOrNumberCallback;
+export declare type StringOrCallback = string | VictoryStringCallback;
+export declare type SliceNumberOrCallback<T, P extends string | number | symbol = never> = number | ((props: Omit<T, P>) => number);
+export declare type CoordinatesPropType = {
+    x: number;
+    y: number;
+};

package/es/types.js

@@ -0,0 +1 @@
+export {};

package/es/victory-accessible-group/victory-accessible-group.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import PropTypes from "prop-types";
+export interface VictoryAccessibleGroupProps {
+    desc?: string;
+    "aria-describedby"?: string;
+    "aria-label"?: string;
+    children?: React.ReactElement | React.ReactElement[];
+    className?: string;
+    tabIndex?: number;
+}
+export declare class VictoryAccessibleGroup extends React.Component<VictoryAccessibleGroupProps> {
+    static displayName: string;
+    static propTypes: {
+        "aria-describedby": PropTypes.Requireable<string>;
+        "aria-label": PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<string | number | boolean | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        className: PropTypes.Requireable<string>;
+        desc: PropTypes.Requireable<string>;
+        tabIndex: PropTypes.Requireable<number>;
+    };
+    static defaultProps: {
+        className: string;
+    };
+    render(): JSX.Element;
+}

package/es/victory-accessible-group/victory-accessible-group.js

@@ -2,45 +2,52 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 import React from "react";
 import PropTypes from "prop-types";
-
-var VictoryAccessibleGroup =
-/*#__PURE__*/
-function (_React$Component) {
+export var VictoryAccessibleGroup = /*#__PURE__*/function (_React$Component) {
   _inherits(VictoryAccessibleGroup, _React$Component);
 
+  var _super = _createSuper(VictoryAccessibleGroup);
+
   function VictoryAccessibleGroup() {
     _classCallCheck(this, VictoryAccessibleGroup);
 
-    return _possibleConstructorReturn(this, (VictoryAccessibleGroup.__proto__ || Object.getPrototypeOf(VictoryAccessibleGroup)).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(VictoryAccessibleGroup, [{
     key: "render",
     value: function render() {
-      var _props = this.props,
-          desc = _props.desc,
-          children = _props.children,
-          className = _props.className,
-          tabIndex = _props.tabIndex;
+      var _this$props = this.props,
+          desc = _this$props.desc,
+          children = _this$props.children,
+          className = _this$props.className,
+          tabIndex = _this$props.tabIndex;
       var descId = desc && (this.props["aria-describedby"] || desc.split(" ").join("-"));
-      return desc ? React.createElement("g", {
+      return desc ? /*#__PURE__*/React.createElement("g", {
         "aria-label": this.props["aria-label"],
         "aria-describedby": descId,
         className: className,
         tabIndex: tabIndex
-      }, React.createElement("desc", {
+      }, /*#__PURE__*/React.createElement("desc", {
         id: descId
-      }, desc), children) : React.createElement("g", {
+      }, desc), children) : /*#__PURE__*/React.createElement("g", {
         "aria-label": this.props["aria-label"],
         "aria-describedby": this.props["aria-describedby"],
         className: className,
@@ -51,32 +58,15 @@ function (_React$Component) {
 
   return VictoryAccessibleGroup;
 }(React.Component);
-
-Object.defineProperty(VictoryAccessibleGroup, "displayName", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: "VictoryAccessibleGroup"
-});
-Object.defineProperty(VictoryAccessibleGroup, "propTypes", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: {
-    "aria-describedby": PropTypes.string,
-    "aria-label": PropTypes.string,
-    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
-    className: PropTypes.string,
-    desc: PropTypes.string,
-    tabIndex: PropTypes.number
-  }
-});
-Object.defineProperty(VictoryAccessibleGroup, "defaultProps", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: {
-    className: "VictoryAccessibleGroup"
-  }
-});
-export default VictoryAccessibleGroup;
+VictoryAccessibleGroup.displayName = "VictoryAccessibleGroup";
+VictoryAccessibleGroup.propTypes = {
+  "aria-describedby": PropTypes.string,
+  "aria-label": PropTypes.string,
+  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+  className: PropTypes.string,
+  desc: PropTypes.string,
+  tabIndex: PropTypes.number
+};
+VictoryAccessibleGroup.defaultProps = {
+  className: "VictoryAccessibleGroup"
+};

package/es/victory-animation/util.d.ts

@@ -0,0 +1,66 @@
+export declare const isInterpolatable: (obj: any) => boolean;
+/**
+ * Interpolate immediately to the end value at the given step `when`.
+ * Some nicer default behavior might be to jump at the halfway point or return
+ * `a` if `t` is 0 (instead of always returning `b`). But d3's default
+ * interpolator does not do these things:
+ *
+ *   d3.interpolate('aaa', 'bbb')(0) === 'bbb'
+ *
+ * ...and things might get wonky if we don't replicate that behavior.
+ *
+ * @param {any} a - Start value.
+ * @param {any} b - End value.
+ * @param {Number} when - Step value (0 to 1) at which to jump to `b`.
+ * @returns {Function} An interpolation function.
+ */
+export declare const interpolateImmediate: (a: any, b: any, when?: number) => (t: any) => any;
+/**
+ * Interpolate to or from a function. The interpolated value will be a function
+ * that calls `a` (if it's a function) and `b` (if it's a function) and calls
+ * `d3.interpolate` on the resulting values. Note that our function won't
+ * necessarily be called (that's up to the component this eventually gets
+ * passed to) - but if it does get called, it will return an appropriately
+ * interpolated value.
+ *
+ * @param {any} a - Start value.
+ * @param {any} b - End value.
+ * @returns {Function} An interpolation function.
+ */
+export declare const interpolateFunction: (a: any, b: any) => (t: any) => any;
+/**
+ * Interpolate to or from an object. This method is a modification of the object interpolator in
+ * d3-interpolate https://github.com/d3/d3-interpolate/blob/master/src/object.js. This interpolator
+ * differs in that it uses our custom interpolators when interpolating the value of each property in
+ * an object. This allows the correct interpolation of nested objects, including styles
+ *
+ * @param {any} a - Start value.
+ * @param {any} b - End value.
+ * @returns {Function} An interpolation function.
+ */
+export declare const interpolateObject: (a: any, b: any) => (t: any) => {};
+export declare const interpolateString: (a: any, b: any) => any;
+/**
+ * By default, the list of interpolators used by `d3.interpolate` has a few
+ * downsides:
+ *
+ * - `null` values get turned into 0.
+ * - `undefined`, `function`, and some other value types get turned into NaN.
+ * - Boolean types get turned into numbers, which probably will be meaningless
+ *   to whatever is consuming them.
+ * - It tries to interpolate between identical start and end values, doing
+ *   unnecessary calculations that sometimes result in floating point rounding
+ *   errors.
+ *
+ * If only the default interpolators are used, `VictoryAnimation` will happily
+ * pass down NaN (and other bad) values as props to the wrapped component.
+ * The component will then either use the incorrect values or complain that it
+ * was passed props of the incorrect type. This custom interpolator is added
+ * using the `d3.interpolators` API, and prevents such cases from happening
+ * for most values.
+ *
+ * @param {any} a - Start value.
+ * @param {any} b - End value.
+ * @returns {Function|undefined} An interpolation function, if necessary.
+ */
+export declare const victoryInterpolator: <T>(a: T, b: T) => (t: number) => T;

package/es/victory-animation/util.js

@@ -1,6 +1,6 @@
 import _orderBy from "lodash/orderBy";
 import _isPlainObject from "lodash/isPlainObject";
-import { interpolate } from "d3-interpolate";
+import { interpolate } from "victory-vendor/d3-interpolate";
 export var isInterpolatable = function (obj) {
   // d3 turns null into 0 and undefined into NaN, which we don't want.
   if (obj !== null) {
@@ -87,7 +87,7 @@ export var interpolateFunction = function (a, b) {
     }
 
     return function () {
-      /* eslint-disable no-invalid-this */
+      /* eslint-disable no-invalid-this, prefer-rest-params */
       var aval = typeof a === "function" ? a.apply(this, arguments) : a;
       var bval = typeof b === "function" ? b.apply(this, arguments) : b;
       return interpolate(aval, bval)(t);
@@ -200,6 +200,7 @@ export var victoryInterpolator = function (a, b) {
   }
 
   if (_isPlainObject(a) || _isPlainObject(b)) {
+    // @ts-expect-error These generics are tough, but they work ok?
     return interpolateObject(a, b);
   }
 

package/es/victory-animation/victory-animation.d.ts

@@ -0,0 +1,69 @@
+import React from "react";
+import PropTypes from "prop-types";
+import TimerContext from "../victory-util/timer-context";
+import type Timer from "../victory-util/timer";
+/**
+ * Single animation object to interpolate
+ */
+export declare type AnimationStyle = {
+    [key: string]: string | number;
+};
+/**
+ * Animation styles to interpolate
+ */
+export declare type AnimationData = AnimationStyle | AnimationStyle[];
+export declare type AnimationEasing = "back" | "backIn" | "backOut" | "backInOut" | "bounce" | "bounceIn" | "bounceOut" | "bounceInOut" | "circle" | "circleIn" | "circleOut" | "circleInOut" | "linear" | "linearIn" | "linearOut" | "linearInOut" | "cubic" | "cubicIn" | "cubicOut" | "cubicInOut" | "elastic" | "elasticIn" | "elasticOut" | "elasticInOut" | "exp" | "expIn" | "expOut" | "expInOut" | "poly" | "polyIn" | "polyOut" | "polyInOut" | "quad" | "quadIn" | "quadOut" | "quadInOut" | "sin" | "sinIn" | "sinOut" | "sinInOut";
+export interface VictoryAnimationProps {
+    children: (style: AnimationStyle, info: AnimationInfo) => React.ReactNode;
+    duration?: number;
+    easing?: AnimationEasing;
+    delay?: number;
+    onEnd?: () => void;
+    data: AnimationData;
+}
+export interface VictoryAnimationState {
+    data: AnimationStyle;
+    animationInfo: AnimationInfo;
+}
+export interface AnimationInfo {
+    progress: number;
+    animating: boolean;
+    terminating?: boolean;
+}
+export interface VictoryAnimation {
+    context: React.ContextType<typeof TimerContext>;
+}
+export declare class VictoryAnimation extends React.Component<VictoryAnimationProps, VictoryAnimationState> {
+    static displayName: string;
+    static propTypes: {
+        children: PropTypes.Requireable<(...args: any[]) => any>;
+        data: PropTypes.Requireable<object>;
+        delay: PropTypes.Requireable<number>;
+        duration: PropTypes.Requireable<number>;
+        easing: PropTypes.Requireable<string>;
+        onEnd: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        data: {};
+        delay: number;
+        duration: number;
+        easing: string;
+    };
+    static contextType: React.Context<{
+        transitionTimer: Timer;
+        animationTimer: Timer;
+    }>;
+    private interpolator;
+    private queue;
+    private ease;
+    private timer;
+    private loopID?;
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    componentWillUnmount(): void;
+    toNewName(ease: any): string;
+    traverseQueue(): void;
+    functionToBeRunEachFrame: (elapsed: any, duration: any) => void;
+    render(): React.ReactNode;
+}