victory-core 36.3.2 → 36.5.0

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

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

package/lib/victory-animation/util.js

@@ -3,13 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.victoryInterpolator = exports.interpolateString = exports.interpolateObject = exports.interpolateFunction = exports.interpolateImmediate = exports.isInterpolatable = void 0;
+exports.victoryInterpolator = exports.isInterpolatable = exports.interpolateString = exports.interpolateObject = exports.interpolateImmediate = exports.interpolateFunction = void 0;
 
 var _orderBy2 = _interopRequireDefault(require("lodash/orderBy"));
 
 var _isPlainObject2 = _interopRequireDefault(require("lodash/isPlainObject"));
 
-var _d3Interpolate = require("d3-interpolate");
+var _d3Interpolate = require("victory-vendor/d3-interpolate");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -105,7 +105,7 @@ var interpolateFunction = function (a, b) {
     }
 
     return function () {
-      /* eslint-disable no-invalid-this */
+      /* eslint-disable no-invalid-this, prefer-rest-params */
       var aval = typeof a === "function" ? a.apply(this, arguments) : a;
       var bval = typeof b === "function" ? b.apply(this, arguments) : b;
       return (0, _d3Interpolate.interpolate)(aval, bval)(t);
@@ -227,6 +227,7 @@ var victoryInterpolator = function (a, b) {
   }
 
   if ((0, _isPlainObject2.default)(a) || (0, _isPlainObject2.default)(b)) {
+    // @ts-expect-error These generics are tough, but they work ok?
     return interpolateObject(a, b);
   }
 

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

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

package/lib/victory-animation/victory-animation.js

@@ -3,13 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.VictoryAnimation = void 0;
 
 var _react = _interopRequireDefault(require("react"));
 
 var _propTypes = _interopRequireDefault(require("prop-types"));
 
-var d3Ease = _interopRequireWildcard(require("d3-ease"));
+var d3Ease = _interopRequireWildcard(require("victory-vendor/d3-ease"));
 
 var _util = require("./util");
 
@@ -17,43 +17,107 @@ var _timerContext = _interopRequireDefault(require("../victory-util/timer-contex
 
 var _reactFastCompare = _interopRequireDefault(require("react-fast-compare"));
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 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; }
 
-var VictoryAnimation =
-/*#__PURE__*/
-function (_React$Component) {
+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); }
+
+var VictoryAnimation = /*#__PURE__*/function (_React$Component) {
   _inherits(VictoryAnimation, _React$Component);
 
+  var _super = _createSuper(VictoryAnimation);
+
   function VictoryAnimation(props, context) {
     var _this;
 
     _classCallCheck(this, VictoryAnimation);
 
-    _this = _possibleConstructorReturn(this, (VictoryAnimation.__proto__ || Object.getPrototypeOf(VictoryAnimation)).call(this, props, context));
+    _this = _super.call(this, props, context);
     /* defaults */
 
+    _this.interpolator = void 0;
+    _this.queue = void 0;
+    _this.ease = void 0;
+    _this.timer = void 0;
+    _this.loopID = void 0;
+
+    _this.functionToBeRunEachFrame = function (elapsed, duration) {
+      /*
+        step can generate imprecise values, sometimes greater than 1
+        if this happens set the state to 1 and return, cancelling the timer
+      */
+      duration = duration !== undefined ? duration : _this.props.duration;
+      var step = duration ? elapsed / duration : 1;
+
+      if (step >= 1) {
+        _this.setState({
+          data: _this.interpolator(1),
+          animationInfo: {
+            progress: 1,
+            animating: false,
+            terminating: true
+          }
+        });
+
+        if (_this.loopID) {
+          _this.timer.unsubscribe(_this.loopID);
+        }
+
+        _this.queue.shift();
+
+        _this.traverseQueue();
+
+        return;
+      }
+      /*
+        if we're not at the end of the timer, set the state by passing
+        current step value that's transformed by the ease function to the
+        interpolator, which is cached for performance whenever props are received
+      */
+
+
+      _this.setState({
+        data: _this.interpolator(_this.ease(step)),
+        animationInfo: {
+          progress: step,
+          animating: step < 1
+        }
+      });
+    };
+
     _this.state = {
       data: Array.isArray(_this.props.data) ? _this.props.data[0] : _this.props.data,
       animationInfo: {
@@ -66,12 +130,6 @@ function (_React$Component) {
     /* build easing function */
 
     _this.ease = d3Ease[_this.toNewName(_this.props.easing)];
-    /*
-      There is no autobinding of this in ES6 classes
-      so we bind functionToBeRunEachFrame to current instance of victory animation class
-    */
-
-    _this.functionToBeRunEachFrame = _this.functionToBeRunEachFrame.bind(_assertThisInitialized(_this));
     _this.timer = _this.context.animationTimer;
     return _this;
   }
@@ -113,10 +171,10 @@ function (_React$Component) {
             this.queue.push(this.props.data);
             /* If an array was supplied */
           } else {
-            var _queue;
+            var _this$queue;
 
             /* Extend the tween queue */
-            (_queue = this.queue).push.apply(_queue, _toConsumableArray(this.props.data));
+            (_this$queue = this.queue).push.apply(_this$queue, _toConsumableArray(this.props.data));
           }
           /* Start traversing the tween queue */
 
@@ -172,49 +230,6 @@ function (_React$Component) {
     }
     /* every frame we... */
 
-  }, {
-    key: "functionToBeRunEachFrame",
-    value: function functionToBeRunEachFrame(elapsed, duration) {
-      /*
-        step can generate imprecise values, sometimes greater than 1
-        if this happens set the state to 1 and return, cancelling the timer
-      */
-      duration = duration !== undefined ? duration : this.props.duration;
-      var step = duration ? elapsed / duration : 1;
-
-      if (step >= 1) {
-        this.setState({
-          data: this.interpolator(1),
-          animationInfo: {
-            progress: 1,
-            animating: false,
-            terminating: true
-          }
-        });
-
-        if (this.loopID) {
-          this.timer.unsubscribe(this.loopID);
-        }
-
-        this.queue.shift();
-        this.traverseQueue();
-        return;
-      }
-      /*
-        if we're not at the end of the timer, set the state by passing
-        current step value that's transformed by the ease function to the
-        interpolator, which is cached for performance whenever props are received
-      */
-
-
-      this.setState({
-        data: this.interpolator(this.ease(step)),
-        animationInfo: {
-          progress: step,
-          animating: step < 1
-        }
-      });
-    }
   }, {
     key: "render",
     value: function render() {
@@ -225,40 +240,20 @@ function (_React$Component) {
   return VictoryAnimation;
 }(_react.default.Component);
 
-exports.default = VictoryAnimation;
-Object.defineProperty(VictoryAnimation, "displayName", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: "VictoryAnimation"
-});
-Object.defineProperty(VictoryAnimation, "propTypes", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: {
-    children: _propTypes.default.func,
-    data: _propTypes.default.oneOfType([_propTypes.default.object, _propTypes.default.array]),
-    delay: _propTypes.default.number,
-    duration: _propTypes.default.number,
-    easing: _propTypes.default.oneOf(["back", "backIn", "backOut", "backInOut", "bounce", "bounceIn", "bounceOut", "bounceInOut", "circle", "circleIn", "circleOut", "circleInOut", "linear", "linearIn", "linearOut", "linearInOut", "cubic", "cubicIn", "cubicOut", "cubicInOut", "elastic", "elasticIn", "elasticOut", "elasticInOut", "exp", "expIn", "expOut", "expInOut", "poly", "polyIn", "polyOut", "polyInOut", "quad", "quadIn", "quadOut", "quadInOut", "sin", "sinIn", "sinOut", "sinInOut"]),
-    onEnd: _propTypes.default.func
-  }
-});
-Object.defineProperty(VictoryAnimation, "defaultProps", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: {
-    data: {},
-    delay: 0,
-    duration: 1000,
-    easing: "quadInOut"
-  }
-});
-Object.defineProperty(VictoryAnimation, "contextType", {
-  configurable: true,
-  enumerable: true,
-  writable: true,
-  value: _timerContext.default
-});
+exports.VictoryAnimation = VictoryAnimation;
+VictoryAnimation.displayName = "VictoryAnimation";
+VictoryAnimation.propTypes = {
+  children: _propTypes.default.func,
+  data: _propTypes.default.oneOfType([_propTypes.default.object, _propTypes.default.array]),
+  delay: _propTypes.default.number,
+  duration: _propTypes.default.number,
+  easing: _propTypes.default.oneOf(["back", "backIn", "backOut", "backInOut", "bounce", "bounceIn", "bounceOut", "bounceInOut", "circle", "circleIn", "circleOut", "circleInOut", "linear", "linearIn", "linearOut", "linearInOut", "cubic", "cubicIn", "cubicOut", "cubicInOut", "elastic", "elasticIn", "elasticOut", "elasticInOut", "exp", "expIn", "expOut", "expInOut", "poly", "polyIn", "polyOut", "polyInOut", "quad", "quadIn", "quadOut", "quadInOut", "sin", "sinIn", "sinOut", "sinInOut"]),
+  onEnd: _propTypes.default.func
+};
+VictoryAnimation.defaultProps = {
+  data: {},
+  delay: 0,
+  duration: 1000,
+  easing: "quadInOut"
+};
+VictoryAnimation.contextType = _timerContext.default;

package/lib/victory-clip-container/victory-clip-container.d.ts

@@ -0,0 +1,76 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { BlockProps } from "../victory-theme/victory-theme";
+import { OriginType } from "../victory-label/victory-label";
+export interface VictoryClipContainerProps {
+    "aria-label"?: string;
+    children?: React.ReactElement | React.ReactElement[];
+    circleComponent?: React.ReactElement;
+    className?: string;
+    clipHeight?: number;
+    clipId?: number | string;
+    clipPadding?: BlockProps;
+    clipPathComponent?: React.ReactElement;
+    clipWidth?: number;
+    events?: React.DOMAttributes<any>;
+    groupComponent?: React.ReactElement;
+    origin?: OriginType;
+    polar?: boolean;
+    radius?: number;
+    rectComponent?: React.ReactElement;
+    translateX?: number;
+    translateY?: number;
+}
+export declare class VictoryClipContainer extends React.Component<VictoryClipContainerProps> {
+    static displayName: string;
+    static role: string;
+    static propTypes: {
+        "aria-label": PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<string | number | boolean | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        circleComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        className: PropTypes.Requireable<string>;
+        clipHeight: any;
+        clipId: PropTypes.Requireable<string | number>;
+        clipPadding: PropTypes.Requireable<PropTypes.InferProps<{
+            top: PropTypes.Requireable<number>;
+            bottom: PropTypes.Requireable<number>;
+            left: PropTypes.Requireable<number>;
+            right: PropTypes.Requireable<number>;
+        }>>;
+        clipPathComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        clipWidth: any;
+        events: PropTypes.Requireable<object>;
+        groupComponent: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        origin: PropTypes.Requireable<PropTypes.InferProps<{
+            x: any;
+            y: any;
+        }>>;
+        polar: PropTypes.Requireable<boolean>;
+        radius: any;
+        style: PropTypes.Requireable<object>;
+        tabIndex: PropTypes.Requireable<number>;
+        transform: PropTypes.Requireable<string>;
+        translateX: PropTypes.Requireable<number>;
+        translateY: PropTypes.Requireable<number>;
+    };
+    static defaultProps: {
+        circleComponent: JSX.Element;
+        rectComponent: JSX.Element;
+        clipPathComponent: JSX.Element;
+        groupComponent: JSX.Element;
+    };
+    private clipId;
+    constructor(props: VictoryClipContainerProps);
+    calculateAttributes(props: any): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    renderClippedGroup(props: any, clipId: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+    renderGroup(props: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+    renderClipComponent(props: any, clipId: any): React.DetailedReactHTMLElement<any, HTMLElement>;
+    getClipValue(props: any, axis: any): any;
+    getTranslateValue(props: any, axis: any): any;
+    render(): React.DetailedReactHTMLElement<any, HTMLElement>;
+}