victory-core 36.1.0 → 36.2.0

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

@@ -48,360 +48,363 @@ 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;
+      function addEvents(props) {
+        var _this;
 
-      _classCallCheck(this, addEvents);
+        _classCallCheck(this, addEvents);
 
-      _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 = {};
+        _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 = {};
 
-      _this.getEvents = function (p, target, eventKey) {
-        return boundGetEvents(p, target, eventKey, getScopedEvents);
-      };
+        _this.getEvents = function (p, target, eventKey) {
+          return boundGetEvents(p, target, eventKey, getScopedEvents);
+        };
 
-      _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
+        _this.getEventState = Events.getEventState.bind(_assertThisInitialized(_this));
 
-      var calculatedValues = _this.getCalculatedValues(props);
+        var calculatedValues = _this.getCalculatedValues(props);
 
-      _this.cacheValues(calculatedValues);
+        _this.cacheValues(calculatedValues);
 
-      _this.externalMutations = _this.getExternalMutations(props);
-      _this.calculatedState = _this.getStateChanges(props);
-      _this.globalEvents = {};
-      _this.prevGlobalEventKeys = [];
-      _this.boundGlobalEvents = {};
-      return _this;
-    }
+        _this.externalMutations = _this.getExternalMutations(props);
+        _this.calculatedState = _this.getStateChanges(props);
+        _this.globalEvents = {};
+        _this.prevGlobalEventKeys = [];
+        _this.boundGlobalEvents = {};
+        return _this;
+      }
 
-    _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);
+      _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;
+          }
 
-        if (animating || newMutation) {
-          this.cacheValues(this.getCalculatedValues(nextProps));
-          this.externalMutations = externalMutations;
-          this.applyExternalMutations(nextProps, externalMutations);
-          return true;
-        }
+          var calculatedState = this.getStateChanges(nextProps);
 
-        var calculatedState = this.getStateChanges(nextProps);
+          if (!isEqual(this.calculatedState, calculatedState)) {
+            this.cacheValues(this.getCalculatedValues(nextProps));
+            return true;
+          }
 
-        if (!isEqual(this.calculatedState, calculatedState)) {
-          this.cacheValues(this.getCalculatedValues(nextProps));
-          return true;
-        }
+          if (!isEqual(this.props, nextProps)) {
+            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;
 
-        return false;
-      }
-    }, {
-      key: "componentDidMount",
-      value: function componentDidMount() {
-        var _this2 = this;
+          var globalEventKeys = _keys(this.globalEvents);
 
-        var globalEventKeys = _keys(this.globalEvents);
-
-        globalEventKeys.forEach(function (key) {
-          return _this2.addGlobalListener(key);
-        });
-        this.prevGlobalEventKeys = globalEventKeys;
-      }
-    }, {
-      key: "componentDidUpdate",
-      value: function componentDidUpdate(prevProps) {
-        var _this3 = this;
+          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 calculatedState = this.getStateChanges(prevProps);
+          this.calculatedState = calculatedState;
 
-        var globalEventKeys = _keys(this.globalEvents);
+          var globalEventKeys = _keys(this.globalEvents);
 
-        var removedGlobalEventKeys = _difference(this.prevGlobalEventKeys, globalEventKeys);
+          var removedGlobalEventKeys = _difference(this.prevGlobalEventKeys, globalEventKeys);
 
-        removedGlobalEventKeys.forEach(function (key) {
-          return _this3.removeGlobalListener(key);
-        });
+          removedGlobalEventKeys.forEach(function (key) {
+            return _this3.removeGlobalListener(key);
+          });
 
-        var addedGlobalEventKeys = _difference(globalEventKeys, this.prevGlobalEventKeys);
+          var addedGlobalEventKeys = _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);
-        });
-      }
-    }, {
-      key: "addGlobalListener",
-      value: function addGlobalListener(key) {
-        var _this5 = this;
-
-        var boundListener = function (event) {
-          var listener = _this5.globalEvents[key];
-          return listener && listener(Events.emulateReactEvent(event));
-        };
+          addedGlobalEventKeys.forEach(function (key) {
+            return _this3.addGlobalListener(key);
+          });
+          this.prevGlobalEventKeys = globalEventKeys;
+        }
+      }, {
+        key: "componentWillUnmount",
+        value: function componentWillUnmount() {
+          var _this4 = this;
 
-        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 {};
+          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));
+          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);
 
