victory-box-plot 36.5.2 → 36.6.1

package/es/helper-methods.d.ts

@@ -0,0 +1,4 @@
+export declare const getData: (props: any) => any;
+export declare const getDomain: (props: any, axis: any) => any;
+export declare const getBaseProps: (props: any, fallbackProps: any) => any;
+//# sourceMappingURL=helper-methods.d.ts.map

package/es/index.d.ts

@@ -1,77 +1,2 @@
-import * as React from "react";
-import {
-  EventPropTypeInterface,
-  DomainPropType,
-  DomainPaddingPropType,
-  OrientationTypes,
-  StringOrNumberOrCallback,
-  VictoryDatableProps,
-  VictoryCommonProps,
-  VictoryStyleObject,
-  VictoryLabelStyleObject,
-} from "victory-core";
-
-export type VictoryBoxPlotLabelType =
-  | boolean
-  | (string | number)[]
-  | Function
-  | { (data: any): string | null };
-
-export interface VictoryBoxPlotStyleInterface {
-  parent?: VictoryStyleObject;
-  max?: VictoryStyleObject;
-  maxLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  min?: VictoryStyleObject;
-  minLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  median?: VictoryStyleObject;
-  medianLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  q1?: VictoryStyleObject;
-  q1Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  q3?: VictoryStyleObject;
-  q3Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-}
-
-export interface VictoryBoxPlotLabelOrientationInterface {
-  max?: OrientationTypes;
-  min?: OrientationTypes;
-  median?: OrientationTypes;
-  q1?: OrientationTypes;
-  q3?: OrientationTypes;
-}
-
-export interface VictoryBoxPlotProps
-  extends VictoryCommonProps,
-    VictoryDatableProps {
-  boxWidth?: number;
-  domain?: DomainPropType;
-  domainPadding?: DomainPaddingPropType;
-  events?: EventPropTypeInterface<string, StringOrNumberOrCallback>[];
-  eventKey?: StringOrNumberOrCallback;
-  horizontal?: boolean;
-  labelOrientation?: OrientationTypes | VictoryBoxPlotLabelOrientationInterface;
-  labels?: boolean;
-  max?: StringOrNumberOrCallback | string[];
-  maxComponent?: React.ReactElement;
-  maxLabelComponent?: React.ReactElement;
-  maxLabels?: VictoryBoxPlotLabelType;
-  median?: StringOrNumberOrCallback | string[];
-  medianComponent?: React.ReactElement;
-  medianLabelComponent?: React.ReactElement;
-  medianLabels?: VictoryBoxPlotLabelType;
-  min?: StringOrNumberOrCallback | string[];
-  minComponent?: React.ReactElement;
-  minLabelComponent?: React.ReactElement;
-  minLabels?: VictoryBoxPlotLabelType;
-  q1?: StringOrNumberOrCallback | string[];
-  q1Component?: React.ReactElement;
-  q1LabelComponent?: React.ReactElement;
-  q1Labels?: VictoryBoxPlotLabelType;
-  q3?: StringOrNumberOrCallback | string[];
-  q3Component?: React.ReactElement;
-  q3LabelComponent?: React.ReactElement;
-  q3Labels?: VictoryBoxPlotLabelType;
-  style?: VictoryBoxPlotStyleInterface;
-  whiskerWidth?: number;
-}
-
-export class VictoryBoxPlot extends React.Component<VictoryBoxPlotProps, any> {}
+export * from "./victory-box-plot";
+//# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -1,2 +1,2 @@
-export { default as VictoryBoxPlot } from "./victory-box-plot";
+export * from "./victory-box-plot";
 //# sourceMappingURL=index.js.map

package/es/victory-box-plot.d.ts

