victory-bar 36.7.0 → 36.8.2

package/es/bar-helper-methods.d.ts

@@ -0,0 +1,7 @@
+import { VictoryStyleObject } from "victory-core";
+import { BarProps } from "./bar";
+import { VictoryBarCornerRadiusKey } from "./victory-bar";
+export declare const getBarWidth: (barWidth: BarProps["barWidth"], props: BarProps) => any;
+export declare const getCornerRadius: (cornerRadius: BarProps["cornerRadius"], props: BarProps) => Partial<Record<VictoryBarCornerRadiusKey, import("victory-core").NumberOrCallback>>;
+export declare const getStyle: (style: VictoryStyleObject | undefined, props: BarProps) => any;
+//# sourceMappingURL=bar-helper-methods.d.ts.map

package/es/bar-helper-methods.js

@@ -2,10 +2,10 @@ import _isPlainObject from "lodash/isPlainObject";
 import _isNil from "lodash/isNil";
 import _assign from "lodash/assign";
 import { Helpers } from "victory-core";
+var DEFAULT_BAR_WIDTH = 8;
 export var getBarWidth = function (barWidth, props) {
   var scale = props.scale,
       data = props.data,
-      defaultBarWidth = props.defaultBarWidth,
       style = props.style;
 
   if (barWidth) {
@@ -18,7 +18,7 @@ export var getBarWidth = function (barWidth, props) {
   var extent = Math.abs(range[1] - range[0]);
   var bars = data.length + 2;
   var barRatio = props.barRatio || 0.5;
-  var defaultWidth = barRatio * (data.length < 2 ? defaultBarWidth : extent / bars);
+  var defaultWidth = barRatio * (data.length < 2 ? DEFAULT_BAR_WIDTH : extent / bars);
   return Math.max(1, defaultWidth);
 };
 
@@ -45,6 +45,10 @@ var getCornerRadiusFromObject = function (cornerRadius, props) {
   return realCornerRadius;
 };
 
+function isCornerRadiusObject(cornerRadius) {
+  return _isPlainObject(cornerRadius);
+}
+
 export var getCornerRadius = function (cornerRadius, props) {
   var realCornerRadius = {
     topLeft: 0,
@@ -57,7 +61,7 @@ export var getCornerRadius = function (cornerRadius, props) {
     return realCornerRadius;
   }
 
-  if (_isPlainObject(cornerRadius)) {
+  if (isCornerRadiusObject(cornerRadius)) {
     return getCornerRadiusFromObject(cornerRadius, props);
   }
 

package/es/bar.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { NumberOrCallback, VictoryCommonPrimitiveProps } from "victory-core";
+import { VictoryBarAlignmentType, VictoryBarCornerRadiusObject } from "./victory-bar";
+export interface BarProps extends VictoryCommonPrimitiveProps {
+    alignment?: VictoryBarAlignmentType;
+    barOffset?: number[];
+    barRatio?: number;
+    barWidth?: NumberOrCallback;
+    cornerRadius?: NumberOrCallback | VictoryBarCornerRadiusObject;
+    datum?: any;
+    getPath?: (x: number, y: number, props: any) => string;
+    horizontal?: boolean;
+    pathComponent?: React.ReactElement;
+    width?: number;
+    x?: number;
+    y?: number;
+    y0?: number;
+}
+export declare const Bar: React.ForwardRefExoticComponent<BarProps & React.RefAttributes<SVGPathElement>>;
+//# sourceMappingURL=bar.d.ts.map

package/es/bar.js

@@ -6,9 +6,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import PropTypes from "prop-types";
 import React, { forwardRef } from "react";
-import { CommonProps, Helpers, Path } from "victory-core";
+import { Helpers, Path } from "victory-core";
 import { getStyle, getBarWidth, getCornerRadius } from "./bar-helper-methods";
 import { getPolarBarPath, getBarPath } from "./path-helper-methods";
 
@@ -46,11 +45,16 @@ var evaluateProps = function (props) {
     id: id,
     tabIndex: tabIndex
   });
-}; // eslint-disable-next-line prefer-arrow-callback
+};
 
+var defaultProps = {
+  pathComponent: /*#__PURE__*/React.createElement(Path, null),
+  role: "presentation",
+  shapeRendering: "auto"
+}; // eslint-disable-next-line prefer-arrow-callback
 
-var Bar = /*#__PURE__*/forwardRef(function Bar(props, ref) {
-  props = evaluateProps(props);
+export var Bar = /*#__PURE__*/forwardRef(function Bar(props, ref) {
+  props = evaluateProps(_objectSpread(_objectSpread({}, defaultProps), props));
   var _props = props,
       polar = _props.polar,
       origin = _props.origin,
@@ -59,6 +63,11 @@ var Bar = /*#__PURE__*/forwardRef(function Bar(props, ref) {
       cornerRadius = _props.cornerRadius;
   var path = polar ? getPolarBarPath(props, cornerRadius) : getBarPath(props, barWidth, cornerRadius);
   var defaultTransform = polar && origin ? "translate(".concat(origin.x, ", ").concat(origin.y, ")") : undefined;
+
+  if (!props.pathComponent) {
+    return null;
+  }
+
   return /*#__PURE__*/React.cloneElement(props.pathComponent, _objectSpread(_objectSpread({}, props.events), {}, {
     "aria-label": props.ariaLabel,
     style: style,
@@ -73,32 +82,4 @@ var Bar = /*#__PURE__*/forwardRef(function Bar(props, ref) {
     tabIndex: props.tabIndex,
     ref: ref
   }));
-});
-Bar.propTypes = _objectSpread(_objectSpread({}, CommonProps.primitiveProps), {}, {
-  alignment: PropTypes.oneOf(["start", "middle", "end"]),
-  barRatio: PropTypes.number,
-  barWidth: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-  cornerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.func, PropTypes.shape({
-    top: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    topLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    topRight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottom: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottomLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottomRight: PropTypes.oneOfType([PropTypes.number, PropTypes.func])
-  })]),
-  datum: PropTypes.object,
-  getPath: PropTypes.func,
-  horizontal: PropTypes.bool,
-  pathComponent: PropTypes.element,
-  width: PropTypes.number,
-  x: PropTypes.number,
-  y: PropTypes.number,
-  y0: PropTypes.number
-});
-Bar.defaultProps = {
-  defaultBarWidth: 8,
-  pathComponent: /*#__PURE__*/React.createElement(Path, null),
-  role: "presentation",
-  shapeRendering: "auto"
-};
-export default Bar;
+});

package/es/geometry-helper-methods.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A point in the 2d plane
+ */
+export declare const point: (x: number, y: number) => {
+    x: number;
+    y: number;
+    distance(p1: {
+        x: number;
+        y: number;
+    }): number;
+    add(p1: {
+        x: number;
+        y: number;
+    }): any;
+    subtract(p1: {
+        x: number;
+        y: number;
+    }): any;
+    scalarMult(n: number): any;
+    scalarDivide(n: number): any;
+    equals(p1: {
+        x: number;
+        y: number;
+    }): boolean;
+};
+declare type Center = ReturnType<typeof point>;
+/**
+ * A circle in the 2d plane
+ */
+export declare const circle: (center: Center, radius: number) => {
+    center: {
+        x: number;
+        y: number;
+        distance(p1: {
+            x: number;
+            y: number;
+        }): number;
+        add(p1: {
+            x: number;
+            y: number;
+        }): any;
+        subtract(p1: {
+            x: number;
+            y: number;
+        }): any;
+        scalarMult(n: number): any;
+        scalarDivide(n: number): any;
+        equals(p1: {
+            x: number;
+            y: number;
+        }): boolean;
+    };
+    radius: number;
+    hasIntersection(circle1: {
+        center: Center;
+        radius: number;
+    }): boolean;
+    equals(circle1: {
+        center: Center;
+        radius: number;
+    }): boolean;
+    intersection(circle1: {
+        center: Center;
+        radius: number;
+    }): {
+        x: number;
+        y: number;
+        distance(p1: {
+            x: number;
+            y: number;
+        }): number;
+        add(p1: {
+            x: number;
+            y: number;
+        }): any;
+        subtract(p1: {
+            x: number;
+            y: number;
+        }): any;
+        scalarMult(n: number): any;
+        scalarDivide(n: number): any;
+        equals(p1: {
+            x: number;
+            y: number;
+        }): boolean;
+    }[];
+    solveX(y: number): number[];
+    solveY(x: number): number[];
+};
+export {};
+//# sourceMappingURL=geometry-helper-methods.d.ts.map

package/es/geometry-helper-methods.js

@@ -1,10 +1,7 @@
 /**
  * A point in the 2d plane
- * @param {number} x - x coordinate
- * @param {number} y - y coordinate
- * @returns {object} - point object
  */
-var point = function (x, y) {
+export var point = function (x, y) {
   return {
     x: x,
     y: y,
@@ -36,15 +33,11 @@ var point = function (x, y) {
     }
   };
 };
+
 /**
  * A circle in the 2d plane
- * @param {point} center - center of circle
- * @param {number} radius - radius of circle
- * @returns {object} - point object
  */
-
-
-var circle = function (center, radius) {
+export var circle = function (center, radius) {
   return {
     center: center,
     radius: radius,
@@ -112,6 +105,4 @@ var circle = function (center, radius) {
       return [this.center.y - sqrt, this.center.y + sqrt];
     }
   };
-};
-
-export { circle, point };
+};

package/es/helper-methods.d.ts

@@ -0,0 +1,8 @@
+export declare const getBarPosition: (props: any, datum: any) => {
+    x: any;
+    x0: any;
+    y: any;
+    y0: any;
+};
+export declare const getBaseProps: (props: any, fallbackProps: any) => any;
+//# sourceMappingURL=helper-methods.d.ts.map

package/es/index.d.ts

@@ -1,73 +1,6 @@
-import * as React from "react";
-import {
-  EventPropTypeInterface,
-  NumberOrCallback,
-  StringOrNumberOrCallback,
-  VictoryCommonProps,
-  VictoryCommonPrimitiveProps,
-  VictoryDatableProps,
-  VictoryMultiLabelableProps,
-  VictoryStyleInterface,
-} from "victory-core";
-
-export type VictoryBarTTargetType = "data" | "labels" | "parent";
-export type VictoryBarAlignmentType = "start" | "middle" | "end";
-
-export interface VictoryBarProps
-  extends VictoryCommonProps,
-    VictoryDatableProps,
-    VictoryMultiLabelableProps {
-  alignment?: VictoryBarAlignmentType;
-  barRatio?: number;
-  barWidth?: NumberOrCallback;
-  cornerRadius?:
-    | NumberOrCallback
-    | {
-        top?: NumberOrCallback;
-        topLeft?: NumberOrCallback;
-        topRight?: NumberOrCallback;
-        bottom?: NumberOrCallback;
-        bottomLeft?: NumberOrCallback;
-        bottomRight?: NumberOrCallback;
-      };
-  events?: EventPropTypeInterface<
-    VictoryBarTTargetType,
-    number | string | number[] | string[]
-  >[];
-  eventKey?: StringOrNumberOrCallback;
-  horizontal?: boolean;
-  style?: VictoryStyleInterface;
-}
-
-/**
- * Draw SVG bar charts with React. VictoryBar is a composable component, so it doesn"t include axes
- * Check out VictoryChart for complete bar charts and more.
- */
-export class VictoryBar extends React.Component<VictoryBarProps, any> {}
-
-export interface BarProps extends VictoryCommonPrimitiveProps {
-  alignment?: VictoryBarAlignmentType;
-  barOffset?: number[];
-  barRatio?: number;
-  barWidth?: NumberOrCallback;
-  cornerRadius?:
-    | NumberOrCallback
-    | {
-        top?: NumberOrCallback;
-        topLeft?: NumberOrCallback;
-        topRight?: NumberOrCallback;
-        bottom?: NumberOrCallback;
-        bottomLeft?: NumberOrCallback;
-        bottomRight?: NumberOrCallback;
-      };
-  datum?: any;
-  getPath?: Function;
-  horizontal?: boolean;
-  pathComponent?: React.ReactElement;
-  width?: number;
-  x?: number;
-  y?: number;
-  y0?: number;
-}
-
-export class Bar extends React.Component<BarProps, any> {}
+export * from "./victory-bar";
+export * from "./bar";
+export { getBarPosition } from "./helper-methods";
+export { getVerticalBarPath, getHorizontalBarPath, getVerticalPolarBarPath, getCustomBarPath, getPolarBarPath, getBarPath, } from "./path-helper-methods";
+export { getBarWidth, getStyle, getCornerRadius } from "./bar-helper-methods";
+//# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -1,5 +1,5 @@
-export { default as VictoryBar } from "./victory-bar";
-export { default as Bar } from "./bar";
+export * from "./victory-bar";
+export * from "./bar";
 export { getBarPosition } from "./helper-methods";
 export { getVerticalBarPath, getHorizontalBarPath, getVerticalPolarBarPath, getCustomBarPath, getPolarBarPath, getBarPath } from "./path-helper-methods";
 export { getBarWidth, getStyle, getCornerRadius } from "./bar-helper-methods";

package/es/path-helper-methods.d.ts

@@ -0,0 +1,7 @@
+export declare const getCustomBarPath: (props: any, width: any) => any;
+export declare const getVerticalBarPath: (props: any, width: any, cornerRadius: any) => string;
+export declare const getHorizontalBarPath: (props: any, width: any, cornerRadius: any) => string;
+export declare const getVerticalPolarBarPath: (props: any, cornerRadius: any) => string;
+export declare const getBarPath: (props: any, width: any, cornerRadius: any) => any;
+export declare const getPolarBarPath: (props: any, cornerRadius: any) => string;
+//# sourceMappingURL=path-helper-methods.d.ts.map

package/es/path-helper-methods.js

@@ -350,11 +350,11 @@ export var getVerticalPolarBarPath = function (props, cornerRadius) {
 
   var getPathData = function (edge) {
     var rightPath = getPath("".concat(edge, "Right"));
-    var rightMoves = rightPath.match(/[A-Z]/g);
+    var rightMoves = rightPath.match(/[A-Z]/g) || [];
     var rightCoords = rightPath.split(/[A-Z]/).slice(1);
     var rightMiddle = rightMoves.indexOf("L");
     var leftPath = getPath("".concat(edge, "Left"));
-    var leftMoves = leftPath.match(/[A-Z]/g);
+    var leftMoves = leftPath.match(/[A-Z]/g) || [];
     var leftCoords = leftPath.split(/[A-Z]/).slice(1);
     var leftMiddle = leftMoves.indexOf("L");
     return {

package/es/victory-bar.d.ts

@@ -0,0 +1,129 @@
+import React from "react";
+import { Data, Domain, EventPropTypeInterface, NumberOrCallback, StringOrNumberOrCallback, VictoryCommonProps, VictoryDatableProps, VictoryMultiLabelableProps, VictoryStyleInterface, EventsMixinClass } from "victory-core";
+export declare type VictoryBarCornerRadiusKey = "top" | "bottom" | "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+export declare type VictoryBarCornerRadiusObject = Partial<Record<VictoryBarCornerRadiusKey, NumberOrCallback>>;
+export declare type VictoryBarTTargetType = "data" | "labels" | "parent";
+export declare type VictoryBarAlignmentType = "start" | "middle" | "end";
+export interface VictoryBarProps extends VictoryCommonProps, VictoryDatableProps, VictoryMultiLabelableProps {
+    alignment?: VictoryBarAlignmentType;
+    barRatio?: number;
+    barWidth?: NumberOrCallback;
+    cornerRadius?: NumberOrCallback | VictoryBarCornerRadiusObject;
+    events?: EventPropTypeInterface<VictoryBarTTargetType, number | string | number[] | string[]>[];
+    eventKey?: StringOrNumberOrCallback;
+    horizontal?: boolean;
+    style?: VictoryStyleInterface;
+}
+interface VictoryBarBase extends EventsMixinClass<VictoryBarProps> {
+}
+/**
+ * Draw SVG bar charts with React. VictoryBar is a composable component, so it doesn"t include axes
+ * Check out VictoryChart for complete bar charts and more.
+ */
+declare class VictoryBarBase extends React.Component<VictoryBarProps> {
+    static animationWhitelist: (keyof VictoryBarProps)[];
+    static displayName: string;
+    static role: string;
+    static defaultTransitions: {
+        onLoad: {
+            duration: number;
+            before: () => {
+                _y: number;
+                _y1: number;
+                _y0: number;
+            };
+            after: (datum: any) => {
+                _y: any;
+                _y1: any;
+                _y0: any;
+            };
+        };
+        onExit: {
+            duration: number;
+            before: () => {
+                _y: number;
+                yOffset: number;
+            };
+        };
+        onEnter: {
+            duration: number;
+            before: () => {
+                _y: number;
+                _y1: number;
+                _y0: number;
+            };
+            after: (datum: any) => {
+                _y: any;
+                _y1: any;
+                _y0: any;
+            };
+        };
+    };
+    static defaultProps: VictoryBarProps;
+    static getDomain: typeof Domain.getDomainWithZero;
+    static getData: typeof Data.getData;
+    static getBaseProps: (props: VictoryBarProps) => any;
+    static expectedComponents: (keyof VictoryBarProps)[];
+    shouldAnimate(): boolean;
+    render(): React.ReactElement;
+}
+export declare const VictoryBar: {
+    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: React.ReactNode, type: string, index: string | number): 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 VictoryBarBase;
+export {};
+//# sourceMappingURL=victory-bar.d.ts.map

package/es/victory-bar.js

@@ -1,9 +1,3 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 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); } }
@@ -24,11 +18,10 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-import PropTypes from "prop-types";
 import React from "react";
 import { getBaseProps } from "./helper-methods";
-import Bar from "./bar";
-import { Helpers, VictoryLabel, VictoryContainer, VictoryTheme, CommonProps, addEvents, Data, Domain, UserProps } from "victory-core";
+import { Bar } from "./bar";
+import { Helpers, VictoryLabel, VictoryContainer, VictoryTheme, addEvents, Data, Domain, UserProps } from "victory-core";
 var fallbackProps = {
   width: 450,
   height: 300,
@@ -46,20 +39,24 @@ var defaultData = [{
 }, {
   x: 4,
   y: 4
-}];
+}]; // eslint-disable-next-line @typescript-eslint/no-empty-interface
 
-var VictoryBar = /*#__PURE__*/function (_React$Component) {
-  _inherits(VictoryBar, _React$Component);
+/**
+ * Draw SVG bar charts with React. VictoryBar is a composable component, so it doesn"t include axes
+ * Check out VictoryChart for complete bar charts and more.
+ */
+var VictoryBarBase = /*#__PURE__*/function (_React$Component) {
+  _inherits(VictoryBarBase, _React$Component);
 
-  var _super = _createSuper(VictoryBar);
+  var _super = _createSuper(VictoryBarBase);
 
-  function VictoryBar() {
-    _classCallCheck(this, VictoryBar);
+  function VictoryBarBase() {
+    _classCallCheck(this, VictoryBarBase);
 
     return _super.apply(this, arguments);
   }
 
-  _createClass(VictoryBar, [{
+  _createClass(VictoryBarBase, [{
     key: "shouldAnimate",
     value: // Overridden in native versions
     function shouldAnimate() {
@@ -82,13 +79,13 @@ var VictoryBar = /*#__PURE__*/function (_React$Component) {
     }
   }]);
 
-  return VictoryBar;
+  return VictoryBarBase;
 }(React.Component);
 
-VictoryBar.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
-VictoryBar.displayName = "VictoryBar";
-VictoryBar.role = "bar";
-VictoryBar.defaultTransitions = {
+VictoryBarBase.animationWhitelist = ["data", "domain", "height", "padding", "style", "width"];
+VictoryBarBase.displayName = "VictoryBar";
+VictoryBarBase.role = "bar";
+VictoryBarBase.defaultTransitions = {
   onLoad: {
     duration: 2000,
     before: function () {
@@ -133,22 +130,7 @@ VictoryBar.defaultTransitions = {
     }
   }
 };
-VictoryBar.propTypes = _objectSpread(_objectSpread(_objectSpread({}, CommonProps.baseProps), CommonProps.dataProps), {}, {
-  alignment: PropTypes.oneOf(["start", "middle", "end"]),
-  barRatio: PropTypes.number,
-  barWidth: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-  cornerRadius: PropTypes.oneOfType([PropTypes.number, PropTypes.func, PropTypes.shape({
-    top: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    topLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    topRight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottom: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottomLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
-    bottomRight: PropTypes.oneOfType([PropTypes.number, PropTypes.func])
-  })]),
-  getPath: PropTypes.func,
-  horizontal: PropTypes.bool
-});
-VictoryBar.defaultProps = {
+VictoryBarBase.defaultProps = {
   containerComponent: /*#__PURE__*/React.createElement(VictoryContainer, null),
   data: defaultData,
   dataComponent: /*#__PURE__*/React.createElement(Bar, null),
@@ -161,12 +143,12 @@ VictoryBar.defaultProps = {
   standalone: true,
   theme: VictoryTheme.grayscale
 };
-VictoryBar.getDomain = Domain.getDomainWithZero;
-VictoryBar.getData = Data.getData;
+VictoryBarBase.getDomain = Domain.getDomainWithZero;
+VictoryBarBase.getData = Data.getData;
 
-VictoryBar.getBaseProps = function (props) {
+VictoryBarBase.getBaseProps = function (props) {
   return getBaseProps(props, fallbackProps);
 };
 
-VictoryBar.expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent"];
-export default addEvents(VictoryBar);
+VictoryBarBase.expectedComponents = ["dataComponent", "labelComponent", "groupComponent", "containerComponent"];
+export var VictoryBar = addEvents(VictoryBarBase);

package/lib/bar-helper-methods.d.ts

@@ -0,0 +1,7 @@
+import { VictoryStyleObject } from "victory-core";
+import { BarProps } from "./bar";
+import { VictoryBarCornerRadiusKey } from "./victory-bar";
+export declare const getBarWidth: (barWidth: BarProps["barWidth"], props: BarProps) => any;
+export declare const getCornerRadius: (cornerRadius: BarProps["cornerRadius"], props: BarProps) => Partial<Record<VictoryBarCornerRadiusKey, import("victory-core").NumberOrCallback>>;
+export declare const getStyle: (style: VictoryStyleObject | undefined, props: BarProps) => any;
+//# sourceMappingURL=bar-helper-methods.d.ts.map