@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/components/dialog/dialog.jsx

@@ -0,0 +1,125 @@
+import React, { PureComponent } from 'react';
+import { createPortal } from 'react-dom';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import closeIcon from '@jetbrains/icons/close';
+import { AdaptiveIsland } from '../island/island';
+import getUID from '../global/get-uid';
+import dataTests from '../global/data-tests';
+import Shortcuts from '../shortcuts/shortcuts';
+import TabTrap from '../tab-trap/tab-trap';
+import Button from '../button/button';
+import { PopupTarget } from '../popup/popup.target';
+import { preventerFactory as scrollPreventerFactory } from './dialog__body-scroll-preventer';
+import styles from './dialog.css';
+/**
+ * @name Dialog
+ */
+function noop() { }
+export default class Dialog extends PureComponent {
+    static propTypes = {
+        label: PropTypes.string,
+        className: PropTypes.string,
+        contentClassName: PropTypes.string,
+        children: PropTypes.oneOfType([
+            PropTypes.arrayOf(PropTypes.node),
+            PropTypes.node
+        ]),
+        show: PropTypes.bool.isRequired,
+        showCloseButton: PropTypes.bool,
+        closeButtonInside: PropTypes.bool,
+        onOverlayClick: PropTypes.func,
+        onEscPress: PropTypes.func,
+        onCloseClick: PropTypes.func,
+        // onCloseAttempt is a common callback for ESC pressing and overlay clicking.
+        // Use it if you don't need different behaviors for this cases.
+        onCloseAttempt: PropTypes.func,
+        // focusTrap may break popups inside dialog, so use it carefully
+        trapFocus: PropTypes.bool,
+        portalTarget: PropTypes.instanceOf(HTMLElement),
+        autoFocusFirst: PropTypes.bool,
+        'data-test': PropTypes.string
+    };
+    static defaultProps = {
+        label: 'Dialog',
+        onOverlayClick: noop,
+        onEscPress: noop,
+        onCloseClick: noop,
+        onCloseAttempt: noop,
+        showCloseButton: false,
+        closeButtonInside: false,
+        trapFocus: false,
+        autoFocusFirst: true
+    };
+    state = {
+        shortcutsScope: getUID('ring-dialog-')
+    };
+    componentDidMount() {
+        this.toggleScrollPreventer();
+    }
+    componentDidUpdate(prevProps) {
+        if (prevProps.show !== this.props.show) {
+            this.toggleScrollPreventer();
+        }
+    }
+    componentWillUnmount() {
+        this.scrollPreventer.reset();
+    }
+    scrollPreventer = scrollPreventerFactory(getUID('preventer-'));
+    uid = getUID('dialog-');
+    toggleScrollPreventer() {
+        if (this.props.show) {
+            this.scrollPreventer.prevent();
+        }
+        else {
+            this.scrollPreventer.reset();
+        }
+    }
+    handleClick = (event) => {
+        this.props.onOverlayClick(event);
+        this.props.onCloseAttempt(event);
+    };
+    onCloseClick = (event) => {
+        this.props.onCloseClick(event);
+        this.props.onCloseAttempt(event);
+    };
+    getShortcutsMap = () => {
+        const onEscape = (event) => {
+            if (this.props.show) {
+                this.props.onEscPress(event);
+                this.props.onCloseAttempt(event);
+            }
+        };
+        return {
+            esc: onEscape
+        };
+    };
+    dialog;
+    dialogRef = (tabTrap) => {
+        this.dialog = tabTrap && tabTrap.node;
+    };
+    render() {
+        const { show, showCloseButton, onOverlayClick, onCloseAttempt, onEscPress, onCloseClick, children, className, contentClassName, trapFocus, 'data-test': dataTest, closeButtonInside, portalTarget, label, ...restProps } = this.props;
+        const classes = classNames(styles.container, className);
+        const shortcutsMap = this.getShortcutsMap();
+        return show && createPortal(<PopupTarget id={this.uid} className={styles.popupTarget}>
+        {target => (<TabTrap trapDisabled={!trapFocus} data-test={dataTests('ring-dialog-container', dataTest)} ref={this.dialogRef} className={classes} role="presentation" {...restProps}>
+              <Shortcuts map={shortcutsMap} scope={this.state.shortcutsScope}/>
+              {(onOverlayClick !== noop || onCloseAttempt !== noop) && (<div 
+                // click handler is duplicated in close button
+                role="presentation" className={styles.clickableOverlay} onClick={this.handleClick}/>)}
+              <div className={styles.innerContainer}>
+                <AdaptiveIsland className={classNames(styles.content, contentClassName)} data-test="ring-dialog" role="dialog" aria-label={label}>
+                  {children}
+                  {showCloseButton &&
+                    (<Button icon={closeIcon} data-test="ring-dialog-close-button" className={classNames(styles.closeButton, {
+                            [styles.closeButtonOutside]: !closeButtonInside,
+                            [styles.closeButtonInside]: closeButtonInside
+                        })} iconClassName={styles.closeIcon} onClick={this.onCloseClick} aria-label="close dialog"/>)}
+                </AdaptiveIsland>
+              </div>
+              {target}
+            </TabTrap>)}
+      </PopupTarget>, portalTarget instanceof HTMLElement ? portalTarget : document.body);
+    }
+}

