victory-core 36.9.2 → 37.0.0

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

@@ -1,55 +1,24 @@
 import _pick from "lodash/pick";
 import _isEmpty from "lodash/isEmpty";
 import _defaults from "lodash/defaults";
-
-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); }
-
 import React from "react";
 import isEqual from "react-fast-compare";
 import { VictoryTransition } from "../victory-transition/victory-transition";
 import { difference } from "./collection";
 import * as Events from "./events";
-import { isFunction, isNil } from "./helpers"; // DISCLAIMER:
+import { isFunction, isNil } from "./helpers";
+
+// 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.
 
-var datumHasXandY = function (datum) {
+const datumHasXandY = datum => {
   return !isNil(datum._x) && !isNil(datum._y);
-}; //  used for checking state changes. Expected components can be passed in via options
-
+};
 
-var defaultComponents = [{
+//  used for checking state changes. Expected components can be passed in via options
+const defaultComponents = [{
   name: "parent",
   index: "parent"
 }, {
@@ -57,361 +26,281 @@ var defaultComponents = [{
 }, {
   name: "labels"
 }];
-export function addEvents(WrappedComponent) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
+/**
+ * These methods will be implemented by the Mixin,
+ * and are accessible to the Wrapped Component.
+ *
+ * To make your Wrapped Component type-safe, use "interface merging" like so:
+ * @example
+ *    interface MyComponent extends EventsMixinClass<MyProps> {}
+ *    class MyComponent extends React.Component<MyProps> { ... }
+ */
+
+/**
+ * These fields are calculated by the Mixin
+ */
+
+/**
+ * These are the common roles that we care about internally.
+ */
+
+/**
+ * A component can have any "role",
+ * but there are certain ones that we actually care about internally
+ */
+
+/**
+ * Static component fields used by Victory for common behavior
+ */
+
+/**
+ * This represents the class itself, including static fields
+ */
+
+export function addEvents(WrappedComponent, options) {
+  if (options === void 0) {
+    options = {};
+  } // eslint-disable-next-line @typescript-eslint/no-empty-interface
   // @ts-expect-error "TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'."
-  var AddEventsMixin = /*#__PURE__*/function (_WrappedComponent) {
-    _inherits(AddEventsMixin, _WrappedComponent);
-
-    var _super = _createSuper(AddEventsMixin);
-
-    function AddEventsMixin(props) {
-      var _this;
-
-      _classCallCheck(this, AddEventsMixin);
-
-      _this = _super.call(this, props);
-      _this.state = {};
-      _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
-      _this.getScopedEvents = Events.getScopedEvents.bind(_assertThisInitialized(_this));
-
-      _this.getEvents = function (p, target, eventKey) {
-        return Events.getEvents.call(_assertThisInitialized(_this), p, target, eventKey, _this.getScopedEvents);
-      };
-
-      _this.externalMutations = _this.getExternalMutations(_this.props);
-      _this.calculatedState = _this.getStateChanges(_this.props);
-      _this.globalEvents = {};
-      _this.prevGlobalEventKeys = [];
-      _this.boundGlobalEvents = {};
-
-      _this.cacheValues(_this.getCalculatedValues(props));
-
-      return _this;
+  class AddEventsMixin extends WrappedComponent {
+    constructor(props) {
+      super(props);
+      this.cacheValues(this.getCalculatedValues(props));
     }
-
-    _createClass(AddEventsMixin, [{
-      key: "shouldComponentUpdate",
-      value: function shouldComponentUpdate(nextProps) {
-        var externalMutations = this.getExternalMutations(nextProps); // @ts-expect-error "Property 'animating' does not exist on type EventMixinCommonProps"
-
-        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;
-        }
-
-        var calculatedState = this.getStateChanges(nextProps);
-
-        if (!isEqual(this.calculatedState, calculatedState)) {
-          this.cacheValues(this.getCalculatedValues(nextProps));
-          return true;
-        }
-
-        if (!isEqual(this.props, nextProps)) {
-          this.cacheValues(this.getCalculatedValues(nextProps));
-          return true;
-        }
-
-        return false;
-      }
-    }, {
-      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;
-      }
-    }, {
-      key: "componentDidUpdate",
-      value: function componentDidUpdate(prevProps) {
-        var _this3 = this;
-
-        var calculatedState = this.getStateChanges(prevProps);
-        this.calculatedState = calculatedState;
-        var globalEventKeys = Object.keys(this.globalEvents);
-        var removedGlobalEventKeys = difference(this.prevGlobalEventKeys, globalEventKeys);
-        removedGlobalEventKeys.forEach(function (key) {
-          return _this3.removeGlobalListener(key);
-        });
-        var addedGlobalEventKeys = difference(globalEventKeys, this.prevGlobalEventKeys);
-        addedGlobalEventKeys.forEach(function (key) {
-          return _this3.addGlobalListener(key);
-        });
-        this.prevGlobalEventKeys = globalEventKeys;
+    state = {};
+    getEventState = Events.getEventState.bind(this);
+    getScopedEvents = Events.getScopedEvents.bind(this);
+    getEvents = (p, target, eventKey) => {
+      return Events.getEvents.call(this, p, target, eventKey, this.getScopedEvents);
+    };
+    externalMutations = this.getExternalMutations(this.props);
+    calculatedState = this.getStateChanges(this.props);
+    globalEvents = {};
+    prevGlobalEventKeys = [];
+    boundGlobalEvents = {};
+    shouldComponentUpdate(nextProps) {
+      const externalMutations = this.getExternalMutations(nextProps);
+      // @ts-expect-error "Property 'animating' does not exist on type EventMixinCommonProps"
+      const animating = this.props.animating || this.props.animate;
+      const newMutation = !isEqual(externalMutations, this.externalMutations);
+      if (animating || newMutation) {
+        this.cacheValues(this.getCalculatedValues(nextProps));
+        this.externalMutations = externalMutations;
+        this.applyExternalMutations(nextProps, externalMutations);
+        return true;
       }
-    }, {
-      key: "componentWillUnmount",
-      value: function componentWillUnmount() {
-        var _this4 = this;
-
-        this.prevGlobalEventKeys.forEach(function (key) {
-          return _this4.removeGlobalListener(key);
-        });
+      const calculatedState = this.getStateChanges(nextProps);
+      if (!isEqual(this.calculatedState, calculatedState)) {
+        this.cacheValues(this.getCalculatedValues(nextProps));
+        return true;
       }
-    }, {
-      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);
+      if (!isEqual(this.props, nextProps)) {
+        this.cacheValues(this.getCalculatedValues(nextProps));
+        return true;
       }
-    }, {
-      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;
-        };
-
-        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;
-          }
+      return false;
+    }
+    componentDidMount() {
+      const globalEventKeys = Object.keys(this.globalEvents);
+      globalEventKeys.forEach(key => this.addGlobalListener(key));
+      this.prevGlobalEventKeys = globalEventKeys;
+    }
+    componentDidUpdate(prevProps) {
+      const calculatedState = this.getStateChanges(prevProps);
+      this.calculatedState = calculatedState;
+      const globalEventKeys = Object.keys(this.globalEvents);
+      const removedGlobalEventKeys = difference(this.prevGlobalEventKeys, globalEventKeys);
+      removedGlobalEventKeys.forEach(key => this.removeGlobalListener(key));
+      const addedGlobalEventKeys = 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(Events.emulateReactEvent(event));
+      };
+      this.boundGlobalEvents[key] = boundListener;
+      window.addEventListener(Events.getGlobalEventNameFromKey(key), boundListener);
+    }
+    removeGlobalListener(key) {
+      window.removeEventListener(Events.getGlobalEventNameFromKey(key), this.boundGlobalEvents[key]);
+    }
 
-          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;
+    // compile all state changes from own and parent state. Order doesn't matter, as any state
+    // state change should trigger a re-render
+    getStateChanges(props) {
+      if (!this.hasEvents) {
+        return {};
       }
-    }, {
-      key: "applyExternalMutations",
-      value: function applyExternalMutations(props, externalMutations) {
-        if (!_isEmpty(externalMutations)) {
-          var callbacks = props.externalEventMutations.reduce(function (memo, mutation) {
-            return isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo;
-          }, []);
-          var compiledCallbacks = callbacks.length ? function () {
-            callbacks.forEach(function (c) {
-              return c();
-            });
-          } : undefined;
-          this.setState(externalMutations, compiledCallbacks);
+      const getState = (key, type) => {
+        const result = _defaults({}, this.getEventState(key, type), this.getSharedEventState(key, type));
+        return _isEmpty(result) ? undefined : result;
+      };
+      const components = options.components || defaultComponents;
+      const stateChanges = components.map(component => {
+        if (!props.standalone && component.name === "parent") {
+          // don't check for changes on parent props for non-standalone components
+          return undefined;
         }
+        return component.index !== undefined ? getState(component.index, component.name) : this.dataKeys.map(key => getState(key, component.name)).filter(Boolean);
+      }).filter(Boolean);
+      return stateChanges;
+    }
+    applyExternalMutations(props, externalMutations) {
+      if (!_isEmpty(externalMutations)) {
+        const callbacks = props.externalEventMutations.reduce((memo, mutation) => isFunction(mutation.callback) ? memo.concat(mutation.callback) : memo, []);
+        const compiledCallbacks = callbacks.length ? () => {
+          callbacks.forEach(c => 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);
-        var dataKeys = Object.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
-        };
+    }
+    getCalculatedValues(props) {
+      const {
+        sharedEvents
+      } = props;
+      const components = WrappedComponent.expectedComponents;
+      const componentEvents = Events.getComponentEvents(props, components);
+      const getSharedEventState = sharedEvents && isFunction(sharedEvents.getEventState) ? sharedEvents.getEventState : () => undefined;
+      const baseProps = this.getBaseProps(props, getSharedEventState);
+      const dataKeys = Object.keys(baseProps).filter(key => key !== "parent");
+      const hasEvents = props.events || props.sharedEvents || componentEvents;
+      const events = this.getAllEvents(props);
+      return {
+        componentEvents,
+        getSharedEventState,
+        baseProps,
+        dataKeys,
+        hasEvents,
+        events
+      };
+    }
+    getExternalMutations(props) {
+      const {
+        sharedEvents,
+        externalEventMutations
+      } = props;
+      return _isEmpty(externalEventMutations) || sharedEvents ? undefined : Events.getExternalMutations(externalEventMutations, this.baseProps, this.state);
+    }
+    cacheValues(obj) {
+      Object.keys(obj).forEach(key => {
+        this[key] = obj[key];
+      });
+    }
+    getBaseProps(props, getSharedEventState) {
+      const getSharedEventStateFunction = getSharedEventState || this.getSharedEventState.bind(this);
+      const sharedParentState = getSharedEventStateFunction("parent", "parent");
+      const parentState = this.getEventState("parent", "parent");
+      const baseParentProps = _defaults({}, parentState, sharedParentState);
+      const parentPropsList = baseParentProps.parentControlledProps;
+      const parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
+      const modifiedProps = _defaults({}, parentProps, props);
+      return typeof WrappedComponent.getBaseProps === "function" ? WrappedComponent.getBaseProps(modifiedProps) : {};
+    }
+    getAllEvents(props) {
+      if (Array.isArray(this.componentEvents)) {
+        return Array.isArray(props.events) ? this.componentEvents.concat(...props.events) : this.componentEvents;
       }
-    }, {
-      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);
+      return props.events;
+    }
+    getComponentProps(component, type, index) {
+      const name = this.props.name || WrappedComponent.role;
+      const key = this.dataKeys && this.dataKeys[index] || index;
+      const id = `${name}-${type}-${key}`;
+      const baseProps = this.baseProps[key] && this.baseProps[key][type] || this.baseProps[key];
+      if (!baseProps && !this.hasEvents) {
+        return undefined;
       }
-    }, {
-      key: "cacheValues",
-      value: function cacheValues(obj) {
-        var _this7 = this;
-
-        Object.keys(obj).forEach(function (key) {
-          _this7[key] = obj[key];
+      const currentProps = component && typeof component === "object" && "props" in component ? component.props : undefined;
+      if (this.hasEvents) {
+        const baseEvents = this.getEvents(this.props, type, key);
+        const componentProps = _defaults({
+          index,
+          key: id
+        }, this.getEventState(key, type), this.getSharedEventState(key, type), currentProps, baseProps, {
+          id
+        });
+        const events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
+        return Object.assign({}, componentProps, {
+          events
         });
       }
-    }, {
-      key: "getBaseProps",
-      value: function getBaseProps(props, getSharedEventState) {
-        var getSharedEventStateFunction = getSharedEventState || this.getSharedEventState.bind(this);
-        var sharedParentState = getSharedEventStateFunction("parent", "parent");
-        var parentState = this.getEventState("parent", "parent");
-
-        var baseParentProps = _defaults({}, parentState, sharedParentState);
-
-        var parentPropsList = baseParentProps.parentControlledProps;
-        var parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
-
-        var modifiedProps = _defaults({}, parentProps, props);
-
-        return typeof WrappedComponent.getBaseProps === "function" ? WrappedComponent.getBaseProps(modifiedProps) : {};
+      return _defaults({
+        index,
+        key: id
+      }, currentProps, baseProps, {
+        id
+      });
+    }
+    renderContainer(component, children) {
+      const isContainer = component.type && component.type.role === "container";
+      const parentProps = isContainer ? this.getComponentProps(component, "parent", "parent") : {};
+      if (parentProps.events) {
+        this.globalEvents = Events.getGlobalEvents(parentProps.events);
+        parentProps.events = Events.omitGlobalEvents(parentProps.events);
       }
-    }, {
-      key: "getAllEvents",
-      value: function getAllEvents(props) {
-        if (Array.isArray(this.componentEvents)) {
-          var _this$componentEvents;
+      return /*#__PURE__*/React.cloneElement(component, parentProps, children);
+    }
+    animateComponent(props, defaultAnimationWhitelist) {
+      const animationWhitelist = typeof props.animate === "object" && props.animate?.animationWhitelist || defaultAnimationWhitelist;
+      const Comp = this.constructor;
+      return /*#__PURE__*/React.createElement(VictoryTransition, {
+        animate: props.animate,
+        animationWhitelist: animationWhitelist
+      }, /*#__PURE__*/React.createElement(Comp, props));
+    }
 
-          return Array.isArray(props.events) ? (_this$componentEvents = this.componentEvents).concat.apply(_this$componentEvents, _toConsumableArray(props.events)) : this.componentEvents;
+    // Used by `VictoryLine` and `VictoryArea`
+    renderContinuousData(props) {
+      const {
+        dataComponent,
+        labelComponent,
+        groupComponent
+      } = props;
+      const dataKeys = this.dataKeys.filter(value => value !== "all");
+      const labelComponents = dataKeys.reduce((memo, key) => {
+        let newMemo = memo;
+        const labelProps = this.getComponentProps(labelComponent, "labels", key);
+        if (labelProps && labelProps.text !== undefined && labelProps.text !== null) {
+          newMemo = newMemo.concat( /*#__PURE__*/React.cloneElement(labelComponent, labelProps));
         }
-
-        return props.events;
+        return newMemo;
+      }, []);
+      const dataProps = this.getComponentProps(dataComponent, "data", "all");
+      const children = [/*#__PURE__*/React.cloneElement(dataComponent, dataProps), ...labelComponents];
+      return this.renderContainer(groupComponent, children);
+    }
+    renderData(props, shouldRenderDatum) {
+      if (shouldRenderDatum === void 0) {
+        shouldRenderDatum = datumHasXandY;
       }
-    }, {
-      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;
+      const {
+        dataComponent,
+        labelComponent,
+        groupComponent
+      } = props;
+      const dataComponents = this.dataKeys.reduce((validDataComponents, _dataKey, index) => {
+        const dataProps = this.getComponentProps(dataComponent, "data", index);
+        if (shouldRenderDatum(dataProps.datum)) {
+          validDataComponents.push( /*#__PURE__*/React.cloneElement(dataComponent, dataProps));
         }
-
-        var currentProps = component && typeof component === "object" && "props" in component ? component.props : undefined;
-
-        if (this.hasEvents) {
-          var baseEvents = this.getEvents(this.props, type, key);
-
-          var componentProps = _defaults({
-            index: index,
-            key: id
-          }, this.getEventState(key, type), this.getSharedEventState(key, type), currentProps, baseProps, {
-            id: id
-          });
-
-          var events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
-
-          return Object.assign({}, componentProps, {
-            events: events
-          });
+        return validDataComponents;
+      }, []);
+      const labelComponents = this.dataKeys.map((_dataKey, index) => {
+        const labelProps = this.getComponentProps(labelComponent, "labels", index);
+        if (labelProps.text !== undefined && labelProps.text !== null) {
+          return /*#__PURE__*/React.cloneElement(labelComponent, labelProps);
         }
-
-        return _defaults({
-          index: index,
-          key: id
-        }, currentProps, 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 /*#__PURE__*/React.cloneElement(component, parentProps, children);
-      }
-    }, {
-      key: "animateComponent",
-      value: function animateComponent(props, defaultAnimationWhitelist) {
-        var _props$animate;
-
-        var animationWhitelist = typeof props.animate === "object" && ((_props$animate = props.animate) === null || _props$animate === void 0 ? void 0 : _props$animate.animationWhitelist) || defaultAnimationWhitelist;
-        var Comp = this.constructor;
-        return /*#__PURE__*/React.createElement(VictoryTransition, {
-          animate: props.animate,
-          animationWhitelist: animationWhitelist
-        }, /*#__PURE__*/React.createElement(Comp, 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 = this.dataKeys.filter(function (value) {
-          return value !== "all";
-        });
-        var labelComponents = dataKeys.reduce(function (memo, key) {
-          var newMemo = memo;
-
-          var labelProps = _this8.getComponentProps(labelComponent, "labels", key);
-
-          if (labelProps && labelProps.text !== undefined && labelProps.text !== null) {
-            newMemo = newMemo.concat( /*#__PURE__*/React.cloneElement(labelComponent, labelProps));
-          }
-
-          return newMemo;
-        }, []);
-        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 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));
-          }
-
-          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 /*#__PURE__*/React.cloneElement(labelComponent, labelProps);
-          }
-
-          return undefined;
-        }).filter(Boolean);
-        var children = [].concat(_toConsumableArray(dataComponents), _toConsumableArray(labelComponents));
-        return this.renderContainer(groupComponent, children);
-      }
-    }]);
-
-    return AddEventsMixin;
-  }(WrappedComponent);
-
+        return undefined;
+      }).filter(Boolean);
+      const children = [...dataComponents, ...labelComponents];
+      return this.renderContainer(groupComponent, children);
+    }
+  }
   return AddEventsMixin;
 }