@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/list/list.js

@@ -0,0 +1,812 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { Component, cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import VirtualizedList from 'react-virtualized/dist/es/List';
+import AutoSizer from 'react-virtualized/dist/es/AutoSizer';
+import WindowScroller from 'react-virtualized/dist/es/WindowScroller';
+import { CellMeasurerCache, CellMeasurer } from 'react-virtualized/dist/es/CellMeasurer';
+import deprecate from 'util-deprecate';
+import memoizeOne from 'memoize-one';
+import joinDataTestAttributes from '../global/data-tests.js';
+import getUID from '../global/get-uid.js';
+import scheduleRAF from '../global/schedule-raf.js';
+import memoize from '../global/memoize.js';
+import { preventDefault } from '../global/dom.js';
+import Shortcuts from '../shortcuts/shortcuts.js';
+import createStatefulContext from '../global/create-stateful-context.js';
+import ListLink from './list__link.js';
+import ListItem from './list__item.js';
+import ListCustom from './list__custom.js';
+import ListTitle from './list__title.js';
+import ListSeparator from './list__separator.js';
+import ListHint from './list__hint.js';
+import { Type, Dimension, DEFAULT_ITEM_TYPE } from './consts.js';
+import { m as modules_3b67a421 } from '../_helpers/list.js';
+import '../shortcuts/core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../link/link.js';
+import 'focus-visible';
+import '../link/clickableLink.js';
+import '../_helpers/link.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import '../avatar/fallback-avatar.js';
+import '../checkbox/checkbox.js';
+import '@jetbrains/icons/checkmark';
+import '@jetbrains/icons/remove-10px';
+import '../icon/icon.js';
+import '../icon/icon__constants.js';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../_helpers/checkbox.js';
+import '../global/get-event-key.js';
+
+const scheduleScrollListener = scheduleRAF();
+const scheduleHoverListener = scheduleRAF();
+
+function noop() {}
+
+const warnEmptyKey = deprecate(() => {}, 'No key passed for list item with non-string label. It is considered as a bad practice and has been deprecated, please provide a key.');
+/**
+ * @param {Type} listItemType
+ * @param {Object} item list item
+ */
+
+function isItemType(listItemType, item) {
+  let type = item.rgItemType;
+
+  if (type == null) {
+    type = DEFAULT_ITEM_TYPE;
+  }
+
+  return type === listItemType;
+}
+
+const nonActivatableTypes = [Type.SEPARATOR, Type.TITLE, Type.MARGIN];
+
+function isActivatable(item) {
+  return item != null && !nonActivatableTypes.includes(item.rgItemType) && !item.disabled;
+}
+
+const shouldActivateFirstItem = props => props.activateFirstItem || props.activateSingleItem && props.data.length === 1;
+
+const ActiveItemContext = createStatefulContext(undefined, 'ActiveItem');
+/**
+ * @name List
+ * @constructor
+ * @extends {ReactComponent}
+ */
+
+/**
+ * Displays a list of items.
+ */
+
+class List extends Component {
+  constructor() {
+    var _this;
+
+    super(...arguments);
+    _this = this;
+
+    _defineProperty(this, "state", {
+      activeIndex: null,
+      prevActiveIndex: null,
+      prevData: [],
+      activeItem: null,
+      needScrollToActive: false,
+      scrolling: false,
+      hasOverflow: false,
+      disabledHover: false,
+      scrolledToBottom: false
+    });
+
+    _defineProperty(this, "hoverHandler", memoize(index => () => scheduleHoverListener(() => {
+      if (this.state.disabledHover) {
+        return;
+      }
+
+      if (this.container) {
+        this.setState({
+          activeIndex: index,
+          activeItem: this.props.data[index],
+          needScrollToActive: false
+        });
+      }
+    })));
+
+    _defineProperty(this, "_activatableItems", false);
+
+    _defineProperty(this, "_bufferSize", 10);
+
+    _defineProperty(this, "sizeCacheKey", index => {
+      if (index === 0 || index === this.props.data.length + 1) {
+        return Type.MARGIN;
+      }
+
+      const item = this.props.data[index - 1];
+      const isFirst = index === 1;
+
+      switch (item.rgItemType) {
+        case Type.SEPARATOR:
+        case Type.TITLE:
+          return `${item.rgItemType}${isFirst ? '_first' : ''}${item.description ? '_desc' : ''}`;
+
+        case Type.MARGIN:
+          return Type.MARGIN;
+
+        case Type.CUSTOM:
+          return `${Type.CUSTOM}_${item.key}`;
+
+        case Type.ITEM:
+        case Type.LINK:
+        default:
+          if (item.details) {
+            return `${Type.ITEM}_${item.details}`;
+          }
+
+          return Type.ITEM;
+      }
+    });
+
+    _defineProperty(this, "_cache", new CellMeasurerCache({
+      defaultHeight: this.defaultItemHeight(),
+      fixedWidth: true,
+      keyMapper: this.sizeCacheKey
+    }));
+
+    _defineProperty(this, "_hasActivatableItems", memoizeOne(items => items.some(isActivatable)));
+
+    _defineProperty(this, "selectHandler", memoize(index => function (event) {
+      let tryKeepOpen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      const item = _this.props.data[index];
+
+      if (!_this.props.useMouseUp && item.onClick) {
+        item.onClick(item, event);
+      } else if (_this.props.useMouseUp && item.onMouseUp) {
+        item.onMouseUp(item, event);
+      }
+
+      if (_this.props.onSelect) {
+        _this.props.onSelect(item, event, {
+          tryKeepOpen
+        });
+      }
+    }));
+
+    _defineProperty(this, "checkboxHandler", memoize(index => event => this.selectHandler(index)(event, true)));
+
+    _defineProperty(this, "upHandler", e => {
+      const {
+        data,
+        disableMoveOverflow
+      } = this.props;
+      const index = this.state.activeIndex;
+      let newIndex;
+
+      if (index === null || index === 0) {
+        if (!disableMoveOverflow) {
+          newIndex = data.length - 1;
+        } else {
+          return;
+        }
+      } else {
+        newIndex = index - 1;
+      }
+
+      this.moveHandler(newIndex, this.upHandler, e);
+    });
+
+    _defineProperty(this, "downHandler", e => {
+      const {
+        data,
+        disableMoveOverflow,
+        disableMoveDownOverflow
+      } = this.props;
+      const index = this.state.activeIndex;
+      let newIndex;
+
+      if (index === null) {
+        newIndex = 0;
+      } else if (index + 1 === data.length) {
+        if (!disableMoveOverflow && !disableMoveDownOverflow) {
+          newIndex = 0;
+        } else {
+          return;
+        }
+      } else {
+        newIndex = index + 1;
+      }
+
+      this.moveHandler(newIndex, this.downHandler, e);
+    });
+
+    _defineProperty(this, "homeHandler", e => {
+      this.moveHandler(0, this.downHandler, e);
+    });
+
+    _defineProperty(this, "endHandler", e => {
+      this.moveHandler(this.props.data.length - 1, this.upHandler, e);
+    });
+
+    _defineProperty(this, "onDocumentMouseMove", () => {
+      if (this.state.disabledHover) {
+        this.setState({
+          disabledHover: false
+        });
+      }
+    });
+
+    _defineProperty(this, "onDocumentKeyDown", e => {
+      const metaKeys = [16, 17, 18, 19, 20, 91]; // eslint-disable-line no-magic-numbers
+
+      if (!this.state.disabledHover && !metaKeys.includes(e.keyCode)) {
+        this.setState({
+          disabledHover: true
+        });
+      }
+    });
+
+    _defineProperty(this, "mouseHandler", () => {
+      this.setState({
+        scrolling: false
+      });
+    });
+
+    _defineProperty(this, "scrollHandler", () => {
+      this.setState({
+        scrolling: true
+      }, this.scrollEndHandler);
+    });
+
+    _defineProperty(this, "enterHandler", (event, shortcut) => {
+      if (this.state.activeIndex !== null) {
+        const item = this.props.data[this.state.activeIndex];
+        this.selectHandler(this.state.activeIndex)(event);
+
+        if (item.href && !event.defaultPrevented) {
+          if (['command+enter', 'ctrl+enter'].includes(shortcut)) {
+            window.open(item.href, '_blank');
+          } else if (shortcut === 'shift+enter') {
+            window.open(item.href);
+          } else {
+            window.location.href = item.href;
+          }
+        }
+
+        return false; // do not propagate event
+      } else {
+        return true; // propagate event to the parent component (e.g., QueryAssist)
+      }
+    });
+
+    _defineProperty(this, "clearSelected", () => {
+      this.setState({
+        activeIndex: null,
+        needScrollToActive: false
+      });
+    });
+
+    _defineProperty(this, "scrollEndHandler", () => scheduleScrollListener(() => {
+      const innerContainer = this.inner;
+
+      if (innerContainer) {
+        const maxScrollingPosition = innerContainer.scrollHeight;
+        const sensitivity = this.defaultItemHeight() / 2;
+        const currentScrollingPosition = innerContainer.scrollTop + innerContainer.clientHeight + sensitivity;
+        const scrolledToBottom = maxScrollingPosition > 0 && currentScrollingPosition >= maxScrollingPosition;
+
+        if (!this.unmounted) {
+          this.setState({
+            scrolledToBottom
+          });
+        }
+
+        if (scrolledToBottom) {
+          this.props.onScrollToBottom();
+        }
+      }
+    }));
+
+    _defineProperty(this, "checkOverflow", () => {
+      if (this.inner) {
+        this.setState({
+          hasOverflow: this.inner.scrollHeight - this.inner.clientHeight > 1
+        });
+      }
+    });
+
+    _defineProperty(this, "renderItem", _ref => {
+      let {
+        index,
+        style,
+        isScrolling,
+        parent,
+        key
+      } = _ref;
+      let itemKey;
+      let el;
+      const realIndex = index - 1;
+      const item = this.props.data[realIndex];
+      const itemId = this.getId(item); // top and bottom margins
+
+      if (index === 0 || index === this.props.data.length + 1 || item.rgItemType === Type.MARGIN) {
+        itemKey = key || `${Type.MARGIN}_${index}`;
+        el = /*#__PURE__*/React.createElement("div", {
+          style: {
+            height: Dimension.MARGIN
+          }
+        });
+      } else {
+        // Hack around SelectNG implementation
+        const {
+          selectedLabel,
+          originalModel,
+          ...cleanedProps
+        } = item;
+        const itemProps = Object.assign({
+          rgItemType: DEFAULT_ITEM_TYPE
+        }, cleanedProps);
+
+        if (itemProps.url) {
+          itemProps.href = itemProps.url;
+        }
+
+        if (itemProps.href) {
+          itemProps.rgItemType = Type.LINK;
+        }
+
+        itemKey = key || itemId;
+        itemProps.hover = realIndex === this.state.activeIndex;
+
+        if (itemProps.hoverClassName != null && itemProps.hover) {
+          itemProps.className = classNames(itemProps.className, itemProps.hoverClassName);
+        }
+
+        itemProps.onMouseOver = this.hoverHandler(realIndex);
+        itemProps.tabIndex = -1;
+        itemProps.scrolling = isScrolling;
+        const selectHandler = this.selectHandler(realIndex);
+
+        if (this.props.useMouseUp) {
+          itemProps.onMouseUp = selectHandler;
+        } else {
+          itemProps.onClick = selectHandler;
+        }
+
+        itemProps.onCheckboxChange = this.checkboxHandler(realIndex);
+
+        if (itemProps.compact == null) {
+          itemProps.compact = this.props.compact;
+        }
+
+        let ItemComponent;
+        const isFirst = index === 1;
+
+        switch (itemProps.rgItemType) {
+          case Type.SEPARATOR:
+            ItemComponent = ListSeparator;
+            itemProps.isFirst = isFirst;
+            break;
+
+          case Type.LINK:
+            ItemComponent = ListLink;
+            this.addItemDataTestToProp(itemProps);
+            break;
+
+          case Type.ITEM:
+            ItemComponent = ListItem;
+            this.addItemDataTestToProp(itemProps);
+            break;
+
+          case Type.CUSTOM:
+            ItemComponent = ListCustom;
+            this.addItemDataTestToProp(itemProps);
+            break;
+
+          case Type.TITLE:
+            itemProps.isFirst = isFirst;
+            ItemComponent = ListTitle;
+            break;
+
+          default:
+            throw new Error(`Unknown menu element type: ${itemProps.rgItemType}`);
+        }
+
+        el = /*#__PURE__*/React.createElement(ItemComponent, itemProps);
+      }
+
+      return parent ? /*#__PURE__*/React.createElement(CellMeasurer, {
+        cache: this._cache,
+        key: itemKey,
+        parent: parent,
+        rowIndex: index,
+        columnIndex: 0
+      }, _ref2 => {
+        let {
+          registerChild
+        } = _ref2;
+        return /*#__PURE__*/React.createElement("div", {
+          ref: registerChild,
+          style: style,
+          role: "row",
+          id: itemId
+        }, /*#__PURE__*/React.createElement("div", {
+          role: "cell"
+        }, el));
+      }) : /*#__PURE__*/React.createElement("div", {
+        role: "row",
+        id: itemId,
+        key: itemKey
+      }, /*#__PURE__*/React.createElement("div", {
+        role: "cell"
+      }, /*#__PURE__*/cloneElement(el)));
+    });
+
+    _defineProperty(this, "addItemDataTestToProp", props => {
+      props['data-test'] = joinDataTestAttributes('ring-list-item', props['data-test']);
+      return props;
+    });
+
+    _defineProperty(this, "virtualizedListRef", el => {
+      this.virtualizedList = el;
+    });
+
+    _defineProperty(this, "containerRef", el => {
+      this.container = el;
+    });
+
+    _defineProperty(this, "id", getUID('list-'));
+
+    _defineProperty(this, "shortcutsScope", this.id);
+
+    _defineProperty(this, "shortcutsMap", {
+      up: this.upHandler,
+      down: this.downHandler,
+      home: this.homeHandler,
+      end: this.endHandler,
+      enter: this.enterHandler,
+      'meta+enter': this.enterHandler,
+      'ctrl+enter': this.enterHandler,
+      'command+enter': this.enterHandler,
+      'shift+enter': this.enterHandler
+    });
+  }
+
+  static getDerivedStateFromProps(nextProps, prevState) {
+    const {
+      prevActiveIndex,
+      prevData,
+      activeItem
+    } = prevState;
+    const {
+      data,
+      activeIndex,
+      restoreActiveIndex
+    } = nextProps;
+    const nextState = {
+      prevActiveIndex: activeIndex,
+      prevData: data
+    };
+
+    if (data !== prevData) {
+      Object.assign(nextState, {
+        activeIndex: null,
+        activeItem: null
+      });
+    }
+
+    if (activeIndex != null && activeIndex !== prevActiveIndex && data[activeIndex] != null) {
+      Object.assign(nextState, {
+        activeIndex,
+        activeItem: data[activeIndex],
+        needScrollToActive: true
+      });
+    } else if (data !== prevData && restoreActiveIndex && activeItem != null && activeItem.key != null) {
+      // Restore active index if there is an item with the same "key" property
+      const index = data.findIndex(item => item.key === activeItem.key);
+
+      if (index >= 0) {
+        Object.assign(nextState, {
+          activeIndex: index,
+          activeItem: data[index]
+        });
+      }
+    }
+
+    if (activeIndex == null && prevState.activeIndex == null && shouldActivateFirstItem(nextProps)) {
+      const firstActivatableIndex = data.findIndex(isActivatable);
+
+      if (firstActivatableIndex >= 0) {
+        Object.assign(nextState, {
+          activeIndex: firstActivatableIndex,
+          activeItem: data[firstActivatableIndex],
+          needScrollToActive: true
+        });
+      }
+    }
+
+    return nextState;
+  }
+
+  componentDidMount() {
+    document.addEventListener('mousemove', this.onDocumentMouseMove);
+    document.addEventListener('keydown', this.onDocumentKeyDown, true);
+  }
+
+  shouldComponentUpdate(nextProps, nextState) {
+    return nextProps !== this.props || Object.keys(nextState).some(key => nextState[key] !== this.state[key]);
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.virtualizedList && prevProps.data !== this.props.data) {
+      this.virtualizedList.recomputeRowHeights();
+    }
+
+    this.checkOverflow();
+  }
+
+  componentWillUnmount() {
+    this.unmounted = true;
+    document.removeEventListener('mousemove', this.onDocumentMouseMove);
+    document.removeEventListener('keydown', this.onDocumentKeyDown, true);
+  }
+
+  hasActivatableItems() {
+    return this._hasActivatableItems(this.props.data);
+  }
+
+  moveHandler(index, retryCallback, e) {
+    let correctedIndex;
+
+    if (this.props.data.length === 0 || !this.hasActivatableItems()) {
+      return;
+    } else if (this.props.data.length < index) {
+      correctedIndex = 0;
+    } else {
+      correctedIndex = index;
+    }
+
+    const item = this.props.data[correctedIndex];
+    this.setState({
+      activeIndex: correctedIndex,
+      activeItem: item,
+      needScrollToActive: true
+    }, function onSet() {
+      if (!isActivatable(item)) {
+        retryCallback(e);
+        return;
+      }
+
+      if (e.key !== 'Home' && e.key !== 'End') {
+        preventDefault(e);
+      }
+    });
+  }
+
+  getFirst() {
+    return this.props.data.find(item => item.rgItemType === Type.ITEM || item.rgItemType === Type.CUSTOM);
+  }
+
+  getSelected() {
+    return this.props.data[this.state.activeIndex];
+  }
+
+  defaultItemHeight() {
+    return this.props.compact ? Dimension.COMPACT_ITEM_HEIGHT : Dimension.ITEM_HEIGHT;
+  }
+
+  getVisibleListHeight(props) {
+    return props.maxHeight - this.defaultItemHeight() - Dimension.INNER_PADDING;
+  }
+
+  _deprecatedGenerateKeyFromContent(itemProps) {
+    const identificator = itemProps.label || itemProps.description;
+    const isString = typeof identificator === 'string' || identificator instanceof String;
+
+    if (identificator && !isString) {
+      warnEmptyKey();
+      `${itemProps.rgItemType}_${JSON.stringify(identificator)}`;
+    }
+
+    return `${itemProps.rgItemType}_${identificator}`;
+  }
+
+  getId(item) {
+    return item != null ? `${this.id}:${item.key || this._deprecatedGenerateKeyFromContent(item)}` : null;
+  }
+
+  get inner() {
+    if (!this._inner) {
+      this._inner = this.container && this.container.querySelector('.ring-list__i');
+    }
+
+    return this._inner;
+  }
+
+  renderVirtualizedInner(_ref3) {
+    let {
+      height,
+      maxHeight,
+      autoHeight = false,
+      rowCount,
+      isScrolling,
+      onChildScroll = noop,
+      scrollTop,
+      registerChild
+    } = _ref3;
+    const dirOverride = {
+      direction: 'auto'
+    }; // Virtualized sets "direction: ltr" by default https://github.com/bvaughn/react-virtualized/issues/457
+
+    return /*#__PURE__*/React.createElement(AutoSizer, {
+      disableHeight: true,
+      onResize: this.props.onResize
+    }, _ref4 => {
+      let {
+        width
+      } = _ref4;
+      return /*#__PURE__*/React.createElement("div", {
+        ref: registerChild
+      }, /*#__PURE__*/React.createElement(VirtualizedList, {
+        "aria-label": this.props.ariaLabel,
+        ref: this.virtualizedListRef,
+        className: "ring-list__i",
+        autoHeight: autoHeight,
+        style: maxHeight ? {
+          maxHeight,
+          height: 'auto',
+          ...dirOverride
+        } : dirOverride,
+        autoContainerWidth: true,
+        height: height,
+        width: width,
+        isScrolling: isScrolling,
+        onScroll: e => {
+          onChildScroll(e);
+          this.scrollEndHandler(e);
+        },
+        scrollTop: scrollTop,
+        rowCount: rowCount,
+        estimatedRowSize: this.defaultItemHeight(),
+        rowHeight: this._cache.rowHeight,
+        rowRenderer: this.renderItem,
+        overscanRowCount: this._bufferSize // ensure rerendering
+        ,
+        noop: () => {},
+        scrollToIndex: !this.props.disableScrollToActive && this.state.needScrollToActive && this.state.activeIndex != null ? this.state.activeIndex + 1 : undefined,
+        scrollToAlignment: "center",
+        deferredMeasurementCache: this._cache,
+        onRowsRendered: this.checkOverflow
+      }));
+    });
+  }
+
+  renderVirtualized(maxHeight, rowCount) {
+    if (maxHeight) {
+      return this.renderVirtualizedInner({
+        height: maxHeight,
+        maxHeight,
+        rowCount
+      });
+    }
+
+    return /*#__PURE__*/React.createElement(WindowScroller, null, props => this.renderVirtualizedInner({ ...props,
+      rowCount,
+      autoHeight: true
+    }));
+  }
+
+  renderSimple(maxHeight, rowCount) {
+    const items = [];
+
+    for (let index = 0; index < rowCount; index++) {
+      items.push(this.renderItem({
+        index,
+        isScrolling: this.state.scrolling
+      }));
+    }
+
+    return /*#__PURE__*/React.createElement("div", {
+      className: classNames('ring-list__i', modules_3b67a421.simpleInner),
+      onScroll: this.scrollHandler,
+      onMouseMove: this.mouseHandler
+    }, /*#__PURE__*/React.createElement("div", {
+      "aria-label": this.props.ariaLabel,
+      role: "grid",
+      style: maxHeight ? {
+        maxHeight: this.getVisibleListHeight(this.props)
+      } : null
+    }, items));
+  }
+
+  /** @override */
+  render() {
+    const hint = this.getSelected() && this.props.hintOnSelection || this.props.hint;
+    const fadeStyles = hint ? {
+      bottom: Dimension.ITEM_HEIGHT
+    } : null;
+    const rowCount = this.props.data.length + 2;
+    const maxHeight = this.props.maxHeight && this.getVisibleListHeight(this.props);
+    const classes = classNames(modules_3b67a421.list, this.props.className);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ActiveItemContext.Updater, {
+      value: this.getId(this.state.activeItem),
+      skipUpdate: this.props.hidden || !isActivatable(this.state.activeItem)
+    }), /*#__PURE__*/React.createElement("div", {
+      id: this.props.id,
+      ref: this.containerRef,
+      className: classes,
+      onMouseOut: this.props.onMouseOut,
+      onBlur: this.props.onMouseOut,
+      onMouseLeave: this.clearSelected,
+      "data-test": "ring-list"
+    }, this.props.shortcuts && /*#__PURE__*/React.createElement(Shortcuts, {
+      map: this.shortcutsMap,
+      scope: this.shortcutsScope
+    }), this.props.renderOptimization ? this.renderVirtualized(maxHeight, rowCount) : this.renderSimple(maxHeight, rowCount), this.state.hasOverflow && !this.state.scrolledToBottom && /*#__PURE__*/React.createElement("div", {
+      className: modules_3b67a421.fade,
+      style: fadeStyles
+    }), hint && /*#__PURE__*/React.createElement(ListHint, {
+      label: hint
+    })));
+  }
+
+}
+
+_defineProperty(List, "propTypes", {
+  id: PropTypes.string,
+  className: PropTypes.string,
+  hint: PropTypes.node,
+  hintOnSelection: PropTypes.string,
+  data: PropTypes.array,
+  maxHeight: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  activeIndex: PropTypes.number,
+  restoreActiveIndex: PropTypes.bool,
+  activateSingleItem: PropTypes.bool,
+  activateFirstItem: PropTypes.bool,
+  shortcuts: PropTypes.bool,
+  onMouseOut: PropTypes.func,
+  onSelect: PropTypes.func,
+  onScrollToBottom: PropTypes.func,
+  onResize: PropTypes.func,
+  useMouseUp: PropTypes.bool,
+  visible: PropTypes.bool,
+  renderOptimization: PropTypes.bool,
+  disableMoveOverflow: PropTypes.bool,
+  disableMoveDownOverflow: PropTypes.bool,
+  compact: PropTypes.bool,
+  disableScrollToActive: PropTypes.bool,
+  hidden: PropTypes.bool,
+  ariaLabel: PropTypes.string
+});
+
+_defineProperty(List, "defaultProps", {
+  data: [],
+  restoreActiveIndex: false,
+  // restore active item using its "key" property
+  activateSingleItem: false,
+  // if there is only one item, activate it
+  activateFirstItem: false,
+  // if there no active items, activate the first one
+  onMouseOut: noop,
+  onSelect: noop,
+  onScrollToBottom: noop,
+  onResize: noop,
+  shortcuts: false,
+  renderOptimization: true,
+  disableMoveDownOverflow: false,
+  ariaLabel: 'List'
+});
+
+_defineProperty(List, "isItemType", isItemType);
+
+_defineProperty(List, "ListHint", ListHint);
+
+_defineProperty(List, "ListProps", {
+  Type,
+  Dimension
+});
+
+export { ActiveItemContext, List as default };