package/components/dialog/dialog__body-scroll-preventer.d.ts

@@ -0,0 +1,9 @@
+export declare const preventerFactory: (key: string | number) => {
+    prevent: () => void;
+    reset: () => void;
+};
+declare const _default: {
+    prevent: () => void;
+    reset: () => void;
+};
+export default _default;

package/components/dialog/dialog__body-scroll-preventer.js

@@ -1,59 +1,43 @@
 import scrollbarWidth from 'scrollbar-width';
-
 import styles from './dialog.css';
-
 const isPrevented = new Set();
 let previousDocumentWidth = null;
-
-const prevent = key => {
-  if (isPrevented.has(key)) {
-    return;
-  }
-
-  isPrevented.add(key);
-
-  if (isPrevented.size > 1) {
-    return;
-  }
-
-  const documentHasScroll = document.documentElement.scrollHeight > window.innerHeight ||
-    getComputedStyle(document.documentElement).overflowY === 'scroll';
-  document.documentElement.classList.add(styles.documentWithoutScroll);
-
-  const scrollWidth = scrollbarWidth();
-
-  if (documentHasScroll && scrollWidth > 0) {
-    previousDocumentWidth = document.documentElement.style.width;
-    document.documentElement.style.width = `calc(100% - ${scrollWidth}px)`;
-  }
+const prevent = (key) => {
+    if (isPrevented.has(key)) {
+        return;
+    }
+    isPrevented.add(key);
+    if (isPrevented.size > 1) {
+        return;
+    }
+    const documentHasScroll = document.documentElement.scrollHeight > window.innerHeight ||
+        getComputedStyle(document.documentElement).overflowY === 'scroll';
+    document.documentElement.classList.add(styles.documentWithoutScroll);
+    const scrollWidth = scrollbarWidth();
+    if (documentHasScroll && scrollWidth != null && scrollWidth > 0) {
+        previousDocumentWidth = document.documentElement.style.width;
+        document.documentElement.style.width = `calc(100% - ${scrollWidth}px)`;
+    }
 };
-
-const reset = key => {
-  if (isPrevented.size === 0) {
-    return;
-  }
-
-  isPrevented.delete(key);
-
-  if (isPrevented.size > 0) {
-    return;
-  }
-
-  document.documentElement.classList.remove(styles.documentWithoutScroll);
-
-  if (previousDocumentWidth !== null) {
-    document.documentElement.style.width = previousDocumentWidth;
-    previousDocumentWidth = null;
-  }
+const reset = (key) => {
+    if (isPrevented.size === 0) {
+        return;
+    }
+    isPrevented.delete(key);
+    if (isPrevented.size > 0) {
+        return;
+    }
+    document.documentElement.classList.remove(styles.documentWithoutScroll);
+    if (previousDocumentWidth !== null) {
+        document.documentElement.style.width = previousDocumentWidth;
+        previousDocumentWidth = null;
+    }
 };
-
-export const preventerFactory = key => {
-  const preventerKey = key || Math.random();
-
-  return {
-    prevent: () => prevent(preventerKey),
-    reset: () => reset(preventerKey)
-  };
+export const preventerFactory = (key) => {
+    const preventerKey = key || Math.random();
+    return {
+        prevent: () => prevent(preventerKey),
+        reset: () => reset(preventerKey)
+    };
 };
-
 export default preventerFactory('default-preventer');

package/components/dialog-ng/dialog-ng.examples.js

@@ -2,12 +2,12 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import ButtonNG from '@jetbrains/ring-ui/components/button-ng/button-ng';
-import SelectNG from '@jetbrains/ring-ui/components/select-ng/select-ng';
-import InputNG from '@jetbrains/ring-ui/components/input-ng/input-ng';
-import SidebarNG from '@jetbrains/ring-ui/components/sidebar-ng/sidebar-ng';
+import ButtonNG from '../button-ng/button-ng';
+import SelectNG from '../select-ng/select-ng';
+import InputNG from '../input-ng/input-ng';
+import SidebarNG from '../sidebar-ng/sidebar-ng';
 
-import DialogNG from '@jetbrains/ring-ui/components/dialog-ng/dialog-ng';
+import DialogNG from './dialog-ng';
 
 export default {
   title: 'Legacy Angular/Dialog Ng',

package/components/docked-panel-ng/docked-panel-ng.examples.js

@@ -2,10 +2,10 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import PanelNG from '@jetbrains/ring-ui/components/panel-ng/panel-ng';
-import ButtonNG from '@jetbrains/ring-ui/components/button-ng/button-ng';
+import PanelNG from '../panel-ng/panel-ng';
+import ButtonNG from '../button-ng/button-ng';
 
-import DockedPanelNG from '@jetbrains/ring-ui/components/docked-panel-ng/docked-panel-ng';
+import DockedPanelNG from './docked-panel-ng';
 
 export default {
   title: 'Legacy Angular/Docked Panel Ng',

package/components/dropdown/anchor.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { ButtonAttrs } from '../button/button';
+declare const _default: React.MemoExoticComponent<{
+    ({ children, className, ...restProps }: ButtonAttrs): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+    };
+}>;
+export default _default;

package/components/dropdown/anchor.jsx

@@ -0,0 +1,16 @@
+import React, { memo } from 'react';
+import PropTypes from 'prop-types';
+import chevronDown from '@jetbrains/icons/chevron-10px';
+import classNames from 'classnames';
+import Icon from '../icon/icon';
+import Button from '../button/button';
+import styles from './dropdown.css';
+const Anchor = ({ children, className, ...restProps }) => (<Button data-test-ring-dropdown-anchor text className={classNames(styles.anchor, className)} {...restProps}>
+    {children}
+    <Icon glyph={chevronDown} className={styles.chevron}/>
+  </Button>);
+Anchor.propTypes = {
+    children: PropTypes.node,
+    className: PropTypes.string
+};
+export default memo(Anchor);

package/components/dropdown/dropdown.d.ts

@@ -0,0 +1,77 @@
+import React, { Component, HTMLAttributes, ReactNode, ReactElement } from 'react';
+import PropTypes from 'prop-types';
+import { PopupAttrs } from '../popup/popup';
+import Anchor from './anchor';
+export interface AnchorProps {
+    active: boolean;
+    pinned: boolean;
+}
+export interface DropdownProps extends HTMLAttributes<HTMLElement> {
+    anchor: ReactElement | readonly ReactElement[] | string | ((props: AnchorProps) => ReactNode);
+    children: ReactElement<PopupAttrs> | ((props: Omit<PopupAttrs, 'children'>) => ReactNode);
+    initShown: boolean;
+    clickMode: boolean;
+    hoverMode: boolean;
+    hoverShowTimeOut: number;
+    hoverHideTimeOut: number;
+    onShow: (() => void);
+    onHide: (() => void);
+    activeClassName?: string | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+interface DropdownState {
+    show: boolean;
+    pinned: boolean;
+}
+/**
+ * @name Dropdown
+ */
+export default class Dropdown extends Component<DropdownProps, DropdownState> {
+    static propTypes: {
+        /**
+         * Can be string, React element, or a function accepting an object with {active, pinned} properties and returning a React element
+         * React element should render some interactive HTML element like `button` or `a`
+         */
+        anchor: PropTypes.Validator<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+        children: PropTypes.Validator<PropTypes.ReactElementLike | ((...args: any[]) => any)>;
+        initShown: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        activeClassName: PropTypes.Requireable<string>;
+        clickMode: PropTypes.Requireable<boolean>;
+        hoverMode: PropTypes.Requireable<boolean>;
+        hoverShowTimeOut: PropTypes.Requireable<number>;
+        hoverHideTimeOut: PropTypes.Requireable<number>;
+        onShow: PropTypes.Requireable<(...args: any[]) => any>;
+        onHide: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        initShown: boolean;
+        clickMode: boolean;
+        hoverMode: boolean;
+        hoverShowTimeOut: number;
+        hoverHideTimeOut: number;
+        onShow: () => void;
+        onHide: () => void;
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+    state: {
+        show: boolean;
+        pinned: boolean;
+    };
+    onClick: () => void;
+    onChildCloseAttempt: () => void;
+    hoverTimer?: number | null;
+    onMouseEnter: (event: React.MouseEvent<HTMLElement>) => void;
+    onMouseLeave: (event: React.MouseEvent<HTMLElement>) => void;
+    handlePopupInteraction: () => void;
+    toggle(show?: boolean): void;
+    _toggle(show: boolean, pinned?: boolean): void;
+    _clearTimer(): void;
+    render(): JSX.Element;
+}
+export declare type DropdownAttrs = JSX.LibraryManagedAttributes<typeof Dropdown, DropdownProps>;
+export { Anchor };

package/components/dropdown/dropdown.jsx

@@ -0,0 +1,148 @@
+import React, { cloneElement, Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import dataTests from '../global/data-tests';
+import { isArray } from '../global/typescript-utils';
+import Anchor from './anchor';
+import styles from './dropdown.css';
+/**
+ * @name Dropdown
+ */
+export default class Dropdown extends Component {
+    static propTypes = {
+        /**
+         * Can be string, React element, or a function accepting an object with {active, pinned} properties and returning a React element
+         * React element should render some interactive HTML element like `button` or `a`
+         */
+        anchor: PropTypes.oneOfType([PropTypes.node, PropTypes.func]).isRequired,
+        children: PropTypes.oneOfType([PropTypes.element, PropTypes.func]).isRequired,
+        initShown: PropTypes.bool,
+        className: PropTypes.string,
+        activeClassName: PropTypes.string,
+        clickMode: PropTypes.bool,
+        hoverMode: PropTypes.bool,
+        hoverShowTimeOut: PropTypes.number,
+        hoverHideTimeOut: PropTypes.number,
+        onShow: PropTypes.func,
+        onHide: PropTypes.func,
+        onMouseEnter: PropTypes.func,
+        onMouseLeave: PropTypes.func,
+        'data-test': PropTypes.string
+    };
+    static defaultProps = {
+        initShown: false,
+        clickMode: true,
+        hoverMode: false,
+        hoverShowTimeOut: 300,
+        hoverHideTimeOut: 600,
+        onShow: () => { },
+        onHide: () => { },
+        onMouseEnter: () => { },
+        onMouseLeave: () => { }
+    };
+    state = {
+        show: this.props.initShown,
+        pinned: false
+    };
+    onClick = () => {
+        const { show, pinned } = this.state;
+        let nextPinned = pinned;
+        if (this.props.hoverMode) {
+            if (!pinned) {
+                nextPinned = true;
+                if (show) {
+                    this.setState({ pinned: true });
+                    return;
+                }
+            }
+            else {
+                nextPinned = false;
+            }
+        }
+        this._toggle(!show, nextPinned);
+    };
+    onChildCloseAttempt = () => {
+        let nextPinned = this.state.pinned;
+        if (this.props.hoverMode) {
+            nextPinned = false;
+        }
+        this._toggle(false, nextPinned);
+    };
+    hoverTimer;
+    onMouseEnter = (event) => {
+        this._clearTimer();
+        this.props.onMouseEnter?.(event);
+        this.hoverTimer = window.setTimeout(() => {
+            if (!this.state.show) {
+                this._toggle(true);
+            }
+        }, this.props.hoverShowTimeOut);
+    };
+    onMouseLeave = (event) => {
+        this.props.onMouseLeave?.(event);
+        if (this.state.pinned) {
+            return;
+        }
+        this._clearTimer();
+        this.hoverTimer = window.setTimeout(() => {
+            if (this.state.show) {
+                this._toggle(false);
+            }
+        }, this.props.hoverHideTimeOut);
+    };
+    handlePopupInteraction = () => {
+        this.setState(({ pinned }) => (pinned ? null : { pinned: true }));
+    };
+    toggle(show = !this.state.show) {
+        this._toggle(show);
+    }
+    _toggle(show, pinned = this.state.pinned) {
+        this.setState({ show, pinned }, () => (show ? this.props.onShow() : this.props.onHide()));
+    }
+    _clearTimer() {
+        if (this.hoverTimer) {
+            clearTimeout(this.hoverTimer);
+            this.hoverTimer = null;
+        }
+    }
+    render() {
+        const { show, pinned } = this.state;
+        const { initShown, onShow, onHide, hoverShowTimeOut, hoverHideTimeOut, children, anchor, className, activeClassName, hoverMode, clickMode, 'data-test': dataTest, ...restProps } = this.props;
+        const classes = classNames(styles.dropdown, className, {
+            [activeClassName ?? '']: activeClassName != null && show
+        });
+        let anchorElement;
+        const active = hoverMode ? pinned : show;
+        switch (typeof anchor) {
+            case 'string':
+                anchorElement = (<Anchor active={active}>{anchor}</Anchor>);
+                break;
+            case 'function':
+                anchorElement = anchor({ active: show, pinned });
+                break;
+            default:
+                if (isArray(anchor) || typeof anchor.type === 'string') {
+                    anchorElement = anchor;
+                }
+                else {
+                    anchorElement = cloneElement(anchor, { active });
+                }
+        }
+        const childProps = {
+            hidden: !show,
+            onCloseAttempt: this.onChildCloseAttempt,
+            onMouseDown: hoverMode ? this.handlePopupInteraction : undefined,
+            onContextMenu: hoverMode ? this.handlePopupInteraction : undefined,
+            dontCloseOnAnchorClick: true
+        };
+        return (<div data-test={dataTests('ring-dropdown', dataTest)} {...restProps} onClick={clickMode ? this.onClick : undefined} 
+        // anchorElement should be a `button` or an `a`
+        role="presentation" onMouseEnter={hoverMode ? this.onMouseEnter : undefined} onMouseLeave={hoverMode ? this.onMouseLeave : undefined} className={classes}>
+        {anchorElement}
+        {typeof children === 'function'
+                ? children(childProps)
+                : cloneElement(children, childProps)}
+      </div>);
+    }
+}
+export { Anchor };

package/components/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactElement, ReactNodeArray, HTMLAttributes, SyntheticEvent } from 'react';
+import { SelectHandlerParams } from '../list/list';
+import { AnchorProps, DropdownAttrs } from '../dropdown/dropdown';
+import PopupMenu, { PopupMenuAttrs } from '../popup-menu/popup-menu';
+import { ListDataItem } from '../list/consts';
+export interface DropdownAnchorWrapperProps extends AnchorProps {
+    anchor: ReactElement | ReactNodeArray | string | ((props: AnchorProps, ariaProps: HTMLAttributes<HTMLElement>) => ReactElement | null);
+    activeListItemId?: string | null | undefined;
+    listId?: string | undefined;
+}
+export interface DropdownMenuProps<T = unknown> extends Omit<DropdownAttrs, 'anchor' | 'onSelect' | 'children'> {
+    anchor: ReactElement | ReactNodeArray | string | ((props: AnchorProps, ariaProps: HTMLAttributes<HTMLElement>) => ReactElement | null);
+    data?: readonly ListDataItem<T>[] | undefined;
+    ariaLabel?: string | null | undefined;
+    onSelect?: ((item: ListDataItem<T>, event: Event | SyntheticEvent, params?: SelectHandlerParams) => void) | undefined;
+    menuProps?: PopupMenuAttrs<T> | null | undefined;
+}
+declare const _default: (<T = unknown>(props: DropdownMenuProps<T> & {
+    ref?: React.Ref<PopupMenu<unknown>> | undefined;
+}) => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null) & {
+    ListProps: {
+        Type: typeof import("../list/consts").Type;
+        Dimension: typeof import("../list/consts").Dimension;
+    };
+};
+export default _default;

package/components/dropdown-menu/dropdown-menu.jsx

@@ -0,0 +1,56 @@
+import React, { useMemo, cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import List, { ActiveItemContext } from '../list/list';
+import Dropdown from '../dropdown/dropdown';
+import PopupMenu from '../popup-menu/popup-menu';
+import getUID from '../global/get-uid';
+import Anchor from '../dropdown/anchor';
+import { isArray } from '../global/typescript-utils';
+const { children, ...dropdownPropTypes } = Dropdown.propTypes || {};
+const { id: idPropType, data: dataPropType, ariaLabel: ariaLabelPropType, onSelect: onSelectPropType } = PopupMenu.propTypes || {};
+const defaultAriaLabel = 'Dropdown menu';
+function DropdownAnchorWrapper({ anchor, pinned, active, activeListItemId, listId, ...restProps }) {
+    const anchorAriaProps = useMemo(() => ({
+        ...(listId ? { 'aria-haspopup': true } : {}),
+        ...(activeListItemId ? { 'aria-activedescendant': activeListItemId, 'aria-owns': listId } : {}),
+        ...(active ? { 'aria-expanded': true } : {})
+    }), [active, activeListItemId, listId]);
+    const anchorProps = useMemo(() => ({ active, pinned, ...restProps, ...anchorAriaProps }), [pinned, active, restProps, anchorAriaProps]);
+    const anchorComponentProps = useMemo(() => ({ ...anchorProps, pinned: `${anchorProps.pinned}` }), [anchorProps]);
+    if (typeof anchor === 'string') {
+        return (<Anchor {...anchorComponentProps}>{anchor}</Anchor>);
+    }
+    if (typeof anchor === 'function') {
+        return anchor(({ active, pinned, ...restProps }), anchorAriaProps);
+    }
+    if (!isArray(anchor)) {
+        return cloneElement(anchor, typeof anchor.type === 'string' ? anchorAriaProps : anchorComponentProps);
+    }
+    return (<div {...anchorAriaProps}>{anchor}</div>);
+}
+DropdownAnchorWrapper.propTypes = {
+    anchor: PropTypes.oneOfType([PropTypes.node, PropTypes.string, PropTypes.func]).isRequired,
+    pinned: PropTypes.bool,
+    active: PropTypes.bool,
+    activeListItemId: PropTypes.string,
+    listId: PropTypes.string
+};
+const DropdownMenu = React.forwardRef(function DropdownMenu({ id, anchor, ariaLabel, data, onSelect, menuProps, ...restDropdownProps }, forwardedRef) {
+    const listId = useMemo(() => id || getUID('dropdown-menu-list'), [id]);
+    return (<ActiveItemContext.Provider>
+      <Dropdown anchor={({ pinned, active, ...restAnchorProps }) => (<ActiveItemContext.ValueContext.Consumer>
+            {activeItemId => (<DropdownAnchorWrapper anchor={anchor} pinned={pinned} active={active} activeListItemId={activeItemId} listId={listId} {...restAnchorProps}/>)}
+          </ActiveItemContext.ValueContext.Consumer>)} {...restDropdownProps}>
+        <PopupMenu ref={forwardedRef} id={listId} ariaLabel={ariaLabel || defaultAriaLabel} closeOnSelect activateFirstItem data={data} onSelect={onSelect} {...menuProps}/>
+      </Dropdown>
+    </ActiveItemContext.Provider>);
+});
+DropdownMenu.propTypes = {
+    id: idPropType,
+    data: dataPropType,
+    ariaLabel: ariaLabelPropType,
+    onSelect: onSelectPropType,
+    menuProps: PropTypes.object,
+    ...dropdownPropTypes
+};
+export default Object.assign(DropdownMenu, { ListProps: List.ListProps });

package/components/error-bubble/error-bubble.d.ts

@@ -0,0 +1,18 @@
+import { PureComponent, ReactElement } from 'react';
+import PropTypes from 'prop-types';
+export declare type ErrorBubbleProps<P> = Partial<P> & {
+    className?: string | null | undefined;
+    children: ReactElement<P> | ReactElement<P>[];
+    error?: string | null | undefined;
+};
+/**
+ * @name Error Bubble
+ */
+export default class ErrorBubble<P> extends PureComponent<ErrorBubbleProps<P>> {
+    static propTypes: {
+        error: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    render(): JSX.Element;
+}

package/components/error-bubble/error-bubble.jsx

@@ -0,0 +1,28 @@
+import React, { Children, cloneElement, PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Popup from '../popup/popup';
+import { Directions } from '../popup/popup.consts';
+import styles from './error-bubble.css';
+/**
+ * @name Error Bubble
+ */
+export default class ErrorBubble extends PureComponent {
+    static propTypes = {
+        error: PropTypes.string,
+        className: PropTypes.string,
+        children: PropTypes.node
+    };
+    render() {
+        const { children, className, ...restProps } = this.props;
+        const errorBubbleClasses = classNames(styles.errorBubble, className);
+        return (<div className={styles.errorBubbleWrapper}>
+        {Children.map(children, (child) => cloneElement(child, { ...child.props, ...restProps }))}
+        {restProps.error && (<Popup trapFocus={false} className={styles.errorBubblePopup} hidden={false} attached={false} directions={[Directions.RIGHT_CENTER, Directions.RIGHT_BOTTOM, Directions.RIGHT_TOP]}>
+            <div className={errorBubbleClasses} data-test="ring-error-bubble">
+              {restProps.error}
+            </div>
+          </Popup>)}
+      </div>);
+    }
+}