@elliemae/ds-shared 1.60.0 → 2.0.0-alpha.12

package/esm/FocusGroup/FocusGroupManager.js

@@ -1,133 +1,102 @@
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
-import React, { Component } from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { Component } from 'react';
 import { isFunction } from '@elliemae/ds-utilities';
 import FocusGroup from './FocusGroup.js';
 import FocusGroupContext from './FocusGroupContext.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'hotkeys-js';
 
-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 _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; } }
+const noop = () => null;
+
+class FocusGroupProvider extends Component {
+  constructor(props) {
+    super(props);
+    this.activated = false;
+    this.focusGroup = new FocusGroup(props);
+    props.onFocusGroupSet(this);
+    this.actions = {
+      activate: this.activate.bind(this),
+      deactivate: this.deactivate.bind(this),
+      register: this.focusGroup.register,
+      unregister: this.unregister.bind(this),
+      focusFirst: this.focusGroup.focusFirst,
+      focusLast: this.focusGroup.focusLast,
+      focusItemByIndex: this.focusItemByIndex.bind(this),
+      focusItemByNode: this.focusItemByNode.bind(this),
+      focus: this.focusGroup.focusCurrent,
+      isGroupActive: this.focusGroup.isGroupActive,
+      focusNext: this.focusGroup.focusNext,
+      focusPrevious: this.focusGroup.focusPrevious
+    };
+  }
 
-var noop = function noop() {
-  return null;
-};
+  componentDidMount() {
+    const {
+      autoFocusOnMount
+    } = this.props;
+    this.activate();
 
-var FocusGroupProvider = /*#__PURE__*/function (_Component) {
-  _inherits(FocusGroupProvider, _Component);
+    if (autoFocusOnMount) {
+      setTimeout(() => {
+        this.actions.focusFirst();
+      }, 0);
+    }
+  }
 
-  var _super = _createSuper(FocusGroupProvider);
+  componentWillUnmount() {
+    this.deactivate();
+  }
 
-  function FocusGroupProvider(props) {
-    var _this;
+  activate() {
+    const {
+      onActivate
+    } = this.props;
+    this.focusGroup.activate();
+    this.activated = true;
+    if (isFunction(onActivate)) onActivate();
+  }
 
-    _classCallCheck(this, FocusGroupProvider);
+  deactivate() {
+    const {
+      onExitFocusGroup
+    } = this.props;
+    this.activated = false;
+    this.focusGroup.deactivate();
 
-    _this = _super.call(this, props);
-    _this.activated = false;
-    _this.focusGroup = new FocusGroup(props);
-    props.onFocusGroupSet(_assertThisInitialized(_this));
-    _this.actions = {
-      activate: _this.activate.bind(_assertThisInitialized(_this)),
-      deactivate: _this.deactivate.bind(_assertThisInitialized(_this)),
-      register: _this.focusGroup.register,
-      unregister: _this.unregister.bind(_assertThisInitialized(_this)),
-      focusFirst: _this.focusGroup.focusFirst,
-      focusLast: _this.focusGroup.focusLast,
-      focusItemByIndex: _this.focusItemByIndex.bind(_assertThisInitialized(_this)),
-      focusItemByNode: _this.focusItemByNode.bind(_assertThisInitialized(_this)),
-      focus: _this.focusGroup.focusCurrent,
-      isGroupActive: _this.focusGroup.isGroupActive,
-      focusNext: _this.focusGroup.focusNext,
-      focusPrevious: _this.focusGroup.focusPrevious
-    };
-    return _this;
+    if (isFunction(onExitFocusGroup)) {
+      onExitFocusGroup();
+    }
   }
 
-  _createClass(FocusGroupProvider, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var _this2 = this;
-
-      var autoFocusOnMount = this.props.autoFocusOnMount;
-      this.activate();
+  register(item) {
+    this.focusGroup.register(item);
+  }
 
-      if (autoFocusOnMount) {
-        setTimeout(function () {
-          _this2.actions.focusFirst();
-        }, 0);
-      }
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.deactivate();
-    }
-  }, {
-    key: "activate",
-    value: function activate() {
-      var onActivate = this.props.onActivate;
-      this.focusGroup.activate();
-      this.activated = true;
-      if (isFunction(onActivate)) onActivate();
-    }
-  }, {
-    key: "deactivate",
-    value: function deactivate() {
-      var onExitFocusGroup = this.props.onExitFocusGroup;
-      this.activated = false;
-      this.focusGroup.deactivate();
+  unregister(item) {
+    this.focusGroup.unregister(item);
+  }
 
-      if (isFunction(onExitFocusGroup)) {
-        onExitFocusGroup();
-      }
-    }
-  }, {
-    key: "register",
-    value: function register(item) {
-      this.focusGroup.register(item);
-    }
-  }, {
-    key: "unregister",
-    value: function unregister(item) {
-      this.focusGroup.unregister(item);
-    }
-  }, {
-    key: "focusItemByIndex",
-    value: function focusItemByIndex(index) {
-      var _this3 = this;
+  focusItemByIndex(index) {
+    if (!this.activated) this.activate();
+    setTimeout(() => {
+      this.focusGroup.focusByIndex(index);
+    }, 200);
+  }
 
-      if (!this.activated) this.activate();
-      setTimeout(function () {
-        _this3.focusGroup.focusByIndex(index);
-      }, 200);
-    }
-  }, {
-    key: "focusItemByNode",
-    value: function focusItemByNode(node) {
-      if (!this.activated) this.activate();
-      var index = this.focusGroup.getItemIndexByNode(node);
-      this.focusItemByIndex(index);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var children = this.props.children;
-      return /*#__PURE__*/React.createElement(FocusGroupContext.Provider, {
-        value: this.actions
-      }, children);
-    }
-  }]);
+  focusItemByNode(node) {
+    if (!this.activated) this.activate();
+    const index = this.focusGroup.getItemIndexByNode(node);
+    this.focusItemByIndex(index);
+  }
 
