victory-core 36.2.2 → 36.4.0

package/es/victory-util/add-events.js

@@ -8,31 +8,44 @@ import _keys from "lodash/keys";
 import _assign from "lodash/assign";
 import _defaults from "lodash/defaults";
 
-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"); }
+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 _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+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 _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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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 _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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
 /*global window:false */
 import React from "react";
 import * as Events from "./events";
 import isEqual from "react-fast-compare";
 import VictoryTransition from "../victory-transition/victory-transition";
+import * as UserProps from "../victory-util/user-props";
 
 var datumHasXandY = function (datum) {
   return !_isNil(datum._x) && !_isNil(datum._y);
@@ -48,363 +61,362 @@ var defaultComponents = [{
   name: "labels"
 }];
 export default (function (WrappedComponent, options) {
-  return (
-    /*#__PURE__*/
-    function (_WrappedComponent) {
-      _inherits(addEvents, _WrappedComponent);
+  return /*#__PURE__*/function (_WrappedComponent) {
+    _inherits(addEvents, _WrappedComponent);
 
-      function addEvents(props) {
-        var _this;
+    var _super = _createSuper(addEvents);
 
-        _classCallCheck(this, addEvents);
+    function addEvents(props) {
+      var _this;
 
-        _this = _possibleConstructorReturn(this, (addEvents.__proto__ || Object.getPrototypeOf(addEvents)).call(this, props));
-        var getScopedEvents = Events.getScopedEvents.bind(_assertThisInitialized(_this));
-        var boundGetEvents = Events.getEvents.bind(_assertThisInitialized(_this));
-        _this.state = {};
+      _classCallCheck(this, addEvents);
 
-        _this.getEvents = function (p, target, eventKey) {
-          return boundGetEvents(p, target, eventKey, getScopedEvents);
-        };
+      _this = _super.call(this, props);
+      var getScopedEvents = Events.getScopedEvents.bind(_assertThisInitialized(_this));
+      var boundGetEvents = Events.getEvents.bind(_assertThisInitialized(_this));
+      _this.state = {};
 
-        _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
+      _this.getEvents = function (p, target, eventKey) {
+        return boundGetEvents(p, target, eventKey, getScopedEvents);
+      };
 
-        var calculatedValues = _this.getCalculatedValues(props);
+      _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
 
-        _this.cacheValues(calculatedValues);
+      var calculatedValues = _this.getCalculatedValues(props);
 
-        _this.externalMutations = _this.getExternalMutations(props);
-        _this.calculatedState = _this.getStateChanges(props);
-        _this.globalEvents = {};
-        _this.prevGlobalEventKeys = [];
-        _this.boundGlobalEvents = {};
-        return _this;
-      }
+      _this.cacheValues(calculatedValues);
 
-      _createClass(addEvents, [{
-        key: "shouldComponentUpdate",
-        value: function shouldComponentUpdate(nextProps) {
-          var externalMutations = this.getExternalMutations(nextProps);
-          var animating = this.props.animating || this.props.animate;
-          var newMutation = !isEqual(externalMutations, this.externalMutations);
-
-          if (animating || newMutation) {
-            this.cacheValues(this.getCalculatedValues(nextProps));
-            this.externalMutations = externalMutations;
-            this.applyExternalMutations(nextProps, externalMutations);
-            return true;
-          }
+      _this.externalMutations = _this.getExternalMutations(props);
+      _this.calculatedState = _this.getStateChanges(props);
+      _this.globalEvents = {};
+      _this.prevGlobalEventKeys = [];
+      _this.boundGlobalEvents = {};
+      return _this;
+    }
 
-          var calculatedState = this.getStateChanges(nextProps);
+    _createClass(addEvents, [{
+      key: "shouldComponentUpdate",
+      value: function shouldComponentUpdate(nextProps) {
+        var externalMutations = this.getExternalMutations(nextProps);
+        var animating = this.props.animating || this.props.animate;
+        var newMutation = !isEqual(externalMutations, this.externalMutations);
 
-          if (!isEqual(this.calculatedState, calculatedState)) {
-            this.cacheValues(this.getCalculatedValues(nextProps));
-            return true;
-          }
+        if (animating || newMutation) {
+          this.cacheValues(this.getCalculatedValues(nextProps));
+          this.externalMutations = externalMutations;
+          this.applyExternalMutations(nextProps, externalMutations);
+          return true;
+        }
 
-          if (!isEqual(this.props, nextProps)) {
-            this.cacheValues(this.getCalculatedValues(nextProps));
-            return true;
-          }
+        var calculatedState = this.getStateChanges(nextProps);
 
-          return false;
+        if (!isEqual(this.calculatedState, calculatedState)) {
+          this.cacheValues(this.getCalculatedValues(nextProps));
+          return true;
         }
-      }, {
-        key: "componentDidMount",
-        value: function componentDidMount() {
-          var _this2 = this;
-
-          var globalEventKeys = _keys(this.globalEvents);
 
-          globalEventKeys.forEach(function (key) {
-            return _this2.addGlobalListener(key);
-          });
-          this.prevGlobalEventKeys = globalEventKeys;
+        if (!isEqual(this.props, nextProps)) {
+          this.cacheValues(this.getCalculatedValues(nextProps));
+          return true;
         }
-      }, {
-        key: "componentDidUpdate",
-        value: function componentDidUpdate(prevProps) {
-          var _this3 = this;
 
-          var calculatedState = this.getStateChanges(prevProps);
-          this.calculatedState = calculatedState;
+        return false;
+      }
+    }, {
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this2 = this;
 
-          var globalEventKeys = _keys(this.globalEvents);
+        var globalEventKeys = _keys(this.globalEvents);
 
-          var removedGlobalEventKeys = _difference(this.prevGlobalEventKeys, globalEventKeys);
+        globalEventKeys.forEach(function (key) {
+          return _this2.addGlobalListener(key);
+        });
+        this.prevGlobalEventKeys = globalEventKeys;
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var _this3 = this;
 
-          removedGlobalEventKeys.forEach(function (key) {
-            return _this3.removeGlobalListener(key);
-          });
+        var calculatedState = this.getStateChanges(prevProps);
+        this.calculatedState = calculatedState;
 
-          var addedGlobalEventKeys = _difference(globalEventKeys, this.prevGlobalEventKeys);
+        var globalEventKeys = _keys(this.globalEvents);
 
-          addedGlobalEventKeys.forEach(function (key) {
-            return _this3.addGlobalListener(key);
-          });
-          this.prevGlobalEventKeys = globalEventKeys;
-        }
-      }, {
-        key: "componentWillUnmount",
-        value: function componentWillUnmount() {
-          var _this4 = this;
+        var removedGlobalEventKeys = _difference(this.prevGlobalEventKeys, globalEventKeys);
 
-          this.prevGlobalEventKeys.forEach(function (key) {
-            return _this4.removeGlobalListener(key);
-          });
-        }
-      }, {
-        key: "addGlobalListener",
-        value: function addGlobalListener(key) {
-          var _this5 = this;
-
-          var boundListener = function (event) {
-            var listener = _this5.globalEvents[key];
-            return listener && listener(Events.emulateReactEvent(event));
-          };
-
-          this.boundGlobalEvents[key] = boundListener;
-          window.addEventListener(Events.getGlobalEventNameFromKey(key), boundListener);
-        }
-      }, {
-        key: "removeGlobalListener",
-        value: function removeGlobalListener(key) {
-          window.removeEventListener(Events.getGlobalEventNameFromKey(key), this.boundGlobalEvents[key]);
-        } // compile all state changes from own and parent state. Order doesn't matter, as any state
-        // state change should trigger a re-render
-
-      }, {
-        key: "getStateChanges",
-        value: function getStateChanges(props) {
-          var _this6 = this;
-
-          if (!this.hasEvents) {
-            return {};
-          }
-
-          var getState = function (key, type) {
-            var result = _defaults({}, _this6.getEventState(key, type), _this6.getSharedEventState(key, type));
-
-            return _isEmpty(result) ? undefined : result;
-          };
-
-          options = options || {};
-          var components = options.components || defaultComponents;
-          var stateChanges = components.map(function (component) {
-            if (!props.standalone && component.name === "parent") {
-              // don't check for changes on parent props for non-standalone components
-              return undefined;
-            } else {
-              return component.index !== undefined ? getState(component.index, component.name) : _this6.dataKeys.map(function (key) {
-                return getState(key, component.name);
-              }).filter(Boolean);
-            }
-          }).filter(Boolean);
-          return stateChanges;
-        }
-      }, {
-        key: "applyExternalMutations",
-        value: function applyExternalMutations(props, externalMutations) {
-          if (!_isEmpty(externalMutations)) {
-            var callbacks = props.externalEventMutations.reduce(function (memo, mutation) {
-              memo = _isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo;
-              return memo;
-            }, []);
-            var compiledCallbacks = callbacks.length ? function () {
-              callbacks.forEach(function (c) {
-                return c();
-              });
-            } : undefined;
-            this.setState(externalMutations, compiledCallbacks);
-          }
-        }
-      }, {
-        key: "getCalculatedValues",
-        value: function getCalculatedValues(props) {
-          var sharedEvents = props.sharedEvents;
-          var components = WrappedComponent.expectedComponents;
-          var componentEvents = Events.getComponentEvents(props, components);
-          var getSharedEventState = sharedEvents && _isFunction(sharedEvents.getEventState) ? sharedEvents.getEventState : function () {
-            return undefined;
-          };
-          var baseProps = this.getBaseProps(props, getSharedEventState);
+        removedGlobalEventKeys.forEach(function (key) {
+          return _this3.removeGlobalListener(key);
+        });
 
-          var dataKeys = _keys(baseProps).filter(function (key) {
-            return key !== "parent";
-          });
+        var addedGlobalEventKeys = _difference(globalEventKeys, this.prevGlobalEventKeys);
 
-          var hasEvents = props.events || props.sharedEvents || componentEvents;
-          var events = this.getAllEvents(props);
-          return {
-            componentEvents: componentEvents,
-            getSharedEventState: getSharedEventState,
-            baseProps: baseProps,
-            dataKeys: dataKeys,
-            hasEvents: hasEvents,
-            events: events
-          };
-        }
-      }, {
-        key: "getExternalMutations",
-        value: function getExternalMutations(props) {
-          var sharedEvents = props.sharedEvents,
-              externalEventMutations = props.externalEventMutations;
-          return _isEmpty(externalEventMutations) || sharedEvents ? undefined : Events.getExternalMutations(externalEventMutations, this.baseProps, this.state);
-        }
-      }, {
-        key: "cacheValues",
-        value: function cacheValues(obj) {
-          var _this7 = this;
+        addedGlobalEventKeys.forEach(function (key) {
+          return _this3.addGlobalListener(key);
+        });
+        this.prevGlobalEventKeys = globalEventKeys;
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        var _this4 = this;
+
+        this.prevGlobalEventKeys.forEach(function (key) {
+          return _this4.removeGlobalListener(key);
+        });
+      }
+    }, {
+      key: "addGlobalListener",
+      value: function addGlobalListener(key) {
+        var _this5 = this;
+
+        var boundListener = function (event) {
+          var listener = _this5.globalEvents[key];
+          return listener && listener(Events.emulateReactEvent(event));
+        };
 
-          _keys(obj).forEach(function (key) {
-            _this7[key] = obj[key];
-          });
+        this.boundGlobalEvents[key] = boundListener;
+        window.addEventListener(Events.getGlobalEventNameFromKey(key), boundListener);
+      }
+    }, {
+      key: "removeGlobalListener",
+      value: function removeGlobalListener(key) {
+        window.removeEventListener(Events.getGlobalEventNameFromKey(key), this.boundGlobalEvents[key]);
+      } // compile all state changes from own and parent state. Order doesn't matter, as any state
+      // state change should trigger a re-render
+
+    }, {
+      key: "getStateChanges",
+      value: function getStateChanges(props) {
+        var _this6 = this;
+
+        if (!this.hasEvents) {
+          return {};
         }
-      }, {
-        key: "getBaseProps",
-        value: function getBaseProps(props, getSharedEventState) {
-          getSharedEventState = getSharedEventState || this.getSharedEventState;
-          var sharedParentState = getSharedEventState("parent", "parent");
-          var parentState = this.getEventState("parent", "parent");
-
-          var baseParentProps = _defaults({}, parentState, sharedParentState);
 
-          var parentPropsList = baseParentProps.parentControlledProps;
-          var parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
+        var getState = function (key, type) {
+          var result = _defaults({}, _this6.getEventState(key, type), _this6.getSharedEventState(key, type));
 
-          var modifiedProps = _defaults({}, parentProps, props);
+          return _isEmpty(result) ? undefined : result;
+        };
 
-          return _isFunction(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
+        options = options || {};
+        var components = options.components || defaultComponents;
+        var stateChanges = components.map(function (component) {
+          if (!props.standalone && component.name === "parent") {
+            // don't check for changes on parent props for non-standalone components
+            return undefined;
+          } else {
+            return component.index !== undefined ? getState(component.index, component.name) : _this6.dataKeys.map(function (key) {
+              return getState(key, component.name);
+            }).filter(Boolean);
+          }
+        }).filter(Boolean);
+        return stateChanges;
+      }
+    }, {
+      key: "applyExternalMutations",
+      value: function applyExternalMutations(props, externalMutations) {
+        if (!_isEmpty(externalMutations)) {
+          var callbacks = props.externalEventMutations.reduce(function (memo, mutation) {
+            memo = _isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo;
+            return memo;
+          }, []);
+          var compiledCallbacks = callbacks.length ? function () {
+            callbacks.forEach(function (c) {
+              return c();
+            });
+          } : undefined;
+          this.setState(externalMutations, compiledCallbacks);
         }
-      }, {
-        key: "getAllEvents",
-        value: function getAllEvents(props) {
-          if (Array.isArray(this.componentEvents)) {
-            var _componentEvents;
+      }
+    }, {
+      key: "getCalculatedValues",
+      value: function getCalculatedValues(props) {
+        var sharedEvents = props.sharedEvents;
+        var components = WrappedComponent.expectedComponents;
+        var componentEvents = Events.getComponentEvents(props, components);
+        var getSharedEventState = sharedEvents && _isFunction(sharedEvents.getEventState) ? sharedEvents.getEventState : function () {
+          return undefined;
+        };
+        var baseProps = this.getBaseProps(props, getSharedEventState);
+
+        var dataKeys = _keys(baseProps).filter(function (key) {
+          return key !== "parent";
+        });
+
+        var hasEvents = props.events || props.sharedEvents || componentEvents;
+        var events = this.getAllEvents(props);
+        return {
+          componentEvents: componentEvents,
+          getSharedEventState: getSharedEventState,
+          baseProps: baseProps,
+          dataKeys: dataKeys,
+          hasEvents: hasEvents,
+          events: events
+        };
+      }
+    }, {
+      key: "getExternalMutations",
+      value: function getExternalMutations(props) {
+        var sharedEvents = props.sharedEvents,
+            externalEventMutations = props.externalEventMutations;
+        return _isEmpty(externalEventMutations) || sharedEvents ? undefined : Events.getExternalMutations(externalEventMutations, this.baseProps, this.state);
+      }
+    }, {
+      key: "cacheValues",
+      value: function cacheValues(obj) {
+        var _this7 = this;
+
+        _keys(obj).forEach(function (key) {
+          _this7[key] = obj[key];
+        });
+      }
+    }, {
+      key: "getBaseProps",
+      value: function getBaseProps(props, getSharedEventState) {
+        getSharedEventState = getSharedEventState || this.getSharedEventState;
+        var sharedParentState = getSharedEventState("parent", "parent");
+        var parentState = this.getEventState("parent", "parent");
 
-            return Array.isArray(props.events) ? (_componentEvents = this.componentEvents).concat.apply(_componentEvents, _toConsumableArray(props.events)) : this.componentEvents;
-          }
+        var baseParentProps = _defaults({}, parentState, sharedParentState);
 
-          return props.events;
-        }
-      }, {
-        key: "getComponentProps",
-        value: function getComponentProps(component, type, index) {
-          var name = this.props.name || WrappedComponent.role;
-          var key = this.dataKeys && this.dataKeys[index] || index;
-          var id = "".concat(name, "-").concat(type, "-").concat(key);
-          var baseProps = this.baseProps[key] && this.baseProps[key][type] || this.baseProps[key];
-
-          if (!baseProps && !this.hasEvents) {
-            return undefined;
-          }
+        var parentPropsList = baseParentProps.parentControlledProps;
+        var parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
 
-          if (this.hasEvents) {
-            var baseEvents = this.getEvents(this.props, type, key);
+        var modifiedProps = _defaults({}, parentProps, props);
 
-            var componentProps = _defaults({
-              index: index,
-              key: id
-            }, this.getEventState(key, type), this.getSharedEventState(key, type), component.props, baseProps, {
-              id: id
-            });
+        return _isFunction(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
+      }
+    }, {
+      key: "getAllEvents",
+      value: function getAllEvents(props) {
+        if (Array.isArray(this.componentEvents)) {
+          var _this$componentEvents;
 
-            var events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
+          return Array.isArray(props.events) ? (_this$componentEvents = this.componentEvents).concat.apply(_this$componentEvents, _toConsumableArray(props.events)) : this.componentEvents;
+        }
 
-            return _assign({}, componentProps, {
-              events: events
-            });
-          }
+        return props.events;
+      }
+    }, {
+      key: "getComponentProps",
+      value: function getComponentProps(component, type, index) {
+        var name = this.props.name || WrappedComponent.role;
+        var key = this.dataKeys && this.dataKeys[index] || index;
+        var id = "".concat(name, "-").concat(type, "-").concat(key);
+        var baseProps = this.baseProps[key] && this.baseProps[key][type] || this.baseProps[key];
+
+        if (!baseProps && !this.hasEvents) {
+          return undefined;
+        }
+
+        if (this.hasEvents) {
+          var baseEvents = this.getEvents(this.props, type, key);
 
-          return _defaults({
+          var componentProps = _defaults({
             index: index,
             key: id
-          }, component.props, baseProps, {
+          }, this.getEventState(key, type), this.getSharedEventState(key, type), component.props, baseProps, {
             id: id
           });
-        }
-      }, {
-        key: "renderContainer",
-        value: function renderContainer(component, children) {
-          var isContainer = component.type && component.type.role === "container";
-          var parentProps = isContainer ? this.getComponentProps(component, "parent", "parent") : {};
-
-          if (parentProps.events) {
-            this.globalEvents = Events.getGlobalEvents(parentProps.events);
-            parentProps.events = Events.omitGlobalEvents(parentProps.events);
-          }
 
-          return React.cloneElement(component, parentProps, children);
+          var events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
+
+          return _assign({}, componentProps, {
+            events: events
+          });
         }
-      }, {
-        key: "animateComponent",
-        value: function animateComponent(props, defaultAnimationWhitelist) {
-          var animationWhitelist = props.animate && props.animate.animationWhitelist ? props.animate.animationWhitelist : defaultAnimationWhitelist;
-          return React.createElement(VictoryTransition, {
-            animate: props.animate,
-            animationWhitelist: animationWhitelist
-          }, React.createElement(this.constructor, props));
-        } // Used by `VictoryLine` and `VictoryArea`
-
-      }, {
-        key: "renderContinuousData",
-        value: function renderContinuousData(props) {
-          var _this8 = this;
-
-          var dataComponent = props.dataComponent,
-              labelComponent = props.labelComponent,
-              groupComponent = props.groupComponent;
-
-          var dataKeys = _without(this.dataKeys, "all");
-
-          var labelComponents = dataKeys.reduce(function (memo, key) {
-            var labelProps = _this8.getComponentProps(labelComponent, "labels", key);
-
-            if (labelProps && labelProps.text !== undefined && labelProps.text !== null) {
-              memo = memo.concat(React.cloneElement(labelComponent, labelProps));
-            }
 
-            return memo;
-          }, []);
-          var dataProps = this.getComponentProps(dataComponent, "data", "all");
-          var children = [React.cloneElement(dataComponent, dataProps)].concat(_toConsumableArray(labelComponents));
-          return this.renderContainer(groupComponent, children);
+        return _defaults({
+          index: index,
+          key: id
+        }, component.props, baseProps, {
+          id: id
+        });
+      }
+    }, {
+      key: "renderContainer",
+      value: function renderContainer(component, children) {
+        var isContainer = component.type && component.type.role === "container";
+        var parentProps = isContainer ? this.getComponentProps(component, "parent", "parent") : {};
+
+        if (parentProps.events) {
+          this.globalEvents = Events.getGlobalEvents(parentProps.events);
+          parentProps.events = Events.omitGlobalEvents(parentProps.events);
         }
-      }, {
-        key: "renderData",
-        value: function renderData(props) {
-          var _this9 = this;
-
-          var shouldRenderDatum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : datumHasXandY;
-          var dataComponent = props.dataComponent,
-              labelComponent = props.labelComponent,
-              groupComponent = props.groupComponent;
-          var dataComponents = this.dataKeys.reduce(function (validDataComponents, _dataKey, index) {
-            var dataProps = _this9.getComponentProps(dataComponent, "data", index);
-
-            if (shouldRenderDatum(dataProps.datum)) {
-              validDataComponents.push(React.cloneElement(dataComponent, dataProps));
-            }
-
-            return validDataComponents;
-          }, []);
-          var labelComponents = this.dataKeys.map(function (_dataKey, index) {
-            var labelProps = _this9.getComponentProps(labelComponent, "labels", index);
 
-            if (labelProps.text !== undefined && labelProps.text !== null) {
-              return React.cloneElement(labelComponent, labelProps);
-            }
+        return /*#__PURE__*/React.cloneElement(component, parentProps, children);
+      }
+    }, {
+      key: "animateComponent",
+      value: function animateComponent(props, defaultAnimationWhitelist) {
+        var animationWhitelist = props.animate && props.animate.animationWhitelist ? props.animate.animationWhitelist : defaultAnimationWhitelist;
+        return /*#__PURE__*/React.createElement(VictoryTransition, {
+          animate: props.animate,
+          animationWhitelist: animationWhitelist
+        }, /*#__PURE__*/React.createElement(this.constructor, props));
+      } // Used by `VictoryLine` and `VictoryArea`
+
+    }, {
+      key: "renderContinuousData",
+      value: function renderContinuousData(props) {
+        var _this8 = this;
+
+        var dataComponent = props.dataComponent,
+            labelComponent = props.labelComponent,
+            groupComponent = props.groupComponent;
+
+        var dataKeys = _without(this.dataKeys, "all");
+
+        var labelComponents = dataKeys.reduce(function (memo, key) {
+          var labelProps = _this8.getComponentProps(labelComponent, "labels", key);
+
+          if (labelProps && labelProps.text !== undefined && labelProps.text !== null) {
+            memo = memo.concat( /*#__PURE__*/React.cloneElement(labelComponent, labelProps));
+          }
 
-            return undefined;
-          }).filter(Boolean);
+          return memo;
+        }, []);
+        var dataProps = this.getComponentProps(dataComponent, "data", "all");
+        var children = [/*#__PURE__*/React.cloneElement(dataComponent, dataProps)].concat(_toConsumableArray(labelComponents));
+        return this.renderContainer(groupComponent, children);
+      }
+    }, {
+      key: "renderData",
+      value: function renderData(props) {
+        var _this9 = this;
+
+        var shouldRenderDatum = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : datumHasXandY;
+        var dataComponent = props.dataComponent,
+            labelComponent = props.labelComponent,
+            groupComponent = props.groupComponent;
+        var userProps = UserProps.getSafeUserProps(props);
+        var dataComponents = this.dataKeys.reduce(function (validDataComponents, _dataKey, index) {
+          var dataProps = _this9.getComponentProps(dataComponent, "data", index);
+
+          if (shouldRenderDatum(dataProps.datum)) {
+            validDataComponents.push( /*#__PURE__*/React.cloneElement(dataComponent, dataProps));
+          }
 
-          var children = _toConsumableArray(dataComponents).concat(_toConsumableArray(labelComponents));
+          return validDataComponents;
+        }, []);
+        var labelComponents = this.dataKeys.map(function (_dataKey, index) {
+          var labelProps = _this9.getComponentProps(labelComponent, "labels", index);
 
-          return this.renderContainer(groupComponent, children);
-        }
-      }]);
+          if (labelProps.text !== undefined && labelProps.text !== null) {
+            return /*#__PURE__*/React.cloneElement(labelComponent, labelProps);
+          }
+
+          return undefined;
+        }).filter(Boolean);
+        var children = [].concat(_toConsumableArray(dataComponents), _toConsumableArray(labelComponents));
+        var group = /*#__PURE__*/React.cloneElement(groupComponent, userProps, children);
+        return this.renderContainer(group, children);
+      }
+    }]);
 
-      return addEvents;
-    }(WrappedComponent)
-  );
+    return addEvents;
+  }(WrappedComponent);
 });