@@ -0,0 +1,265 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { EventPropTypeInterface, DomainPropType, DomainPaddingPropType, OrientationTypes, StringOrNumberOrCallback, VictoryDatableProps, VictoryCommonProps, VictoryStyleObject, VictoryLabelStyleObject, EventsMixinClass } from "victory-core";
+export declare type VictoryBoxPlotLabelType = boolean | (string | number)[] | {
+    (): any;
+} | {
+    (data: any): string | null;
+};
+export interface VictoryBoxPlotStyleInterface {
+    parent?: VictoryStyleObject;
+    max?: VictoryStyleObject;
+    maxLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    min?: VictoryStyleObject;
+    minLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    median?: VictoryStyleObject;
+    medianLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    q1?: VictoryStyleObject;
+    q1Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+    q3?: VictoryStyleObject;
+    q3Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
+}
+export interface VictoryBoxPlotLabelOrientationInterface {
+    max?: OrientationTypes;
+    min?: OrientationTypes;
+    median?: OrientationTypes;
+    q1?: OrientationTypes;
+    q3?: OrientationTypes;
+}
+export interface VictoryBoxPlotProps extends VictoryCommonProps, VictoryDatableProps {
+    boxWidth?: number;
+    datum?: any;
+    domain?: DomainPropType;
+    domainPadding?: DomainPaddingPropType;
+    events?: EventPropTypeInterface<string, StringOrNumberOrCallback>[];
+    eventKey?: StringOrNumberOrCallback;
+    horizontal?: boolean;
+    labelOrientation?: OrientationTypes | VictoryBoxPlotLabelOrientationInterface;
+    labels?: boolean;
+    max?: StringOrNumberOrCallback | string[];
+    maxComponent?: React.ReactElement;
+    maxLabelComponent?: React.ReactElement;
+    maxLabels?: VictoryBoxPlotLabelType;
+    median?: StringOrNumberOrCallback | string[];
+    medianComponent?: React.ReactElement;
+    medianLabelComponent?: React.ReactElement;
+    medianLabels?: VictoryBoxPlotLabelType;
+    min?: StringOrNumberOrCallback | string[];
+    minComponent?: React.ReactElement;
+    minLabelComponent?: React.ReactElement;
+    minLabels?: VictoryBoxPlotLabelType;
+    q1?: StringOrNumberOrCallback | string[];
+    q1Component?: React.ReactElement;
+    q1LabelComponent?: React.ReactElement;
+    q1Labels?: VictoryBoxPlotLabelType;
+    q3?: StringOrNumberOrCallback | string[];
+    q3Component?: React.ReactElement;
+    q3LabelComponent?: React.ReactElement;
+    q3Labels?: VictoryBoxPlotLabelType;
+    style?: VictoryBoxPlotStyleInterface;
+    text?: StringOrNumberOrCallback | string[];
+    whiskerWidth?: number;
+}
+interface VictoryBoxPlotBase extends EventsMixinClass<VictoryBoxPlotProps> {
+}
+declare class VictoryBoxPlotBase extends React.Component<VictoryBoxPlotProps> {
+    static animationWhitelist: Array<keyof VictoryBoxPlotProps>;
+    static displayName: string;
+    static role: string;
+    static defaultTransitions: import("victory-core").AnimatePropTypeInterface;
+    static propTypes: {
+        boxWidth: PropTypes.Requireable<number>;
+        events: PropTypes.Requireable<(PropTypes.InferProps<{
+            target: PropTypes.Requireable<string>;
+            eventKey: PropTypes.Requireable<string | number | any[]>;
+            eventHandlers: PropTypes.Requireable<object>;
+        }> | null | undefined)[]>;
+        horizontal: PropTypes.Requireable<boolean>;
+        labelOrientation: PropTypes.Requireable<string | PropTypes.InferProps<{
+            q1: PropTypes.Requireable<string>;
+            q3: PropTypes.Requireable<string>;
+            min: PropTypes.Requireable<string>;
+            max: PropTypes.Requireable<string>;
+            median: PropTypes.Requireable<string>;
+        }>>;
+        labels: PropTypes.Requireable<boolean>;
+        max: PropTypes.Requireable<string | number | ((...args: any[]) => any) | (string | null | undefined)[]>;
+        maxComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        maxLabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        maxLabels: PropTypes.Requireable<boolean | any[] | ((...args: any[]) => any)>;
+        median: PropTypes.Requireable<string | number | ((...args: any[]) => any) | (string | null | undefined)[]>;
+        medianComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        medianLabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        medianLabels: PropTypes.Requireable<boolean | any[] | ((...args: any[]) => any)>;
+        min: PropTypes.Requireable<string | number | ((...args: any[]) => any) | (string | null | undefined)[]>;
+        minComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        minLabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        minLabels: PropTypes.Requireable<boolean | any[] | ((...args: any[]) => any)>;
+        q1: PropTypes.Requireable<string | number | ((...args: any[]) => any) | (string | null | undefined)[]>;
+        q1Component: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        q1LabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        q1Labels: PropTypes.Requireable<boolean | any[] | ((...args: any[]) => any)>;
+        q3: PropTypes.Requireable<string | number | ((...args: any[]) => any) | (string | null | undefined)[]>;
+        q3Component: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        q3LabelComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        q3Labels: PropTypes.Requireable<boolean | any[] | ((...args: any[]) => any)>;
+        style: PropTypes.Requireable<PropTypes.InferProps<{
+            boxes: PropTypes.Requireable<object>;
+            labels: PropTypes.Requireable<object>;
+            parent: PropTypes.Requireable<object>;
+            max: PropTypes.Requireable<object>;
+            maxLabels: PropTypes.Requireable<object>;
+            median: PropTypes.Requireable<object>;
+            medianLabels: PropTypes.Requireable<object>;
+            min: PropTypes.Requireable<object>;
+            minLabels: PropTypes.Requireable<object>;
+            q1: PropTypes.Requireable<object>;
+            q1Labels: PropTypes.Requireable<object>;
+            q3: PropTypes.Requireable<object>;
+            q3Labels: PropTypes.Requireable<object>;
+            whiskers: PropTypes.Requireable<object>;
+        }>>;
+        whiskerWidth: PropTypes.Requireable<number>;
+        categories?: React.Validator<import("victory-core").CategoryPropType | null | undefined> | undefined;
+        data?: React.Validator<readonly any[] | null | undefined> | undefined;
+        dataComponent?: React.Validator<React.ReactElement<any, string | React.JSXElementConstructor<any>> | null | undefined> | undefined;
+        domain?: React.Validator<import("victory-core").ForAxes<import("victory-core").DomainTuple> | null | undefined> | undefined;
+        domainPadding?: React.Validator<import("victory-core").ForAxes<import("victory-core").PaddingType> | null | undefined> | undefined;
+        samples?: React.Validator<number | null | undefined> | undefined;
+        sortKey?: React.Validator<import("victory-core").DataGetterPropType | null | undefined> | undefined;
+        sortOrder?: React.Validator<import("victory-core").SortOrderPropType | null | undefined> | undefined;
+        x?: React.Validator<import("victory-core").DataGetterPropType | null | undefined> | undefined;
+        y?: React.Validator<import("victory-core").DataGetterPropType | null | undefined> | undefined;
+        y0?: React.Validator<import("victory-core").DataGetterPropType | null | undefined> | undefined;
+        theme?: React.Validator<import("victory-core").VictoryThemeDefinition | null | undefined> | undefined;
+        animate?: React.Validator<boolean | import("victory-core").AnimatePropTypeInterface | null | undefined> | undefined;
+        colorScale?: React.Validator<import("victory-core").ColorScalePropType | null | undefined> | undefined;
+        containerComponent?: React.Validator<React.ReactElement<any, string | React.JSXElementConstructor<any>> | null | undefined> | undefined;
+        externalEventMutations?: React.Validator<import("victory-core").EventCallbackInterface<string | string[], import("victory-core").StringOrNumberOrList>[] | null | undefined> | undefined;
+        groupComponent?: React.Validator<React.ReactElement<any, string | React.JSXElementConstructor<any>> | null | undefined> | undefined;
+        height?: React.Validator<number | null | undefined> | undefined;
+        maxDomain?: React.Validator<number | {
+            x?: number | undefined;
+            y?: number | undefined;
+        } | null | undefined> | undefined;
+        minDomain?: React.Validator<number | {
+            x?: number | undefined;
+            y?: number | undefined;
+        } | null | undefined> | undefined;
+        name?: React.Validator<string | null | undefined> | undefined;
+        origin?: React.Validator<import("victory-core").OriginType | null | undefined> | undefined;
+        padding?: React.Validator<import("victory-core").PaddingProps | null | undefined> | undefined;
+        polar?: React.Validator<boolean | null | undefined> | undefined;
+        range?: React.Validator<import("victory-core").ForAxes<import("victory-core").RangeTuple> | null | undefined> | undefined;
+        scale?: React.Validator<import("victory-core").D3Scale<any> | import("victory-core").ScaleName | {
+            x?: import("victory-core").D3Scale<any> | import("victory-core").ScaleName | undefined;
+            y?: import("victory-core").D3Scale<any> | import("victory-core").ScaleName | undefined;
+        } | null | undefined> | undefined;
+        sharedEvents?: React.Validator<{
+            events: any[];
+            getEventState: Function;
+        } | null | undefined> | undefined;
+        singleQuadrantDomainPadding?: React.Validator<boolean | {
+            x?: boolean | undefined;
+            y?: boolean | undefined;
+        } | null | undefined> | undefined;
+        standalone?: React.Validator<boolean | null | undefined> | undefined;
+        width?: React.Validator<number | null | undefined> | undefined;
+    };
+    static defaultProps: {
+        containerComponent: JSX.Element;
+        data: {
+            x: number;
+            min: number;
+            q1: number;
+            median: number;
+            q3: number;
+            max: number;
+        }[];
+        dataComponent: JSX.Element;
+        groupComponent: JSX.Element;
+        maxComponent: JSX.Element;
+        maxLabelComponent: JSX.Element;
+        medianComponent: JSX.Element;
+        medianLabelComponent: JSX.Element;
+        minComponent: JSX.Element;
+        minLabelComponent: JSX.Element;
+        q1Component: JSX.Element;
+        q1LabelComponent: JSX.Element;
+        q3Component: JSX.Element;
+        q3LabelComponent: JSX.Element;
+        samples: number;
+        sortKey: string;
+        sortOrder: string;
+        standalone: boolean;
+        theme: import("victory-core").VictoryThemeDefinition;
+    };
+    static getDomain: (props: any, axis: any) => any;
+    static getData: (props: any) => any;
+    static getBaseProps: (props: any) => any;
+    static expectedComponents: Array<keyof VictoryBoxPlotProps>;
+    renderBoxPlot(props: any): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    shouldAnimate(): boolean;
+    shouldRenderDatum(datum: any): boolean;
+    render(): React.ReactElement;
+}
+export declare const VictoryBoxPlot: {
+    new (props: import("victory-core").EventMixinCommonProps): {
+        state: {};
+        getEventState: (eventKey: string | number, namespace: string, childType?: string | undefined) => any;
+        getScopedEvents: (events: any, namespace: any, childType: any, baseProps: any) => {};
+        getEvents: (p: any, target: any, eventKey: any) => any;
+        externalMutations: {} | undefined;
+        calculatedState: {};
+        globalEvents: {};
+        prevGlobalEventKeys: string[];
+        boundGlobalEvents: {};
+        shouldComponentUpdate(nextProps: import("victory-core").EventMixinCommonProps): boolean;
+        componentDidMount(): void;
+        componentDidUpdate(prevProps: any): void;
+        componentWillUnmount(): void;
+        addGlobalListener(key: any): void;
+        removeGlobalListener(key: any): void;
+        getStateChanges(props: any): {};
+        applyExternalMutations(props: any, externalMutations: any): void;
+        getCalculatedValues(props: any): import("victory-core").EventMixinCalculatedValues;
+        getExternalMutations(props: import("victory-core").EventMixinCommonProps): {} | undefined;
+        cacheValues(obj: any): void;
+        getBaseProps(props: any, getSharedEventState: any): Record<string, object>;
+        getAllEvents(props: any): any;
+        getComponentProps(component: any, type: any, index: any): any;
+        renderContainer(component: any, children: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+        animateComponent(props: import("victory-core").EventMixinCommonProps, defaultAnimationWhitelist: string[]): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+        renderContinuousData(props: import("victory-core").EventMixinCommonProps): React.DetailedReactHTMLElement<any, HTMLElement>;
+        renderData(props: any, shouldRenderDatum?: ((datum: any) => boolean) | undefined): React.DetailedReactHTMLElement<any, HTMLElement>;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("victory-core").EventMixinCommonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): React.ReactNode;
+        readonly props: Readonly<import("victory-core").EventMixinCommonProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("victory-core").EventMixinCommonProps>, prevState: Readonly<{}>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("victory-core").EventMixinCommonProps>, nextState: Readonly<{}>, nextContext: any): void;
+        componentEvents: import("victory-core/lib/victory-util/events").ComponentEvent[];
+        getSharedEventState: (key: string, value: string) => unknown;
+        baseProps: Record<string, object>;
+        dataKeys: string[];
+        hasEvents: unknown;
+        events: unknown;
+    };
+    getBaseProps?(props: import("victory-core").EventMixinCommonProps): Record<string, object>;
+    role?: string | undefined;
+    expectedComponents?: string[] | undefined;
+    getChildren?: ((props: import("victory-core").EventMixinCommonProps, childComponents?: React.ReactNode[] | undefined, calculatedProps?: import("victory-core").EventMixinCommonProps | undefined) => void) | undefined;
+    animationWhitelist?: string[] | undefined;
+} & typeof VictoryBoxPlotBase;
+export {};
+//# sourceMappingURL=victory-box-plot.d.ts.map