-  return FocusGroupProvider;
-}(Component);
+  render() {
+    const {
+      children
+    } = this.props;
+    return /*#__PURE__*/_jsx(FocusGroupContext.Provider, {
+      value: this.actions
+    }, void 0, children);
+  }
 
+}
 FocusGroupProvider.defaultProps = {
   exitWhenNoPrevious: false,
   exitWhenNoNext: false,
@@ -140,4 +109,3 @@ FocusGroupProvider.defaultProps = {
 };
 
 export { FocusGroupProvider as default };
-//# sourceMappingURL=FocusGroupManager.js.map

package/esm/FocusGroup/focusGroupManagerHoc.js

@@ -1,35 +1,37 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
-import React from 'react';
+import 'react';
 import FocusGroupProvider from './FocusGroupManager.js';
-import '@babel/runtime/helpers/esm/classCallCheck';
-import '@babel/runtime/helpers/esm/createClass';
-import '@babel/runtime/helpers/esm/assertThisInitialized';
-import '@babel/runtime/helpers/esm/inherits';
-import '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import '@babel/runtime/helpers/esm/getPrototypeOf';
-import '@elliemae/ds-utilities';
-import './FocusGroup.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'hotkeys-js';
-import './FocusGroupContext.js';
+import { jsx } from 'react/jsx-runtime';
 
-var _excluded = ["onExitFocusGroup", "onFocusPrevGroup", "focusKeyBindings"];
+const _excluded = ["onExitFocusGroup", "onFocusPrevGroup", "focusKeyBindings"];
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 function FocusGroupHoc(WrappedComponent) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return function (_ref) {
-    var onExitFocusGroup = _ref.onExitFocusGroup,
-        onFocusPrevGroup = _ref.onFocusPrevGroup,
-        focusKeyBindings = _ref.focusKeyBindings,
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return _ref => {
+    let {
+      onExitFocusGroup,
+      onFocusPrevGroup,
+      focusKeyBindings
+    } = _ref,
         props = _objectWithoutProperties(_ref, _excluded);
 
-    return /*#__PURE__*/React.createElement(FocusGroupProvider, _extends({
+    return /*#__PURE__*/jsx(FocusGroupProvider, _objectSpread(_objectSpread({
       keyBindings: focusKeyBindings,
       onExitFocusGroup: onExitFocusGroup,
       onFocusPrevGroup: onFocusPrevGroup
-    }, options), /*#__PURE__*/React.createElement(WrappedComponent, _extends({}, props, options)));
+    }, options), {}, {
+      children: /*#__PURE__*/jsx(WrappedComponent, _objectSpread(_objectSpread({}, props), options))
+    }));
   };
 }
 
 export { FocusGroupHoc as default };
-//# sourceMappingURL=focusGroupManagerHoc.js.map

package/esm/FocusGroup/index.js

@@ -4,17 +4,3 @@ export { default as FocusGroupManager } from './FocusGroupManager.js';
 export { default as useFocusGroupItem, useFocusGroupWithState } from './useFocusGroupItem.js';
 export { default as focusGroupManagerHoc } from './focusGroupManagerHoc.js';
 export { default as FocusGrid, FocusGridContext } from './FocusGrid.js';
-import '@babel/runtime/helpers/esm/classCallCheck';
-import '@babel/runtime/helpers/esm/createClass';
-import '@babel/runtime/helpers/esm/defineProperty';
-import '@elliemae/ds-utilities';
-import 'hotkeys-js';
-import 'react';
-import '@babel/runtime/helpers/esm/assertThisInitialized';
-import '@babel/runtime/helpers/esm/inherits';
-import '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import '@babel/runtime/helpers/esm/getPrototypeOf';
-import '@babel/runtime/helpers/esm/objectWithoutProperties';
-import '@babel/runtime/helpers/esm/extends';
-import './utils/getNextCellPosition.js';
-//# sourceMappingURL=index.js.map

package/esm/FocusGroup/useFocusGroupItem.js

@@ -2,20 +2,22 @@ import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutPr
 import { useContext, useEffect } from 'react';
 import FocusGroupContext from './FocusGroupContext.js';
 
-var _excluded = ["register", "unregister"],
-    _excluded2 = ["register", "unregister"];
+const _excluded = ["register", "unregister"],
+      _excluded2 = ["register", "unregister"];
 function useFocusGroupItem() {
-  var ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var props = arguments.length > 1 ? arguments[1] : undefined;
+  let ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let props = arguments.length > 1 ? arguments[1] : undefined;
 
-  var _ref = useContext(FocusGroupContext) || {},
-      register = _ref.register,
-      unregister = _ref.unregister,
-      otherActions = _objectWithoutProperties(_ref, _excluded);
+  const _ref = useContext(FocusGroupContext) || {},
+        {
+    register,
+    unregister
+  } = _ref,
+        otherActions = _objectWithoutProperties(_ref, _excluded);
 
-  useEffect(function () {
+  useEffect(() => {
     if (ref.current && register) register(ref.current, props);
-    return function () {
+    return () => {
       if (ref.current && unregister) unregister(ref.current);
     };
   }); // if the focus item is not wrapped with the focus provider then return null
@@ -23,18 +25,20 @@ function useFocusGroupItem() {
   if (!register) return {};
   return otherActions;
 }
-var useFocusGroupWithState = function useFocusGroupWithState() {
-  var ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var props = arguments.length > 1 ? arguments[1] : undefined;
-
-  var _ref2 = useContext(FocusGroupContext) || {},
-      register = _ref2.register,
-      unregister = _ref2.unregister,
-      otherActions = _objectWithoutProperties(_ref2, _excluded2);
-
-  useEffect(function () {
+const useFocusGroupWithState = function () {
+  let ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  let props = arguments.length > 1 ? arguments[1] : undefined;
+
+  const _ref2 = useContext(FocusGroupContext) || {},
+        {
+    register,
+    unregister
+  } = _ref2,
+        otherActions = _objectWithoutProperties(_ref2, _excluded2);
+
+  useEffect(() => {
     if (ref && register) register(ref, props);
-    return function () {
+    return () => {
       if (ref && unregister) unregister(ref);
     };
   }, [ref]); // if the focus item is not wrapped with the focus provider then return null
@@ -44,4 +48,3 @@ var useFocusGroupWithState = function useFocusGroupWithState() {
 };
 
 export { useFocusGroupItem as default, useFocusGroupWithState };
-//# sourceMappingURL=useFocusGroupItem.js.map

package/esm/FocusGroup/utils/getNextCellPosition.js

@@ -1,24 +1,24 @@
 // eslint-disable-next-line max-statements
 function getNextCellPosition(_ref) {
-  var grid = _ref.grid,
-      _ref$currentRow = _ref.currentRow,
-      currentRow = _ref$currentRow === void 0 ? 0 : _ref$currentRow,
-      _ref$currentCell = _ref.currentCell,
-      currentCell = _ref$currentCell === void 0 ? 0 : _ref$currentCell,
-      directionY = _ref.directionY,
-      directionX = _ref.directionX,
-      shouldWrapCells = _ref.shouldWrapCells,
-      shouldWrapRows = _ref.shouldWrapRows;
-  var nextRow = currentRow + directionY;
-  var nextCell = currentCell + directionX;
-  var rowCount = grid.length;
-  var isLeftRight = directionX !== 0;
+  let {
+    grid,
+    currentRow = 0,
+    currentCell = 0,
+    directionY,
+    directionX,
+    shouldWrapCells,
+    shouldWrapRows
+  } = _ref;
+  let nextRow = currentRow + directionY;
+  let nextCell = currentCell + directionX;
+  const rowCount = grid.length;
+  const isLeftRight = directionX !== 0;
 
   if (!rowCount) {
     return false;
   }
 
-  var cellsLength = grid[0].length; // moving horizontally
+  const cellsLength = grid[0].length; // moving horizontally
 
   if (shouldWrapCells && isLeftRight) {
     // to left
@@ -56,4 +56,3 @@ function getNextCellPosition(_ref) {
 }
 
 export { getNextCellPosition as default };
-//# sourceMappingURL=getNextCellPosition.js.map

package/esm/GroupContext/Group.js

@@ -1,38 +1,35 @@
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { Component } from 'react';
 import { GroupContext } from './GroupContext.js';
 
-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 _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; } }
-
-var getValueItem = function getValueItem(e) {
-  var target = e.target,
-      currentTarget = e.currentTarget;
+const getValueItem = e => {
+  const {
+    target,
+    currentTarget
+  } = e;
 
   if (target) {
-    var value = target.value;
+    const {
+      value
+    } = target;
     return value;
   }
 
   if (currentTarget) {
-    var _value = currentTarget.value;
-    return _value;
+    const {
+      value
+    } = currentTarget;
+    return value;
   }
 
   return e;
 };
 
-var toggleItemValue = function toggleItemValue(array, e) {
-  var newvalue = getValueItem(e);
-  var res = array;
-  var index = array.indexOf(newvalue);
+const toggleItemValue = (array, e) => {
+  const newvalue = getValueItem(e);
+  const res = array;
+  const index = array.indexOf(newvalue);
 
   if (index === -1) {
     res.push(newvalue);
@@ -43,91 +40,79 @@ var toggleItemValue = function toggleItemValue(array, e) {
   return res;
 };
 
-var Provider = GroupContext.Provider;
+const {
+  Provider
+} = GroupContext;
 /** deprecated use CheckableGroup instead */
 
-var Group = /*#__PURE__*/function (_Component) {
-  _inherits(Group, _Component);
-
-  var _super = _createSuper(Group);
-
-  function Group(props) {
-    var _this;
-
-    _classCallCheck(this, Group);
-
-    _this = _super.call(this, props);
-    var activeValue = props.activeValue,
-        disabled = props.disabled;
-    _this.state = {
-      activeValue: activeValue,
-      disabled: disabled,
+class Group extends Component {
+  constructor(props) {
+    super(props);
+    const {
+      activeValue,
+      disabled
+    } = props;
+    this.state = {
+      activeValue,
+      disabled,
       prevValue: null,
-      onChange: _this.handleChange.bind(_assertThisInitialized(_this))
+      onChange: this.handleChange.bind(this)
     };
-    return _this;
   }
 
-  _createClass(Group, [{
-    key: "handleChange",
-    value: function handleChange(e) {
-      var _this$props = this.props,
-          multiple = _this$props.multiple,
-          onChange = _this$props.onChange;
-      var activeValue = this.state.activeValue;
-      var value = getValueItem(e);
-      var newValue;
-
-      if (multiple) {
-        newValue = toggleItemValue(activeValue || [], value);
-      } else if (activeValue !== value) {
-        // default behaviour it will be toggle the active value
-        newValue = value;
-      }
-
-      this.setState({
-        activeValue: newValue
-      });
-
-      for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        rest[_key - 1] = arguments[_key];
-      }
-
-      if (onChange) onChange.apply(void 0, [newValue].concat(rest));
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      var children = this.props.children;
-      return /*#__PURE__*/React.createElement(Provider, {
-        value: this.state
-      }, children);
+  static getDerivedStateFromProps(nextProps, _ref) {
+    let {
+      prevValue
+    } = _ref;
+    if (nextProps.activeValue === prevValue) return null;
+    return {
+      activeValue: nextProps.activeValue,
+      prevValue: nextProps.activeValue
+    };
+  }
+
+  handleChange(e) {
+    const {
+      multiple,
+      onChange
+    } = this.props;
+    const {
+      activeValue
+    } = this.state;
+    const value = getValueItem(e);
+    let newValue;
+
+    if (multiple) {
+      newValue = toggleItemValue(activeValue || [], value);
+    } else if (activeValue !== value) {
+      // default behaviour it will be toggle the active value
+      newValue = value;
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(nextProps, _ref) {
-      var prevValue = _ref.prevValue;
-      if (nextProps.activeValue === prevValue) return null;
-      return {
-        activeValue: nextProps.activeValue,
-        prevValue: nextProps.activeValue
-      };
+
+    this.setState({
+      activeValue: newValue
+    });
+
+    for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      rest[_key - 1] = arguments[_key];
     }
-  }]);
 
-  return Group;
-}(Component);
+    if (onChange) onChange(newValue, ...rest);
+  }
+
+  render() {
+    const {
+      children
+    } = this.props;
+    return /*#__PURE__*/_jsx(Provider, {
+      value: this.state
+    }, void 0, children);
+  }
+
+}
 
 Group.defaultProps = {
   multiple: false
 };
-Group.propTypes = {
-  children: PropTypes.array,
-  multiple: PropTypes.bool,
-  onChange: PropTypes.func,
-  activeValue: PropTypes.oneOfType([PropTypes.array, PropTypes.number]),
-  disabled: PropTypes.bool
-};
 
 export { Group as default };
-//# sourceMappingURL=Group.js.map

package/esm/GroupContext/GroupContext.js

@@ -1,6 +1,5 @@
 import React from 'react';
 
-var GroupContext = /*#__PURE__*/React.createContext();
+const GroupContext = /*#__PURE__*/React.createContext();
 
 export { GroupContext };
-//# sourceMappingURL=GroupContext.js.map

package/esm/GroupContext/GroupItem.js

@@ -1,14 +1,16 @@
-import React from 'react';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
 import { GroupContext } from './GroupContext.js';
 
-var Consumer = GroupContext.Consumer;
+const {
+  Consumer
+} = GroupContext;
 
-var GroupItem = function GroupItem(_ref) {
-  var render = _ref.render;
-  return /*#__PURE__*/React.createElement(Consumer, null, function (context) {
-    return render(context);
-  });
+const GroupItem = _ref => {
+  let {
+    render
+  } = _ref;
+  return /*#__PURE__*/_jsx(Consumer, {}, void 0, context => render(context));
 };
 
 export { GroupItem as default };
-//# sourceMappingURL=GroupItem.js.map