victory-core 36.3.2 → 36.5.0

package/es/victory-theme/victory-theme-definition.d.ts

@@ -0,0 +1,244 @@
+import * as React from "react";
+import { VictoryCommonThemeProps, VictoryDatableProps } from "../index";
+import { CallbackArgs, StringOrNumberOrCallback } from "../types";
+export declare type BlockProps = {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+};
+export declare type PaddingProps = number | BlockProps;
+export declare type OrientationTypes = "top" | "bottom" | "left" | "right";
+export declare type VictoryNumberCallback = (args: CallbackArgs) => number;
+export declare type VictoryPaddingCallback = (args: CallbackArgs) => number | BlockProps;
+export declare type VictoryOrientationCallback = (args: CallbackArgs) => OrientationTypes;
+export declare type NumberOrCallback = number | VictoryNumberCallback;
+export declare type PaddingOrCallback = number | BlockProps | VictoryPaddingCallback;
+export declare type OrientationOrCallback = OrientationTypes | VictoryOrientationCallback;
+export declare type VictoryStyleObject = {
+    [K in keyof React.CSSProperties]: StringOrNumberOrCallback;
+};
+export declare type LabelProps = React.CSSProperties & {
+    angle?: number;
+    verticalAnchor?: VerticalAnchorType;
+};
+export declare type VictoryLabelStyleObject = {
+    [K in keyof LabelProps]: StringOrNumberOrCallback;
+};
+/**
+ * Style interface used in components/themeing
+ */
+export interface VictoryStyleInterface {
+    parent?: VictoryStyleObject;
+    data?: VictoryStyleObject;
+    labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    border?: VictoryStyleObject;
+}
+export declare type TickProps = React.CSSProperties & {
+    size?: number;
+};
+export declare type VictoryTickStyleObject = {
+    [K in keyof TickProps]: StringOrNumberOrCallback;
+};
+export interface VictoryAxisCommonProps {
+    axisComponent?: React.ReactElement;
+    axisLabelComponent?: React.ReactElement;
+    axisValue?: number | string | object | Date;
+    dependentAxis?: boolean;
+    disableInlineStyles?: boolean;
+    gridComponent?: React.ReactElement;
+    invertAxis?: boolean;
+    style?: {
+        parent?: VictoryStyleObject;
+        axis?: VictoryStyleObject;
+        axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        grid?: VictoryStyleObject;
+        ticks?: VictoryTickStyleObject;
+        tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    };
+    tickComponent?: React.ReactElement;
+    tickCount?: number;
+    tickLabelComponent?: React.ReactElement;
+    tickFormat?: any[] | {
+        (tick: any, index: number, ticks: any[]): string | number;
+    };
+    tickValues?: any[];
+}
+export declare type VerticalAnchorType = "start" | "middle" | "end";
+export interface VictoryThemeDefinition {
+    area?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    axis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+    } & VictoryCommonThemeProps;
+    bar?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    boxplot?: {
+        style?: {
+            max?: VictoryStyleObject;
+            maxLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            median?: VictoryStyleObject;
+            medianLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            min?: VictoryStyleObject;
+            minLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            q1?: VictoryStyleObject;
+            q1Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            q3?: VictoryStyleObject;
+            q3Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        boxWidth?: number;
+    } & VictoryCommonThemeProps;
+    candlestick?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        candleColors?: {
+            positive?: string;
+            negative?: string;
+        };
+    } & VictoryCommonThemeProps;
+    chart?: VictoryCommonThemeProps;
+    dependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+        orientation?: OrientationTypes;
+    } & VictoryCommonThemeProps;
+    errorbar?: {
+        borderWidth?: number;
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    group?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    histogram?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    independentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+        offsetX?: number;
+        offsetY?: number;
+        orientation?: OrientationTypes;
+    } & VictoryCommonThemeProps;
+    legend?: {
+        gutter?: number | BlockProps;
+        rowGutter?: number | BlockProps;
+        orientation?: string;
+        titleOrientation?: string;
+        style?: {
+            data?: VictoryStyleObject & {
+                type?: string;
+            };
+            border?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            title?: VictoryLabelStyleObject;
+        };
+        itemsPerRow?: number;
+        x?: number;
+        y?: number;
+        centerTitle?: boolean;
+        borderPadding?: number | BlockProps;
+    } & VictoryCommonThemeProps;
+    line?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    pie?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    polarAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    polarDependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    polarIndependentAxis?: {
+        style?: {
+            axis?: VictoryStyleObject;
+            axisLabel?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            grid?: VictoryStyleObject;
+            ticks?: VictoryTickStyleObject;
+            tickLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps;
+    scatter?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+    stack?: VictoryCommonThemeProps;
+    tooltip?: {
+        style?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+        flyoutStyle?: VictoryStyleObject;
+        cornerRadius?: NumberOrCallback;
+        pointerLength?: NumberOrCallback;
+        flyoutPadding?: PaddingOrCallback;
+        flyoutWidth?: NumberOrCallback;
+        flyoutHeight?: NumberOrCallback;
+        orientation?: OrientationOrCallback;
+        pointerOrientation?: OrientationOrCallback;
+    };
+    voronoi?: {
+        style?: {
+            data?: VictoryStyleObject;
+            labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+            flyout?: VictoryStyleObject;
+        };
+    } & VictoryCommonThemeProps & VictoryDatableProps;
+}

package/es/victory-theme/victory-theme-definition.js

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

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

@@ -0,0 +1,5 @@
+export * from "./victory-theme-definition";
+export declare const VictoryTheme: {
+    grayscale: import("./victory-theme-definition").VictoryThemeDefinition;
+    material: import("./victory-theme-definition").VictoryThemeDefinition;
+};

package/es/victory-theme/victory-theme.js

@@ -1,6 +1,7 @@
-import materialTheme from "./material";
-import grayscaleTheme from "./grayscale";
-export default {
-  material: materialTheme,
-  grayscale: grayscaleTheme
+import { grayscale } from "./grayscale";
+import { material } from "./material";
+export * from "./victory-theme-definition";
+export var VictoryTheme = {
+  grayscale: grayscale,
+  material: material
 };

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

@@ -0,0 +1,59 @@
+import React from "react";
+import PropTypes from "prop-types";
+import TimerContext from "../victory-util/timer-context";
+import Timer from "../victory-util/timer";
+declare type VictoryTransitionChild = React.ReactElement<{
+    polar?: boolean;
+    domain?: number[] | {
+        x: number[];
+        y: number[];
+    };
+    groupComponent?: React.ReactElement;
+}, {
+    new (props: any): React.Component<any, any>;
+    continuous?: boolean;
+}>;
+interface VictoryTransitionProps {
+    animate?: boolean | any;
+    animationWhitelist?: string[];
+    children: VictoryTransitionChild;
+}
+interface VictoryTransitionState {
+    oldProps?: VictoryTransitionProps | null;
+    nextProps?: VictoryTransitionProps;
+    nodesShouldLoad?: boolean;
+    nodesDoneLoad?: boolean;
+    nodesWillExit?: boolean;
+    nodesWillEnter?: boolean;
+    nodesShouldEnter?: boolean;
+    childrenTransitions?: unknown;
+}
+export interface VictoryTransition {
+    context: React.ContextType<typeof TimerContext>;
+}
+export declare class VictoryTransition extends React.Component<VictoryTransitionProps, VictoryTransitionState> {
+    static displayName: string;
+    static propTypes: {
+        animate: PropTypes.Requireable<boolean | object>;
+        animationWhitelist: PropTypes.Requireable<any[]>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static contextType: React.Context<{
+        transitionTimer: Timer;
+        animationTimer: Timer;
+    }>;
+    private continuous;
+    private timer;
+    private transitionProps;
+    constructor(props: any, context: any);
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: VictoryTransitionProps): boolean;
+    componentWillUnmount(): void;
+    private getTransitionState;
+    private getDomainFromChildren;
+    pickProps(): Readonly<VictoryTransitionProps>;
+    private pickDomainProps;
+    getClipWidth(props: any, child: any): any;
+    render(): JSX.Element;
+}
+export {};

package/es/victory-transition/victory-transition.js

@@ -1,42 +1,51 @@
-import _isObject from "lodash/isObject";
 import _pick from "lodash/pick";
 import _isFunction from "lodash/isFunction";
 import _defaults from "lodash/defaults";
 
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
 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 _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 _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 _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";
-import VictoryAnimation from "../victory-animation/victory-animation";
+import { VictoryAnimation } from "../victory-animation/victory-animation";
 import * as Collection from "../victory-util/collection";
 import * as Helpers from "../victory-util/helpers";
 import TimerContext from "../victory-util/timer-context";
 import * as Transitions from "../victory-util/transitions";
 import isEqual from "react-fast-compare";
-
-var VictoryTransition =
-/*#__PURE__*/
-function (_React$Component) {
+export var VictoryTransition = /*#__PURE__*/function (_React$Component) {
   _inherits(VictoryTransition, _React$Component);
 
+  var _super = _createSuper(VictoryTransition);
+
   function VictoryTransition(props, context) {
     var _this;
 
     _classCallCheck(this, VictoryTransition);
 
-    _this = _possibleConstructorReturn(this, (VictoryTransition.__proto__ || Object.getPrototypeOf(VictoryTransition)).call(this, props, context));
+    _this = _super.call(this, props, context);
+    _this.continuous = void 0;
+    _this.timer = void 0;
+    _this.transitionProps = void 0;
     _this.state = {
       nodesShouldLoad: false,
       nodesDoneLoad: false
@@ -44,7 +53,6 @@ function (_React$Component) {
     var child = _this.props.children;
     var polar = child.props.polar;
     _this.continuous = !polar && child.type && child.type.continuous === true;
-    _this.getTransitionState = _this.getTransitionState.bind(_assertThisInitialized(_this));
     _this.timer = _this.context.transitionTimer;
     return _this;
   }
@@ -148,10 +156,12 @@ function (_React$Component) {
   }, {
     key: "pickDomainProps",
     value: function pickDomainProps(props) {
-      var parentState = _isObject(props.animate) && props.animate.parentState;
+      var _props$animate;
+
+      var parentState = (_props$animate = props.animate) === null || _props$animate === void 0 ? void 0 : _props$animate.parentState;
 
       if (parentState && parentState.nodesWillExit) {
-        return this.continous || parentState.continuous ? parentState.nextProps || this.state.nextProps || props : props;
+        return this.continuous || parentState.continuous ? parentState.nextProps || this.state.nextProps || props : props;
       }
 
       return this.continuous && this.state.nodesWillExit ? this.state.nextProps || props : props;
@@ -170,10 +180,11 @@ function (_React$Component) {
   }, {
     key: "render",
     value: function render() {
-      var _this3 = this;
+      var _this$props$animate,
+          _this3 = this;
 
       var props = this.pickProps();
-      var getTransitionProps = _isObject(this.props.animate) && this.props.animate.getTransitions ? this.props.animate.getTransitions : Transitions.getTransitionPropsFactory(props, this.state, function (newState) {
+      var getTransitionProps = (_this$props$animate = this.props.animate) !== null && _this$props$animate !== void 0 && _this$props$animate.getTransitions ? this.props.animate.getTransitions : Transitions.getTransitionPropsFactory(props, this.state, function (newState) {
         return _this3.setState(newState);
       });
       var child = React.Children.toArray(props.children)[0];
@@ -193,21 +204,21 @@ function (_React$Component) {
       var animationWhitelist = props.animationWhitelist || [];
       var whitelist = animationWhitelist.concat(["clipWidth"]);
       var propsToAnimate = whitelist.length ? _pick(combinedProps, whitelist) : combinedProps;
-      return React.createElement(VictoryAnimation, _extends({}, combinedProps.animate, {
+      return /*#__PURE__*/React.createElement(VictoryAnimation, _extends({}, combinedProps.animate, {
         data: propsToAnimate
       }), function (newProps) {
         if (child.props.groupComponent) {
-          var groupComponent = _this3.continuous ? React.cloneElement(child.props.groupComponent, {
+          var groupComponent = _this3.continuous ? /*#__PURE__*/React.cloneElement(child.props.groupComponent, {
             clipWidth: newProps.clipWidth || 0
           }) : child.props.groupComponent;
-          return React.cloneElement(child, _defaults({
+          return /*#__PURE__*/React.cloneElement(child, _defaults({
             animate: null,
             animating: true,
             groupComponent: groupComponent
           }, newProps, combinedProps));
         }
 
-        return React.cloneElement(child, _defaults({
+        return /*#__PURE__*/React.cloneElement(child, _defaults({
           animate: null,
           animating: true
         }, newProps, combinedProps));
@@ -217,27 +228,10 @@ function (_React$Component) {
 
   return VictoryTransition;
 }(React.Component);
-
-Object.defineProperty(VictoryTransition, "displayName", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: "VictoryTransition"
-});
-Object.defineProperty(VictoryTransition, "propTypes", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: {
-    animate: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
-    animationWhitelist: PropTypes.array,
-    children: PropTypes.node
-  }
-});
-Object.defineProperty(VictoryTransition, "contextType", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: TimerContext
-});
-export { VictoryTransition as default };
+VictoryTransition.displayName = "VictoryTransition";
+VictoryTransition.propTypes = {
+  animate: PropTypes.oneOfType([PropTypes.bool, PropTypes.object]),
+  animationWhitelist: PropTypes.array,
+  children: PropTypes.node
+};
+VictoryTransition.contextType = TimerContext;