victory-shared-events 36.9.2 → 37.0.0

package/lib/victory-shared-events.js

@@ -4,363 +4,203 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VictorySharedEvents = void 0;
-
 var _fromPairs2 = _interopRequireDefault(require("lodash/fromPairs"));
-
 var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
-
 var _defaults2 = _interopRequireDefault(require("lodash/defaults"));
-
 var _react = _interopRequireDefault(require("react"));
-
 var _victoryCore = require("victory-core");
-
 var _reactFastCompare = _interopRequireDefault(require("react-fast-compare"));
-
 var _jsonStringifySafe = _interopRequireDefault(require("json-stringify-safe"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-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 _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); 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 _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; }
-
-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 VictorySharedEvents = /*#__PURE__*/function (_React$Component) {
-  _inherits(VictorySharedEvents, _React$Component);
-
-  var _super = _createSuper(VictorySharedEvents);
-
-  function VictorySharedEvents(props) {
-    var _this;
-
-    _classCallCheck(this, VictorySharedEvents);
-
-    _this = _super.call(this, props);
-    _this.getScopedEvents = void 0;
-    _this.getEventState = void 0;
-    _this.baseProps = void 0;
-    _this.sharedEventsCache = void 0;
-    _this.globalEvents = void 0;
-    _this.prevGlobalEventKeys = void 0;
-    _this.boundGlobalEvents = void 0;
-    _this.getScopedEvents = _victoryCore.Events.getScopedEvents.bind(_assertThisInitialized(_this));
-    _this.getEventState = _victoryCore.Events.getEventState.bind(_assertThisInitialized(_this));
-    _this.state = _this.state || {};
-    _this.sharedEventsCache = {};
-    _this.globalEvents = {};
-    _this.prevGlobalEventKeys = [];
-    _this.boundGlobalEvents = {};
-    _this.baseProps = _this.getBaseProps(props);
-    return _this;
+// DISCLAIMER:
+// This file is not currently tested, and it is first on the list of files
+// to refactor in our current refactoring effort. Please do not make changes
+// to this file without manual testing and/or refactoring and adding tests.
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+class VictorySharedEvents extends _react.default.Component {
+  static displayName = "VictorySharedEvents";
+  static role = "shared-event-wrapper";
+  static contextType = _victoryCore.TimerContext;
+  static defaultProps = {
+    groupComponent: /*#__PURE__*/_react.default.createElement("g", null)
+  };
+  constructor(props) {
+    super(props);
+    this.getScopedEvents = _victoryCore.Events.getScopedEvents.bind(this);
+    this.getEventState = _victoryCore.Events.getEventState.bind(this);
+    this.state = this.state || {};
+    this.sharedEventsCache = {};
+    this.globalEvents = {};
+    this.prevGlobalEventKeys = [];
+    this.boundGlobalEvents = {};
+    this.baseProps = this.getBaseProps(props);
   }
-
-  _createClass(VictorySharedEvents, [{
-    key: "shouldComponentUpdate",
-    value: function shouldComponentUpdate(nextProps) {
-      if (!(0, _reactFastCompare.default)(this.props, nextProps)) {
-        this.baseProps = this.getBaseProps(nextProps);
-        var externalMutations = this.getExternalMutations(nextProps, this.baseProps);
-        this.applyExternalMutations(nextProps, externalMutations);
-      }
-
-      return true;
-    }
-  }, {
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var _this2 = this;
-
-      var globalEventKeys = Object.keys(this.globalEvents);
-      globalEventKeys.forEach(function (key) {
-        return _this2.addGlobalListener(key);
-      });
-      this.prevGlobalEventKeys = globalEventKeys;
+  shouldComponentUpdate(nextProps) {
+    if (!(0, _reactFastCompare.default)(this.props, nextProps)) {
+      this.baseProps = this.getBaseProps(nextProps);
+      const externalMutations = this.getExternalMutations(nextProps, this.baseProps);
+      this.applyExternalMutations(nextProps, externalMutations);
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate() {
-      var _this3 = this;
-
-      var globalEventKeys = Object.keys(this.globalEvents);
-
-      var removedGlobalEventKeys = _victoryCore.Collection.difference(this.prevGlobalEventKeys, globalEventKeys);
-
-      removedGlobalEventKeys.forEach(function (key) {
-        return _this3.removeGlobalListener(key);
-      });
-
-      var addedGlobalEventKeys = _victoryCore.Collection.difference(globalEventKeys, this.prevGlobalEventKeys);
-
-      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);
-      });
+    return true;
+  }
+  componentDidMount() {
+    const globalEventKeys = Object.keys(this.globalEvents);
+    globalEventKeys.forEach(key => this.addGlobalListener(key));
+    this.prevGlobalEventKeys = globalEventKeys;
+  }
+  componentDidUpdate() {
+    const globalEventKeys = Object.keys(this.globalEvents);
+    const removedGlobalEventKeys = _victoryCore.Collection.difference(this.prevGlobalEventKeys, globalEventKeys);
+    removedGlobalEventKeys.forEach(key => this.removeGlobalListener(key));
+    const addedGlobalEventKeys = _victoryCore.Collection.difference(globalEventKeys, this.prevGlobalEventKeys);
+    addedGlobalEventKeys.forEach(key => this.addGlobalListener(key));
+    this.prevGlobalEventKeys = globalEventKeys;
+  }
+  componentWillUnmount() {
+    this.prevGlobalEventKeys.forEach(key => this.removeGlobalListener(key));
+  }
+  addGlobalListener(key) {
+    const boundListener = event => {
+      const listener = this.globalEvents[key];
+      return listener && listener(_victoryCore.Events.emulateReactEvent(event));
+    };
+    this.boundGlobalEvents[key] = boundListener;
+    window.addEventListener(_victoryCore.Events.getGlobalEventNameFromKey(key), boundListener);
+  }
+  removeGlobalListener(key) {
+    window.removeEventListener(_victoryCore.Events.getGlobalEventNameFromKey(key), this.boundGlobalEvents[key]);
+  }
+  getAllEvents(props) {
+    const components = ["container", "groupComponent"];
+    const componentEvents = _victoryCore.Events.getComponentEvents(props, components);
+    if (Array.isArray(componentEvents)) {
+      return Array.isArray(props.events) ? componentEvents.concat(...props.events) : componentEvents;
     }
-  }, {
-    key: "addGlobalListener",
-    value: function addGlobalListener(key) {
-      var _this5 = this;
-
-      var boundListener = function (event) {
-        var listener = _this5.globalEvents[key];
-        return listener && listener(_victoryCore.Events.emulateReactEvent(event));
-      };
-
-      this.boundGlobalEvents[key] = boundListener;
-      window.addEventListener(_victoryCore.Events.getGlobalEventNameFromKey(key), boundListener);
+    return props.events;
+  }
+  applyExternalMutations(props, externalMutations) {
+    if (!(0, _isEmpty2.default)(externalMutations)) {
+      const callbacks = props.externalEventMutations.reduce((memo, mutation) => _victoryCore.Helpers.isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo, []);
+      const compiledCallbacks = callbacks.length ? () => {
+        callbacks.forEach(c => c());
+      } : undefined;
+      this.setState(externalMutations, compiledCallbacks);
     }
-  }, {
-    key: "removeGlobalListener",
-    value: function removeGlobalListener(key) {
-      window.removeEventListener(_victoryCore.Events.getGlobalEventNameFromKey(key), this.boundGlobalEvents[key]);
+  }
+  getExternalMutations(props, baseProps) {
+    return !(0, _isEmpty2.default)(props.externalEventMutations) ? _victoryCore.Events.getExternalMutationsWithChildren(props.externalEventMutations, baseProps, this.state, Object.keys(baseProps)) : undefined;
+  }
+  cacheSharedEvents(name, sharedEvents, cacheValues) {
+    this.sharedEventsCache[name] = [sharedEvents, cacheValues];
+  }
+  getCachedSharedEvents(name, cacheValues) {
+    const [sharedEvents, prevCacheValues] = this.sharedEventsCache[name] || [];
+    if (sharedEvents && (0, _reactFastCompare.default)(cacheValues, prevCacheValues)) {
+      return sharedEvents;
     }
-  }, {
-    key: "getAllEvents",
-    value: function getAllEvents(props) {
-      var components = ["container", "groupComponent"];
-
-      var componentEvents = _victoryCore.Events.getComponentEvents(props, components);
-
-      if (Array.isArray(componentEvents)) {
-        return Array.isArray(props.events) ? componentEvents.concat.apply(componentEvents, _toConsumableArray(props.events)) : componentEvents;
+    return undefined;
+  }
+  getBaseProps(props) {
+    const {
+      container
+    } = props;
+    const children = _react.default.Children.toArray(this.props.children);
+    const childBaseProps = this.getBasePropsFromChildren(children);
+    const parentBaseProps = container ? container.props : {};
+    return Object.assign({}, childBaseProps, {
+      parent: parentBaseProps
+    });
+  }
+  getBasePropsFromChildren(childComponents) {
+    const iteratee = (child, childName) => {
+      if (child.type && _victoryCore.Helpers.isFunction(child.type.getBaseProps)) {
+        const baseProps = child.props && child.type.getBaseProps(child.props);
+        return baseProps ? [[childName, baseProps]] : null;
       }
-
-      return props.events;
-    }
-  }, {
-    key: "applyExternalMutations",
-    value: function applyExternalMutations(props, externalMutations) {
-      if (!(0, _isEmpty2.default)(externalMutations)) {
-        var callbacks = props.externalEventMutations.reduce(function (memo, mutation) {
-          return _victoryCore.Helpers.isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo;
-        }, []);
-        var compiledCallbacks = callbacks.length ? function () {
-          callbacks.forEach(function (c) {
-            return c();
+      return null;
+    };
+    const baseProps = _victoryCore.Helpers.reduceChildren(childComponents, iteratee);
+    return (0, _fromPairs2.default)(baseProps);
+  }
+  getNewChildren(props, baseProps) {
+    const {
+      events,
+      eventKey
+    } = props;
+    const alterChildren = (children, childNames) => {
+      return children.reduce((memo, child, index) => {
+        if (child.props.children) {
+          const newChildren = _react.default.Children.toArray(child.props.children);
+          const names = childNames.slice(index, index + newChildren.length);
+          const results = /*#__PURE__*/_react.default.cloneElement(child, child.props, alterChildren(newChildren, names));
+          return memo.concat(results);
+        } else if (childNames[index] !== "parent" && child.type && _victoryCore.Helpers.isFunction(child.type.getBaseProps)) {
+          const name = child.props.name || childNames[index];
+          const childEvents = Array.isArray(events) && events.filter(event => {
+            if (event.target === "parent") {
+              return false;
+            }
+            return Array.isArray(event.childName) ? event.childName.indexOf(name) > -1 : event.childName === name || event.childName === "all";
           });
-        } : undefined;
-        this.setState(externalMutations, compiledCallbacks);
-      }
-    }
-  }, {
-    key: "getExternalMutations",
-    value: function getExternalMutations(props, baseProps) {
-      return !(0, _isEmpty2.default)(props.externalEventMutations) ? _victoryCore.Events.getExternalMutationsWithChildren(props.externalEventMutations, baseProps, this.state, Object.keys(baseProps)) : undefined;
-    }
-  }, {
-    key: "cacheSharedEvents",
-    value: function cacheSharedEvents(name, sharedEvents, cacheValues) {
-      this.sharedEventsCache[name] = [sharedEvents, cacheValues];
-    }
-  }, {
-    key: "getCachedSharedEvents",
-    value: function getCachedSharedEvents(name, cacheValues) {
-      var _ref = this.sharedEventsCache[name] || [],
-          _ref2 = _slicedToArray(_ref, 2),
-          sharedEvents = _ref2[0],
-          prevCacheValues = _ref2[1];
-
-      if (sharedEvents && (0, _reactFastCompare.default)(cacheValues, prevCacheValues)) {
-        return sharedEvents;
-      }
-
-      return undefined;
-    }
-  }, {
-    key: "getBaseProps",
-    value: function getBaseProps(props) {
-      var container = props.container;
-
-      var children = _react.default.Children.toArray(this.props.children);
-
-      var childBaseProps = this.getBasePropsFromChildren(children);
-      var parentBaseProps = container ? container.props : {};
-      return Object.assign({}, childBaseProps, {
-        parent: parentBaseProps
-      });
-    }
-  }, {
-    key: "getBasePropsFromChildren",
-    value: function getBasePropsFromChildren(childComponents) {
-      var iteratee = function (child, childName) {
-        if (child.type && _victoryCore.Helpers.isFunction(child.type.getBaseProps)) {
-          var _baseProps = child.props && child.type.getBaseProps(child.props);
-
-          return _baseProps ? [[childName, _baseProps]] : null;
+          const sharedEventsCacheValues = [name, baseProps, childEvents, (0, _jsonStringifySafe.default)(this.state[name])];
+          const sharedEvents = this.getCachedSharedEvents(name, sharedEventsCacheValues) || {
+            events: childEvents,
+            // partially apply child name and baseProps,
+            getEvents: (evts, target) => this.getScopedEvents(evts, target, name, baseProps),
+            // partially apply child name
+            getEventState: (key, target) => this.getEventState(key, target, name)
+          };
+          this.cacheSharedEvents(name, sharedEvents, sharedEventsCacheValues);
+          return memo.concat( /*#__PURE__*/_react.default.cloneElement(child, Object.assign({
+            key: `events-${name}`,
+            sharedEvents,
+            eventKey,
+            name
+          }, child.props)));
         }
-
-        return null;
-      };
-
-      var baseProps = _victoryCore.Helpers.reduceChildren(childComponents, iteratee);
-
-      return (0, _fromPairs2.default)(baseProps);
-    }
-  }, {
-    key: "getNewChildren",
-    value: function getNewChildren(props, baseProps) {
-      var _this6 = this;
-
-      var events = props.events,
-          eventKey = props.eventKey;
-
-      var alterChildren = function (children, childNames) {
-        return children.reduce(function (memo, child, index) {
-          if (child.props.children) {
-            var newChildren = _react.default.Children.toArray(child.props.children);
-
-            var names = childNames.slice(index, index + newChildren.length);
-
-            var results = /*#__PURE__*/_react.default.cloneElement(child, child.props, alterChildren(newChildren, names));
-
-            return memo.concat(results);
-          } else if (childNames[index] !== "parent" && child.type && _victoryCore.Helpers.isFunction(child.type.getBaseProps)) {
-            var name = child.props.name || childNames[index];
-            var childEvents = Array.isArray(events) && events.filter(function (event) {
-              if (event.target === "parent") {
-                return false;
-              }
-
-              return Array.isArray(event.childName) ? event.childName.indexOf(name) > -1 : event.childName === name || event.childName === "all";
-            });
-            var sharedEventsCacheValues = [name, baseProps, childEvents, (0, _jsonStringifySafe.default)(_this6.state[name])];
-            var sharedEvents = _this6.getCachedSharedEvents(name, sharedEventsCacheValues) || {
-              events: childEvents,
-              // partially apply child name and baseProps,
-              getEvents: function (evts, target) {
-                return _this6.getScopedEvents(evts, target, name, baseProps);
-              },
-              // partially apply child name
-              getEventState: function (key, target) {
-                return _this6.getEventState(key, target, name);
-              }
-            };
-
-            _this6.cacheSharedEvents(name, sharedEvents, sharedEventsCacheValues);
-
-            return memo.concat( /*#__PURE__*/_react.default.cloneElement(child, Object.assign({
-              key: "events-".concat(name),
-              sharedEvents: sharedEvents,
-              eventKey: eventKey,
-              name: name
-            }, child.props)));
-          }
-
-          return memo.concat(child);
-        }, []);
-      };
-
-      var childNames = Object.keys(baseProps);
-
-      var childComponents = _react.default.Children.toArray(props.children);
-
-      return alterChildren(childComponents, childNames);
-    }
-  }, {
-    key: "getContainer",
-    value: function getContainer(props, baseProps, events) {
-      var _this7 = this;
-
-      var children = this.getNewChildren(props, baseProps);
-      var parents = Array.isArray(events) ? events.filter(function (event) {
-        return event.target === "parent";
-      }) : [];
-      var sharedEvents = parents.length > 0 ? {
-        events: parents,
-        // partially apply childName (null) and baseProps,
-        getEvents: function (evts, target) {
-          return _this7.getScopedEvents(evts, target, null, baseProps);
-        },
-        getEventState: this.getEventState
-      } : null;
-      var container = props.container || props.groupComponent;
-      var role = container.type && container.type.role;
-      var containerProps = container.props || {};
-
-      var boundGetEvents = _victoryCore.Events.getEvents.bind(this);
-
-      var parentEvents = sharedEvents && boundGetEvents({
-        sharedEvents: sharedEvents
-      }, "parent");
-      var parentProps = (0, _defaults2.default)({}, this.getEventState("parent", "parent"), containerProps, baseProps.parent, {
-        children: children
-      });
-      var containerEvents = (0, _defaults2.default)({}, _victoryCore.Events.getPartialEvents(parentEvents, "parent", parentProps), containerProps.events);
-      this.globalEvents = _victoryCore.Events.getGlobalEvents(containerEvents);
-
-      var localEvents = _victoryCore.Events.omitGlobalEvents(containerEvents);
-
-      return role === "container" ? /*#__PURE__*/_react.default.cloneElement(container, Object.assign({}, parentProps, {
-        events: localEvents
-      })) : /*#__PURE__*/_react.default.cloneElement(container, localEvents, children);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var events = this.getAllEvents(this.props);
-
-      if (events) {
-        return this.getContainer(this.props, this.baseProps, events);
-      }
-
-      return /*#__PURE__*/_react.default.cloneElement(this.props.container, {
-        children: this.props.children
-      });
-    }
-  }]);
-
-  return VictorySharedEvents;
-}(_react.default.Component);
-
-exports.VictorySharedEvents = VictorySharedEvents;
-VictorySharedEvents.displayName = "VictorySharedEvents";
-VictorySharedEvents.role = "shared-event-wrapper";
-VictorySharedEvents.contextType = _victoryCore.TimerContext;
-VictorySharedEvents.defaultProps = {
-  groupComponent: /*#__PURE__*/_react.default.createElement("g", null)
-};
+        return memo.concat(child);
+      }, []);
+    };
+    const childNames = Object.keys(baseProps);
+    const childComponents = _react.default.Children.toArray(props.children);
+    return alterChildren(childComponents, childNames);
+  }
+  getContainer(props, baseProps, events) {
+    const children = this.getNewChildren(props, baseProps);
+    const parents = Array.isArray(events) ? events.filter(event => event.target === "parent") : [];
+    const sharedEvents = parents.length > 0 ? {
+      events: parents,
+      // partially apply childName (null) and baseProps,
+      getEvents: (evts, target) => this.getScopedEvents(evts, target, null, baseProps),
+      getEventState: this.getEventState
+    } : null;
+    const container = props.container || props.groupComponent;
+    const role = container.type && container.type.role;
+    const containerProps = container.props || {};
+    const boundGetEvents = _victoryCore.Events.getEvents.bind(this);
+    const parentEvents = sharedEvents && boundGetEvents({
+      sharedEvents
+    }, "parent");
+    const parentProps = (0, _defaults2.default)({}, this.getEventState("parent", "parent"), containerProps, baseProps.parent, {
+      children
+    });
+    const containerEvents = (0, _defaults2.default)({}, _victoryCore.Events.getPartialEvents(parentEvents, "parent", parentProps), containerProps.events);
+    this.globalEvents = _victoryCore.Events.getGlobalEvents(containerEvents);
+    const localEvents = _victoryCore.Events.omitGlobalEvents(containerEvents);
+    return role === "container" ? /*#__PURE__*/_react.default.cloneElement(container, Object.assign({}, parentProps, {
+      events: localEvents
+    })) : /*#__PURE__*/_react.default.cloneElement(container, localEvents, children);
+  }
+  render() {
+    const events = this.getAllEvents(this.props);
+    if (events) {
+      return this.getContainer(this.props, this.baseProps, events);
+    }
+    return /*#__PURE__*/_react.default.cloneElement(this.props.container, {
+      children: this.props.children
+    });
+  }
+}
+exports.VictorySharedEvents = VictorySharedEvents;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-shared-events",
-  "version": "36.9.2",
+  "version": "37.0.0",
   "description": "Shared Event Helper for Victory",
   "keywords": [
     "data visualization",
@@ -23,7 +23,7 @@
     "json-stringify-safe": "^5.0.1",
     "lodash": "^4.17.19",
     "react-fast-compare": "^3.2.0",
-    "victory-core": "^36.9.2"
+    "victory-core": "^37.0.0"
   },
   "peerDependencies": {
     "react": ">=16.6.0"