victory-box-plot 36.5.3 → 36.6.2

package/lib/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/lib/victory-box-plot.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.VictoryBoxPlot = void 0;
 
 var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
 
@@ -109,18 +109,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;
@@ -140,18 +140,18 @@ var VictoryBoxPlot = /*#__PURE__*/function (_React$Component) {
         }, []);
       }));
       var labelComponents = (0, _flatten2.default)(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.default.cloneElement(baseComponent, labelProps);
+            validComponents.push( /*#__PURE__*/_react.default.cloneElement(baseComponent, labelProps));
           }
 
-          return undefined;
-        });
+          return validComponents;
+        }, []);
 
         return components.filter(Boolean);
       }));
@@ -190,14 +190,14 @@ var VictoryBoxPlot = /*#__PURE__*/function (_React$Component) {
     }
   }]);
 
-  return VictoryBoxPlot;
+  return VictoryBoxPlotBase;
 }(_react.default.Component);
 
-VictoryBoxPlot.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
-VictoryBoxPlot.displayName = "VictoryBoxPlot";
-VictoryBoxPlot.role = "boxplot";
-VictoryBoxPlot.defaultTransitions = _victoryCore.DefaultTransitions.discreteTransitions();
-VictoryBoxPlot.propTypes = _objectSpread(_objectSpread(_objectSpread({}, _victoryCore.CommonProps.baseProps), _victoryCore.CommonProps.dataProps), {}, {
+VictoryBoxPlotBase.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
+VictoryBoxPlotBase.displayName = "VictoryBoxPlot";
+VictoryBoxPlotBase.role = "boxplot";
+VictoryBoxPlotBase.defaultTransitions = _victoryCore.DefaultTransitions.discreteTransitions();
+VictoryBoxPlotBase.propTypes = _objectSpread(_objectSpread(_objectSpread({}, _victoryCore.CommonProps.baseProps), _victoryCore.CommonProps.dataProps), {}, {
   boxWidth: _propTypes.default.number,
   events: _propTypes.default.arrayOf(_propTypes.default.shape({
     target: _propTypes.default.oneOf(["max", "maxLabels", "median", "medianLabels", "min", "minLabels", "q1", "q1Labels", "q3", "q3Labels", "parent"]),
@@ -251,7 +251,7 @@ VictoryBoxPlot.propTypes = _objectSpread(_objectSpread(_objectSpread({}, _victor
   }),
   whiskerWidth: _propTypes.default.number
 });
-VictoryBoxPlot.defaultProps = {
+VictoryBoxPlotBase.defaultProps = {
   containerComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.VictoryContainer, null),
   data: defaultData,
   dataComponent: /*#__PURE__*/_react.default.createElement(_victoryCore.Box, null),
@@ -274,16 +274,14 @@ VictoryBoxPlot.defaultProps = {
   standalone: true,
   theme: _victoryCore.VictoryTheme.grayscale
 };
-VictoryBoxPlot.getDomain = _helperMethods.getDomain;
-VictoryBoxPlot.getData = _helperMethods.getData;
+VictoryBoxPlotBase.getDomain = _helperMethods.getDomain;
+VictoryBoxPlotBase.getData = _helperMethods.getData;
 
-VictoryBoxPlot.getBaseProps = function (props) {
+VictoryBoxPlotBase.getBaseProps = function (props) {
   return (0, _helperMethods.getBaseProps)(props, fallbackProps);
 };
 
-VictoryBoxPlot.expectedComponents = ["maxComponent", "maxLabelComponent", "medianComponent", "medianLabelComponent", "minComponent", "minLabelComponent", "q1Component", "q1LabelComponent", "q3Component", "q3LabelComponent", "groupComponent", "containerComponent"];
-
-var _default = (0, _victoryCore.addEvents)(VictoryBoxPlot, options);
-
-exports.default = _default;
+VictoryBoxPlotBase.expectedComponents = ["maxComponent", "maxLabelComponent", "medianComponent", "medianLabelComponent", "minComponent", "minLabelComponent", "q1Component", "q1LabelComponent", "q3Component", "q3LabelComponent", "groupComponent", "containerComponent"];
+var VictoryBoxPlot = (0, _victoryCore.addEvents)(VictoryBoxPlotBase, options);
+exports.VictoryBoxPlot = VictoryBoxPlot;
 //# sourceMappingURL=victory-box-plot.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-box-plot",
-  "version": "36.5.3",
+  "version": "36.6.2",
   "description": "Box Plot Component for Victory",
   "keywords": [
     "data visualization",
@@ -13,6 +13,7 @@
     "url": "https://github.com/formidablelabs/victory.git"
   },
   "homepage": "https://formidable.com/open-source/victory",
+  "sideEffects": false,
   "main": "lib/index.js",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",
@@ -21,15 +22,266 @@
   "dependencies": {
     "lodash": "^4.17.19",
     "prop-types": "^15.8.1",
-    "victory-core": "^36.5.3",
-    "victory-vendor": "^36.5.1"
+    "victory-core": "^36.6.2",
+    "victory-vendor": "^36.6.2"
   },
   "peerDependencies": {
     "react": ">=16.6.0"
   },
-  "scripts": {
-    "version": "yarn run nps build-libs && nps build-dists"
+  "devDependencies": {
+    "victory-box-plot": "*",
+    "victory-chart": "^36.6.2"
   },
-  "sideEffects": false,
-  "gitHead": "55338af3c57eacca5956e53c08a58e47ba41d01e"
-}
+  "wireit": {
+    "###            THESE WIREIT CONFIGS ARE GENERATED        ####": {},
+    "###            DO NOT MODIFY THESE MANUALLY              ####": {},
+    "build": {
+      "dependencies": [
+        "build:lib",
+        "build:dist",
+        "types:create"
+      ]
+    },
+    "build:lib": {
+      "dependencies": [
+        "build:lib:esm",
+        "build:lib:cjs"
+      ]
+    },
+    "build:lib:esm": {
+      "command": "nps build:lib:esm",
+      "files": [
+        "src/**",
+        "!src/**/*.test.*",
+        "../../.babelrc.build.js"
+      ],
+      "output": [
+        "es/**/*.js",
+        "es/**/*.js.map"
+      ],
+      "dependencies": [
+        "../victory-core:build:lib:esm",
+        "../victory-vendor:build:lib:esm"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "build:lib:cjs": {
+      "command": "nps build:lib:cjs",
+      "files": [
+        "src/**",
+        "!src/**/*.test.*",
+        "../../.babelrc.build.js"
+      ],
+      "output": [
+        "lib/**/*.js",
+        "lib/**/*.js.map"
+      ],
+      "dependencies": [
+        "../victory-core:build:lib:cjs",
+        "../victory-vendor:build:lib:cjs"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "build:dist": {
+      "dependencies": [
+        "build:dist:dev",
+        "build:dist:min"
+      ]
+    },
+    "build:dist:dev": {
+      "command": "nps build:dist:dev",
+      "files": [
+        "src/**",
+        "!src/**/*.test.*",
+        "../../.babelrc.build.js",
+        "../../config/webpack.config.js",
+        "../../config/webpack.config.dev.js"
+      ],
+      "output": [
+        "dist/victory*.js",
+        "!dist/victory*.min.js*"
+      ],
+      "dependencies": [
+        "../victory-core:build:lib:esm",
+        "../victory-vendor:build:lib:esm"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "build:dist:min": {
+      "command": "nps build:dist:min",
+      "files": [
+        "src/**",
+        "!src/**/*.test.*",
+        "../../.babelrc.build.js",
+        "../../config/webpack.config.js"
+      ],
+      "output": [
+        "dist/victory*.min.js*"
+      ],
+      "dependencies": [
+        "../victory-core:build:lib:esm",
+        "../victory-vendor:build:lib:esm"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "check": {
+      "dependencies": [
+        "types:check",
+        "jest",
+        "format",
+        "lint"
+      ]
+    },
+    "types:check": {
+      "command": "nps types:pkg:check",
+      "files": [
+        "src/**/*.{ts,tsx}",
+        "../../tsconfig.base.json",
+        "tsconfig.json"
+      ],
+      "dependencies": [
+        "types:create",
+        "../victory-core:types:create",
+        "../victory-vendor:types:create",
+        "../victory-chart:types:create",
+        "../victory-voronoi:types:create"
+      ],
+      "output": [],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "types:create": {
+      "command": "nps types:pkg:create",
+      "files": [
+        "src/**",
+        "!src/**/*.test.*",
+        "../../tsconfig.base.json",
+        "tsconfig.build.json"
+      ],
+      "output": [
+        "es/**/*.d.ts",
+        "es/**/*.d.ts.map",
+        "lib/**/*.d.ts",
+        "lib/**/*.d.ts.map"
+      ],
+      "dependencies": [
+        "../victory-core:types:create",
+        "../victory-vendor:types:create"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "format": {
+      "command": "nps format:pkg",
+      "files": [
+        "src/**",
+        "*.json",
+        "../../.prettierignore",
+        "../../.prettierrc.json"
+      ],
+      "output": [],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "format:fix": {
+      "command": "pnpm run format || nps format:pkg:fix",
+      "files": [
+        "src/**",
+        "*.json",
+        "../../.prettierignore",
+        "../../.prettierrc.json"
+      ],
+      "output": [],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "lint": {
+      "command": "nps lint:pkg",
+      "files": [
+        "src/**",
+        "../../.eslintignore",
+        "../../.eslintrc.js"
+      ],
+      "output": [],
+      "dependencies": [
+        "../victory-vendor:build",
+        "../victory-core:types:create",
+        "../victory-vendor:types:create",
+        "../victory-chart:types:create",
+        "../victory-voronoi:types:create"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "lint:fix": {
+      "command": "pnpm run lint || nps lint:pkg:fix",
+      "files": [
+        "src/**",
+        "../../.eslintignore",
+        "../../.eslintrc.js"
+      ],
+      "output": [],
+      "dependencies": [
+        "../victory-vendor:build",
+        "../victory-core:types:create",
+        "../victory-vendor:types:create",
+        "../victory-chart:types:create",
+        "../victory-voronoi:types:create"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    },
+    "jest": {
+      "command": "nps jest:pkg",
+      "files": [
+        "src/**/*.test.*",
+        "../../.babelrc.js",
+        "../../test/jest-config.js",
+        "../../test/jest-setup.ts"
+      ],
+      "output": [],
+      "dependencies": [
+        "build:lib:cjs",
+        "../victory-chart:build:lib:cjs",
+        "../victory-vendor:build:lib:cjs",
+        "../victory-voronoi:build:lib:cjs"
+      ],
+      "packageLocks": [
+        "pnpm-lock.yaml"
+      ]
+    }
+  },
+  "scripts": {
+    "###            THESE SCRIPTS ARE GENERATED           ###": "true",
+    "###            DO NOT MODIFY THESE MANUALLY          ###": "true",
+    "build": "wireit",
+    "build:lib": "wireit",
+    "build:lib:esm": "wireit",
+    "build:lib:cjs": "wireit",
+    "build:dist": "wireit",
+    "build:dist:dev": "wireit",
+    "build:dist:min": "wireit",
+    "check": "wireit",
+    "types:check": "wireit",
+    "types:create": "wireit",
+    "format": "wireit",
+    "format:fix": "wireit",
+    "lint": "wireit",
+    "lint:fix": "wireit",
+    "jest": "wireit"
+  }
+}

package/src/{helper-methods.js → helper-methods.tsx}

@@ -152,7 +152,7 @@ export const getDomain = (props, axis) => {
   return Domain.createDomainFunction(getDomainFromData)(props, axis);
 };
 
-const getLabelStyle = (props, styleObject, namespace) => {
+const getLabelStyle = (props, styleObject, namespace?) => {
   const component = props[`${namespace}LabelComponent`] || props.labelComponent;
   const baseStyle = styleObject[`${namespace}Labels`] || styleObject.labels;
   if (!Helpers.isTooltip(component)) {

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./victory-box-plot";