package/es/victory-box-plot.js

@@ -95,18 +95,18 @@ var options = {
   }]
 };
 
-var VictoryBoxPlot = /*#__PURE__*/function (_React$Component) {
-  _inherits(VictoryBoxPlot, _React$Component);
+var VictoryBoxPlotBase = /*#__PURE__*/function (_React$Component) {
+  _inherits(VictoryBoxPlotBase, _React$Component);
 
-  var _super = _createSuper(VictoryBoxPlot);
+  var _super = _createSuper(VictoryBoxPlotBase);
 
-  function VictoryBoxPlot() {
-    _classCallCheck(this, VictoryBoxPlot);
+  function VictoryBoxPlotBase() {
+    _classCallCheck(this, VictoryBoxPlotBase);
 
     return _super.apply(this, arguments);
   }
 
-  _createClass(VictoryBoxPlot, [{
+  _createClass(VictoryBoxPlotBase, [{
     key: "renderBoxPlot",
     value: function renderBoxPlot(props) {
       var _this = this;
@@ -128,18 +128,18 @@ var VictoryBoxPlot = /*#__PURE__*/function (_React$Component) {
       }));
 
       var labelComponents = _flatten(types.map(function (type) {
-        var components = _this.dataKeys.map(function (key, index) {
+        var components = _this.dataKeys.reduce(function (validComponents, _key, index) {
           var name = "".concat(type, "Labels");
           var baseComponent = props["".concat(type, "LabelComponent")];
 
           var labelProps = _this.getComponentProps(baseComponent, name, index);
 
           if (labelProps.text !== undefined && labelProps.text !== null) {
-            return /*#__PURE__*/React.cloneElement(baseComponent, labelProps);
+            validComponents.push( /*#__PURE__*/React.cloneElement(baseComponent, labelProps));
           }
 
-          return undefined;
-        });
+          return validComponents;
+        }, []);
 
         return components.filter(Boolean);
       }));
@@ -178,14 +178,14 @@ var VictoryBoxPlot = /*#__PURE__*/function (_React$Component) {
     }
   }]);
 
-  return VictoryBoxPlot;
+  return VictoryBoxPlotBase;
 }(React.Component);
 
-VictoryBoxPlot.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
-VictoryBoxPlot.displayName = "VictoryBoxPlot";
-VictoryBoxPlot.role = "boxplot";
-VictoryBoxPlot.defaultTransitions = DefaultTransitions.discreteTransitions();
-VictoryBoxPlot.propTypes = _objectSpread(_objectSpread(_objectSpread({}, CommonProps.baseProps), CommonProps.dataProps), {}, {
+VictoryBoxPlotBase.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
+VictoryBoxPlotBase.displayName = "VictoryBoxPlot";
+VictoryBoxPlotBase.role = "boxplot";
+VictoryBoxPlotBase.defaultTransitions = DefaultTransitions.discreteTransitions();
+VictoryBoxPlotBase.propTypes = _objectSpread(_objectSpread(_objectSpread({}, CommonProps.baseProps), CommonProps.dataProps), {}, {
   boxWidth: PropTypes.number,
   events: PropTypes.arrayOf(PropTypes.shape({
     target: PropTypes.oneOf(["max", "maxLabels", "median", "medianLabels", "min", "minLabels", "q1", "q1Labels", "q3", "q3Labels", "parent"]),
@@ -239,7 +239,7 @@ VictoryBoxPlot.propTypes = _objectSpread(_objectSpread(_objectSpread({}, CommonP
   }),
   whiskerWidth: PropTypes.number
 });
-VictoryBoxPlot.defaultProps = {
+VictoryBoxPlotBase.defaultProps = {
   containerComponent: /*#__PURE__*/React.createElement(VictoryContainer, null),
   data: defaultData,
   dataComponent: /*#__PURE__*/React.createElement(Box, null),
@@ -262,13 +262,13 @@ VictoryBoxPlot.defaultProps = {
   standalone: true,
   theme: VictoryTheme.grayscale
 };
-VictoryBoxPlot.getDomain = getDomain;
-VictoryBoxPlot.getData = getData;
+VictoryBoxPlotBase.getDomain = getDomain;
+VictoryBoxPlotBase.getData = getData;
 
-VictoryBoxPlot.getBaseProps = function (props) {
+VictoryBoxPlotBase.getBaseProps = function (props) {
   return getBaseProps(props, fallbackProps);
 };
 
-VictoryBoxPlot.expectedComponents = ["maxComponent", "maxLabelComponent", "medianComponent", "medianLabelComponent", "minComponent", "minLabelComponent", "q1Component", "q1LabelComponent", "q3Component", "q3LabelComponent", "groupComponent", "containerComponent"];
-export default addEvents(VictoryBoxPlot, options);
+VictoryBoxPlotBase.expectedComponents = ["maxComponent", "maxLabelComponent", "medianComponent", "medianLabelComponent", "minComponent", "minLabelComponent", "q1Component", "q1LabelComponent", "q3Component", "q3LabelComponent", "groupComponent", "containerComponent"];
+export var VictoryBoxPlot = addEvents(VictoryBoxPlotBase, options);
 //# sourceMappingURL=victory-box-plot.js.map

package/lib/helper-methods.d.ts

@@ -0,0 +1,4 @@
+export declare const getData: (props: any) => any;
+export declare const getDomain: (props: any, axis: any) => any;
+export declare const getBaseProps: (props: any, fallbackProps: any) => any;
+//# sourceMappingURL=helper-methods.d.ts.map

package/lib/index.d.ts

@@ -1,77 +1,2 @@
-import * as React from "react";
-import {
-  EventPropTypeInterface,
-  DomainPropType,
-  DomainPaddingPropType,
-  OrientationTypes,
-  StringOrNumberOrCallback,
-  VictoryDatableProps,
-  VictoryCommonProps,
-  VictoryStyleObject,
-  VictoryLabelStyleObject,
-} from "victory-core";
-
-export type VictoryBoxPlotLabelType =
-  | boolean
-  | (string | number)[]
-  | Function
-  | { (data: any): string | null };
-
-export interface VictoryBoxPlotStyleInterface {
-  parent?: VictoryStyleObject;
-  max?: VictoryStyleObject;
-  maxLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  min?: VictoryStyleObject;
-  minLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  median?: VictoryStyleObject;
-  medianLabels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  q1?: VictoryStyleObject;
-  q1Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-  q3?: VictoryStyleObject;
-  q3Labels?: VictoryLabelStyleObject | VictoryLabelStyleObject[];
-}
-
-export interface VictoryBoxPlotLabelOrientationInterface {
-  max?: OrientationTypes;
-  min?: OrientationTypes;
-  median?: OrientationTypes;
-  q1?: OrientationTypes;
-  q3?: OrientationTypes;
-}
-
-export interface VictoryBoxPlotProps
-  extends VictoryCommonProps,
-    VictoryDatableProps {
-  boxWidth?: number;
-  domain?: DomainPropType;
-  domainPadding?: DomainPaddingPropType;
-  events?: EventPropTypeInterface<string, StringOrNumberOrCallback>[];
-  eventKey?: StringOrNumberOrCallback;
-  horizontal?: boolean;
-  labelOrientation?: OrientationTypes | VictoryBoxPlotLabelOrientationInterface;
-  labels?: boolean;
-  max?: StringOrNumberOrCallback | string[];
-  maxComponent?: React.ReactElement;
-  maxLabelComponent?: React.ReactElement;
-  maxLabels?: VictoryBoxPlotLabelType;
-  median?: StringOrNumberOrCallback | string[];
-  medianComponent?: React.ReactElement;
-  medianLabelComponent?: React.ReactElement;
-  medianLabels?: VictoryBoxPlotLabelType;
-  min?: StringOrNumberOrCallback | string[];
-  minComponent?: React.ReactElement;
-  minLabelComponent?: React.ReactElement;
-  minLabels?: VictoryBoxPlotLabelType;
-  q1?: StringOrNumberOrCallback | string[];
-  q1Component?: React.ReactElement;
-  q1LabelComponent?: React.ReactElement;
-  q1Labels?: VictoryBoxPlotLabelType;
-  q3?: StringOrNumberOrCallback | string[];
-  q3Component?: React.ReactElement;
-  q3LabelComponent?: React.ReactElement;
-  q3Labels?: VictoryBoxPlotLabelType;
-  style?: VictoryBoxPlotStyleInterface;
-  whiskerWidth?: number;
-}
-
-export class VictoryBoxPlot extends React.Component<VictoryBoxPlotProps, any> {}
+export * from "./victory-box-plot";
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -3,14 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "VictoryBoxPlot", {
-  enumerable: true,
-  get: function () {
-    return _victoryBoxPlot.default;
-  }
-});
 
-var _victoryBoxPlot = _interopRequireDefault(require("./victory-box-plot"));
+var _victoryBoxPlot = require("./victory-box-plot");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+Object.keys(_victoryBoxPlot).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _victoryBoxPlot[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _victoryBoxPlot[key];
+    }
+  });
+});
 //# sourceMappingURL=index.js.map