-          return _isEmpty(result) ? undefined : result;
-        };
+          var dataKeys = _keys(baseProps).filter(function (key) {
+            return key !== "parent";
+          });
 
-        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);
+          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: "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");
+      }, {
+        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;
 
-        var baseParentProps = _defaults({}, parentState, sharedParentState);
+          _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");
 
-        var parentPropsList = baseParentProps.parentControlledProps;
-        var parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
+          var baseParentProps = _defaults({}, parentState, sharedParentState);
 
-        var modifiedProps = _defaults({}, parentProps, props);
+          var parentPropsList = baseParentProps.parentControlledProps;
+          var parentProps = parentPropsList ? _pick(baseParentProps, parentPropsList) : {};
 
-        return _isFunction(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
-      }
-    }, {
-      key: "getAllEvents",
-      value: function getAllEvents(props) {
-        if (Array.isArray(this.componentEvents)) {
-          var _componentEvents;
+          var modifiedProps = _defaults({}, parentProps, props);
 
-          return Array.isArray(props.events) ? (_componentEvents = this.componentEvents).concat.apply(_componentEvents, _toConsumableArray(props.events)) : this.componentEvents;
+          return _isFunction(WrappedComponent.getBaseProps) ? WrappedComponent.getBaseProps(modifiedProps) : {};
         }
+      }, {
+        key: "getAllEvents",
+        value: function getAllEvents(props) {
+          if (Array.isArray(this.componentEvents)) {
+            var _componentEvents;
 
-        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;
+            return Array.isArray(props.events) ? (_componentEvents = this.componentEvents).concat.apply(_componentEvents, _toConsumableArray(props.events)) : this.componentEvents;
+          }
+
+          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);
+
+            var componentProps = _defaults({
+              index: index,
+              key: id
+            }, this.getEventState(key, type), this.getSharedEventState(key, type), component.props, baseProps, {
+              id: id
+            });
 
-        if (this.hasEvents) {
-          var baseEvents = this.getEvents(this.props, type, key);
+            var events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
 
-          var componentProps = _defaults({
+            return _assign({}, componentProps, {
+              events: events
+            });
+          }
+
+          return _defaults({
             index: index,
             key: id
-          }, this.getEventState(key, type), this.getSharedEventState(key, type), component.props, baseProps, {
+          }, component.props, baseProps, {
             id: id
           });
-
-          var events = _defaults({}, Events.getPartialEvents(baseEvents, key, componentProps), componentProps.events);
-
-          return _assign({}, componentProps, {
-            events: events
-          });
-        }
-
-        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);
         }
-
-        return React.cloneElement(component, parentProps, children);
-      }
-    }, {
-      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));
+      }, {
+        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 memo;
-        }, []);
-        var dataProps = this.getComponentProps(dataComponent, "data", "all");
-        var children = [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(React.cloneElement(dataComponent, dataProps));
-          }
+          return React.cloneElement(component, parentProps, children);
+        }
+      }, {
+        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 validDataComponents;
-        }, []);
-        var labelComponents = this.dataKeys.map(function (_dataKey, index) {
-          var labelProps = _this9.getComponentProps(labelComponent, "labels", index);
+            return memo;
+          }, []);
+          var dataProps = this.getComponentProps(dataComponent, "data", "all");
+          var children = [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(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);
-          }
+            if (labelProps.text !== undefined && labelProps.text !== null) {
+              return React.cloneElement(labelComponent, labelProps);
+            }
 
-          return undefined;
-        }).filter(Boolean);
+            return undefined;
+          }).filter(Boolean);
 
-        var children = _toConsumableArray(dataComponents).concat(_toConsumableArray(labelComponents));
+          var children = _toConsumableArray(dataComponents).concat(_toConsumableArray(labelComponents));
 
-        return this.renderContainer(groupComponent, children);
-      }
-    }]);
+          return this.renderContainer(groupComponent, children);
+        }
+      }]);
 
-    return addEvents;
-  }(WrappedComponent);
+      return addEvents;
+    }(WrappedComponent)
+  );
 });