@jetbrains/ring-ui 4.1.3 → 5.0.0-beta.0

package/dist/popup/popup.consts.d.ts

@@ -0,0 +1,37 @@
+export declare enum Directions {
+    BOTTOM_RIGHT = "BOTTOM_RIGHT",
+    BOTTOM_LEFT = "BOTTOM_LEFT",
+    BOTTOM_CENTER = "BOTTOM_CENTER",
+    TOP_LEFT = "TOP_LEFT",
+    TOP_RIGHT = "TOP_RIGHT",
+    TOP_CENTER = "TOP_CENTER",
+    RIGHT_TOP = "RIGHT_TOP",
+    RIGHT_BOTTOM = "RIGHT_BOTTOM",
+    RIGHT_CENTER = "RIGHT_CENTER",
+    LEFT_TOP = "LEFT_TOP",
+    LEFT_BOTTOM = "LEFT_BOTTOM",
+    LEFT_CENTER = "LEFT_CENTER"
+}
+/**
+ * When positioning a popup, directions will be tried in the listed order.
+ * @type {Array.<string>}
+ */
+export declare const DEFAULT_DIRECTIONS: Directions[];
+/**
+ * @enum {number}
+ */
+export declare enum Dimension {
+    MARGIN = 16,
+    BORDER_WIDTH = 1
+}
+export declare enum MinWidth {
+    TARGET = -1
+}
+export declare enum MaxHeight {
+    SCREEN = -1
+}
+export declare enum Display {
+    HIDDEN = 0,
+    SHOWING = 1,
+    SHOWN = 2
+}

package/dist/popup/popup.consts.js

@@ -1,41 +1,55 @@
-const Directions = {
-  BOTTOM_RIGHT: 'BOTTOM_RIGHT',
-  BOTTOM_LEFT: 'BOTTOM_LEFT',
-  BOTTOM_CENTER: 'BOTTOM_CENTER',
-  TOP_LEFT: 'TOP_LEFT',
-  TOP_RIGHT: 'TOP_RIGHT',
-  TOP_CENTER: 'TOP_CENTER',
-  RIGHT_TOP: 'RIGHT_TOP',
-  RIGHT_BOTTOM: 'RIGHT_BOTTOM',
-  RIGHT_CENTER: 'RIGHT_CENTER',
-  LEFT_TOP: 'LEFT_TOP',
-  LEFT_BOTTOM: 'LEFT_BOTTOM',
-  LEFT_CENTER: 'LEFT_CENTER'
-};
+var Directions;
+
+(function (Directions) {
+  Directions["BOTTOM_RIGHT"] = "BOTTOM_RIGHT";
+  Directions["BOTTOM_LEFT"] = "BOTTOM_LEFT";
+  Directions["BOTTOM_CENTER"] = "BOTTOM_CENTER";
+  Directions["TOP_LEFT"] = "TOP_LEFT";
+  Directions["TOP_RIGHT"] = "TOP_RIGHT";
+  Directions["TOP_CENTER"] = "TOP_CENTER";
+  Directions["RIGHT_TOP"] = "RIGHT_TOP";
+  Directions["RIGHT_BOTTOM"] = "RIGHT_BOTTOM";
+  Directions["RIGHT_CENTER"] = "RIGHT_CENTER";
+  Directions["LEFT_TOP"] = "LEFT_TOP";
+  Directions["LEFT_BOTTOM"] = "LEFT_BOTTOM";
+  Directions["LEFT_CENTER"] = "LEFT_CENTER";
+})(Directions || (Directions = {}));
 /**
  * When positioning a popup, directions will be tried in the listed order.
  * @type {Array.<string>}
  */
 
+
 const DEFAULT_DIRECTIONS = [Directions.BOTTOM_RIGHT, Directions.BOTTOM_LEFT, Directions.TOP_LEFT, Directions.TOP_RIGHT, Directions.RIGHT_TOP, Directions.RIGHT_BOTTOM, Directions.LEFT_TOP, Directions.LEFT_BOTTOM];
 /**
  * @enum {number}
  */
 
-const Dimension = {
-  MARGIN: 16,
-  BORDER_WIDTH: 1
-};
-const MinWidth = {
-  TARGET: -1
-};
-const MaxHeight = {
-  SCREEN: -1
-};
-const Display = {
-  HIDDEN: 0,
-  SHOWING: 1,
-  SHOWN: 2
-};
+var Dimension;
+
+(function (Dimension) {
+  Dimension[Dimension["MARGIN"] = 16] = "MARGIN";
+  Dimension[Dimension["BORDER_WIDTH"] = 1] = "BORDER_WIDTH";
+})(Dimension || (Dimension = {}));
+
+var MinWidth;
+
+(function (MinWidth) {
+  MinWidth[MinWidth["TARGET"] = -1] = "TARGET";
+})(MinWidth || (MinWidth = {}));
+
+var MaxHeight;
+
+(function (MaxHeight) {
+  MaxHeight[MaxHeight["SCREEN"] = -1] = "SCREEN";
+})(MaxHeight || (MaxHeight = {}));
+
+var Display;
+
+(function (Display) {
+  Display[Display["HIDDEN"] = 0] = "HIDDEN";
+  Display[Display["SHOWING"] = 1] = "SHOWING";
+  Display[Display["SHOWN"] = 2] = "SHOWN";
+})(Display || (Display = {}));
 
 export { DEFAULT_DIRECTIONS, Dimension, Directions, Display, MaxHeight, MinWidth };

package/dist/popup/popup.d.ts

@@ -0,0 +1,141 @@
+/**
+ * @name Popup
+ */
+import React, { PureComponent, ReactNode, CSSProperties, SyntheticEvent } from 'react';
+import { Listeners } from '../global/dom';
+import { PositionStyles } from './position';
+import { Dimension, Directions, Display, MaxHeight, MinWidth } from './popup.consts';
+import { PopupTargetContext, PopupTarget } from './popup.target';
+export { PopupTargetContext, PopupTarget };
+export declare const getPopupContainer: (target: string | Element) => Element | null;
+export interface BasePopupProps {
+    hidden: boolean;
+    onOutsideClick: (e: PointerEvent) => void;
+    onEscPress: (e: KeyboardEvent) => void;
+    onCloseAttempt: (e?: Event | SyntheticEvent, isEsc?: boolean | undefined) => void;
+    dontCloseOnAnchorClick: boolean;
+    shortcuts: boolean;
+    keepMounted: boolean;
+    directions: readonly Directions[];
+    autoPositioning: boolean;
+    autoCorrectTopOverflow: boolean;
+    left: number;
+    top: number;
+    sidePadding: number;
+    attached: boolean;
+    trapFocus: boolean;
+    autoFocusFirst: boolean;
+    offset: number;
+    legacy: boolean;
+    anchorElement?: HTMLElement | null | undefined;
+    target?: string | Element | null | undefined;
+    className?: string | null | undefined;
+    style?: CSSProperties | undefined;
+    'data-test'?: string | null | undefined;
+    client?: boolean | null | undefined;
+    maxHeight?: number | 'screen' | null | undefined;
+    minWidth?: number | 'target' | null | undefined;
+    onMouseDown?: ((e: React.MouseEvent<HTMLElement>) => void) | undefined;
+    onMouseUp?: ((e: React.MouseEvent<HTMLElement>) => void) | undefined;
+    onMouseOver?: ((e: React.SyntheticEvent<HTMLElement>) => void) | undefined;
+    onMouseOut?: ((e: React.SyntheticEvent<HTMLElement>) => void) | undefined;
+    onContextMenu?: ((e: React.MouseEvent<HTMLElement>) => void) | undefined;
+    onDirectionChange?: ((direction: Directions) => void) | null | undefined;
+    onShow?: (() => void) | null | undefined;
+}
+export interface PopupProps extends BasePopupProps {
+    children: ReactNode;
+}
+interface PopupState {
+    display: Display;
+    client?: boolean;
+    direction?: Directions;
+}
+/**
+ * @constructor
+ * @name Popup
+ * @extends {ReactComponent}
+ */
+export default class Popup<P extends BasePopupProps = PopupProps> extends PureComponent<P, PopupState> {
+    static defaultProps: {
+        shortcuts: boolean;
+        hidden: boolean;
+        onOutsideClick(): void;
+        onEscPress(): void;
+        onCloseAttempt(): void;
+        dontCloseOnAnchorClick: boolean;
+        keepMounted: boolean;
+        directions: Directions[];
+        autoPositioning: boolean;
+        autoCorrectTopOverflow: boolean;
+        left: number;
+        top: number;
+        offset: number;
+        sidePadding: number;
+        attached: boolean;
+        trapFocus: boolean;
+        autoFocusFirst: boolean;
+        legacy: boolean;
+    };
+    state: PopupState;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: BasePopupProps, prevState: PopupState): void;
+    componentWillUnmount(): void;
+    popup?: HTMLElement | null;
+    node?: HTMLElement | null;
+    parent?: HTMLElement | null;
+    container?: HTMLElement | null;
+    ringPopupTarget?: string | Element;
+    shouldUseShortcuts(): boolean;
+    listeners: Listeners;
+    redrawScheduler: (cb: () => void) => void;
+    uid: string;
+    calculateDisplay: (prevState: PopupState) => {
+        display: Display;
+        client?: boolean | undefined;
+        direction?: Directions | undefined;
+    };
+    static PopupProps: {
+        Directions: typeof Directions;
+        Dimension: typeof Dimension;
+        MinWidth: typeof MinWidth;
+        MaxHeight: typeof MaxHeight;
+    };
+    portalRef: (el: HTMLElement | null) => void;
+    popupRef: (el: HTMLElement | null) => void;
+    containerRef: (el: HTMLElement | null) => void;
+    getContainer(): "" | Element | null | undefined;
+    position(): {
+        styles: PositionStyles;
+        direction: Directions | null;
+    };
+    private _updateDirection;
+    private _updatePosition;
+    private _redraw;
+    private _getAnchor;
+    private _listenersEnabled?;
+    /**
+     * @param {boolean} enable
+     * @private
+     */
+    private _setListenersEnabled;
+    /**
+     * Returns visibility state
+     * @return {boolean}
+     */
+    isVisible(): boolean;
+    _onCloseAttempt(evt?: Event | SyntheticEvent, isEsc?: boolean): void;
+    private _onEscPress;
+    /**
+     * @param {jQuery.Event} evt
+     * @private
+     */
+    private _onDocumentClick;
+    getInternalContent(): React.ReactNode;
+    shortcutsScope: string;
+    shortcutsMap: {
+        esc: (evt: KeyboardEvent) => void;
+    };
+    render(): JSX.Element;
+}
+export declare type PopupAttrs = JSX.LibraryManagedAttributes<typeof Popup, PopupProps>;

package/dist/popup/popup.js

@@ -9,7 +9,7 @@ import { Listeners, getStyles } from '../global/dom.js';
 import Shortcuts from '../shortcuts/shortcuts.js';
 import joinDataTestAttributes from '../global/data-tests.js';
 import TabTrap from '../tab-trap/tab-trap.js';
-import position, { positionPropKeys } from './position.js';
+import position from './position.js';
 import { Display, DEFAULT_DIRECTIONS, Directions, Dimension, MinWidth, MaxHeight } from './popup.consts.js';
 import { PopupTargetContext, PopupTarget } from './popup.target.js';
 export { PopupTarget, PopupTargetContext } from './popup.target.js';
@@ -37,6 +37,16 @@ class Popup extends PureComponent {
       display: Display.SHOWING
     });
 
+    _defineProperty(this, "popup", void 0);
+
+    _defineProperty(this, "node", void 0);
+
+    _defineProperty(this, "parent", void 0);
+
+    _defineProperty(this, "container", void 0);
+
+    _defineProperty(this, "ringPopupTarget", void 0);
+
     _defineProperty(this, "listeners", new Listeners());
 
     _defineProperty(this, "redrawScheduler", scheduleRAF(true));
@@ -79,25 +89,30 @@ class Popup extends PureComponent {
     });
 
     _defineProperty(this, "_updatePosition", () => {
-      if (this.popup) {
-        this.popup.style.position = 'absolute';
+      const popup = this.popup;
+
+      if (popup) {
+        popup.style.position = 'absolute';
 
         if (this.isVisible()) {
           const {
             styles: style,
             direction
           } = this.position();
-          Object.keys(style).forEach(key => {
-            const value = style[key];
+          Object.entries(style).forEach(_ref => {
+            let [key, value] = _ref;
+            const propKey = key;
 
             if (typeof value === 'number') {
-              this.popup.style[key] = `${value}px`;
+              popup.style[propKey] = `${value}px`;
             } else {
-              this.popup.style[key] = value.toString();
+              popup.style[propKey] = value.toString();
             }
           });
 
-          this._updateDirection(direction);
+          if (direction != null) {
+            this._updateDirection(direction);
+          }
         }
 
         this.setState(this.calculateDisplay);
@@ -110,6 +125,8 @@ class Popup extends PureComponent {
       }
     });
 
+    _defineProperty(this, "_listenersEnabled", void 0);
+
     _defineProperty(this, "_onEscPress", evt => {
       this.props.onEscPress(evt);
 
@@ -117,7 +134,9 @@ class Popup extends PureComponent {
     });
 
     _defineProperty(this, "_onDocumentClick", evt => {
-      if (this.container && this.container.contains(evt.target) || !this._listenersEnabled || this.props.dontCloseOnAnchorClick && this._getAnchor() && this._getAnchor().contains(evt.target)) {
+      var _this$_getAnchor;
+
+      if (this.container && evt.target instanceof Node && this.container.contains(evt.target) || !this._listenersEnabled || this.props.dontCloseOnAnchorClick && evt.target instanceof Node && (_this$_getAnchor = this._getAnchor()) !== null && _this$_getAnchor !== void 0 && _this$_getAnchor.contains(evt.target)) {
         return;
       }
 
@@ -184,28 +203,42 @@ class Popup extends PureComponent {
   }
 
   position() {
-    const positionProps = positionPropKeys.reduce((acc, key) => {
-      acc[key] = this.props[key];
-      return acc;
-    }, {});
+    const {
+      directions,
+      autoPositioning,
+      autoCorrectTopOverflow,
+      sidePadding,
+      top,
+      left,
+      offset,
+      maxHeight,
+      minWidth
+    } = this.props;
     const container = this.getContainer();
     return position({
       popup: this.popup,
       container: container && getStyles(container).position !== 'static' ? container : null,
       anchor: this._getAnchor(),
-      ...positionProps
+      directions,
+      autoPositioning,
+      autoCorrectTopOverflow,
+      sidePadding,
+      top,
+      left,
+      offset,
+      maxHeight,
+      minWidth
     });
   }
 
   _getAnchor() {
     return this.props.anchorElement || this.parent;
   }
+
   /**
    * @param {boolean} enable
    * @private
    */
-
-
   _setListenersEnabled(enable) {
     if (enable && !this._listenersEnabled) {
       setTimeout(() => {
@@ -313,7 +346,39 @@ class Popup extends PureComponent {
 
 }
 
-_defineProperty(Popup, "propTypes", {
+_defineProperty(Popup, "defaultProps", {
+  shortcuts: true,
+  hidden: false,
+
+  onOutsideClick() {},
+
+  onEscPress() {},
+
+  onCloseAttempt() {},
+
+  dontCloseOnAnchorClick: false,
+  keepMounted: false,
+  directions: DEFAULT_DIRECTIONS,
+  autoPositioning: true,
+  autoCorrectTopOverflow: true,
+  left: 0,
+  top: 0,
+  offset: 0,
+  sidePadding: 8,
+  attached: false,
+  trapFocus: false,
+  autoFocusFirst: false,
+  legacy: false
+});
+
+_defineProperty(Popup, "PopupProps", {
+  Directions,
+  Dimension,
+  MinWidth,
+  MaxHeight
+});
+
+Popup.propTypes = {
   anchorElement: PropTypes.instanceOf(Node),
   target: PropTypes.oneOfType([PropTypes.string, PropTypes.instanceOf(Element)]),
   className: PropTypes.string,
@@ -328,10 +393,8 @@ _defineProperty(Popup, "propTypes", {
   dontCloseOnAnchorClick: PropTypes.bool,
   shortcuts: PropTypes.bool,
   keepMounted: PropTypes.bool,
-  // pass this prop to preserve the popup's DOM state while hidden
   'data-test': PropTypes.string,
   client: PropTypes.bool,
-  // true means that it's never used in SSR
   directions: PropTypes.arrayOf(PropTypes.string),
   autoPositioning: PropTypes.bool,
   autoCorrectTopOverflow: PropTypes.bool,
@@ -341,7 +404,6 @@ _defineProperty(Popup, "propTypes", {
   minWidth: PropTypes.number,
   sidePadding: PropTypes.number,
   attached: PropTypes.bool,
-  // Popup adjacent to an input, without upper border and shadow
   onMouseDown: PropTypes.func,
   onMouseUp: PropTypes.func,
   onMouseOver: PropTypes.func,
@@ -352,38 +414,6 @@ _defineProperty(Popup, "propTypes", {
   // set to true whenever popup contains focusable and scrollable content
   trapFocus: PropTypes.bool,
   autoFocusFirst: PropTypes.bool
-});
-
-_defineProperty(Popup, "defaultProps", {
-  shortcuts: true,
-  hidden: false,
-
-  onOutsideClick() {},
-
-  onEscPress() {},
-
-  onCloseAttempt() {},
-
-  dontCloseOnAnchorClick: false,
-  keepMounted: false,
-  directions: DEFAULT_DIRECTIONS,
-  autoPositioning: true,
-  autoCorrectTopOverflow: true,
-  left: 0,
-  top: 0,
-  offset: 0,
-  sidePadding: 8,
-  attached: false,
-  trapFocus: false,
-  autoFocusFirst: false,
-  legacy: false
-});
-
-_defineProperty(Popup, "PopupProps", {
-  Directions,
-  Dimension,
-  MinWidth,
-  MaxHeight
-});
+};
 
 export { Popup as default, getPopupContainer };

package/dist/popup/popup.target.d.ts

@@ -0,0 +1,6 @@
+import React, { HTMLAttributes, ReactNode } from 'react';
+export declare const PopupTargetContext: React.Context<string | undefined>;
+export interface PopupTargetProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode | ((target: ReactNode) => ReactNode);
+}
+export declare const PopupTarget: React.ForwardRefExoticComponent<PopupTargetProps & React.RefAttributes<HTMLDivElement>>;

package/dist/popup/popup.target.js

@@ -2,21 +2,20 @@ import { a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { createContext, forwardRef } from 'react';
 import PropTypes from 'prop-types';
 
-const PopupTargetContext = /*#__PURE__*/createContext();
+const PopupTargetContext = /*#__PURE__*/createContext(undefined);
 const PopupTarget = /*#__PURE__*/forwardRef(function PopupTarget(_ref, ref) {
   let {
     id,
     children,
     ...restProps
   } = _ref;
-  const isFunctionChild = typeof children === 'function';
   const target = /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
     "data-portaltarget": id,
     ref: ref
-  }), !isFunctionChild && children);
+  }), typeof children !== 'function' && children);
   return /*#__PURE__*/React.createElement(PopupTargetContext.Provider, {
     value: id
-  }, isFunctionChild ? children(target) : target);
+  }, typeof children === 'function' ? children(target) : target);
 });
 PopupTarget.propTypes = {
   id: PropTypes.string.isRequired,

package/dist/popup/position.d.ts

@@ -0,0 +1,30 @@
+import { Dimension, Directions, MaxHeight, MinWidth } from './popup.consts';
+export { Dimension, Directions, MaxHeight, MinWidth };
+interface Position {
+    top: number;
+    left: number;
+}
+export interface PositionStyles extends Position {
+    maxHeight?: number;
+    minWidth?: number;
+}
+export interface PositionAttrs {
+    popup: Element | null | undefined;
+    anchor: Element | null | undefined;
+    container: Element | null;
+    directions: readonly Directions[];
+    autoPositioning: boolean;
+    sidePadding: number;
+    top: number;
+    left: number;
+    offset: number;
+    maxHeight: number | 'screen' | null | undefined;
+    minWidth: number | 'target' | null | undefined;
+    autoCorrectTopOverflow: boolean;
+}
+export declare const positionPropKeys: readonly ["directions", "autoPositioning", "autoCorrectTopOverflow", "sidePadding", "top", "left", "offset", "maxHeight", "minWidth"];
+export declare function maxHeightForDirection(direction: Directions, anchorNode: Element, containerNode?: Element | null): number | null;
+export default function position(attrs: PositionAttrs): {
+    styles: PositionStyles;
+    direction: Directions | null;
+};

package/dist/popup/position.js

@@ -126,15 +126,15 @@ function handleTopOffScreen(_ref) {
     RIGHT_TOP,
     LEFT_TOP
   } = Directions;
-  const openedToTop = [TOP_LEFT, TOP_RIGHT, TOP_CENTER, RIGHT_TOP, LEFT_TOP].includes(direction);
+  const openedToTop = direction != null && [TOP_LEFT, TOP_RIGHT, TOP_CENTER, RIGHT_TOP, LEFT_TOP].includes(direction);
 
   if (!openedToTop) {
     return styles;
   }
 
-  const isAttachedToAnchorTop = [TOP_LEFT, TOP_CENTER, TOP_RIGHT].includes(direction);
+  const isAttachedToAnchorTop = direction != null && [TOP_LEFT, TOP_CENTER, TOP_RIGHT].includes(direction);
   const attachingPointY = isAttachedToAnchorTop ? anchorRect.top : anchorRect.bottom;
-  const effectiveHeight = maxHeight ? Math.min(popupScrollHeight, maxHeight) : popupScrollHeight;
+  const effectiveHeight = maxHeight && typeof maxHeight === 'number' ? Math.min(popupScrollHeight, maxHeight) : popupScrollHeight;
   const hypotheticalTop = attachingPointY - effectiveHeight;
 
   if (hypotheticalTop <= sidePadding) {
@@ -212,6 +212,9 @@ function position(attrs) {
   const anchorTop = anchorRect.top + scroll.top + top - containerRect.top;
 
   if (popup) {
+    const overflowAttrs = { ...attrs,
+      popup
+    };
     const directionsMatrix = getPositionStyles(popup, anchorRect, anchorLeft, anchorTop, offset);
 
     if (!autoPositioning || directions.length === 1) {
@@ -229,8 +232,8 @@ function position(attrs) {
         let {
           styles: stylesB
         } = _ref3;
-        const overflowA = verticalOverflow(stylesA, scroll, attrs) + horizontalOverflow(stylesA, scroll, attrs);
-        const overflowB = verticalOverflow(stylesB, scroll, attrs) + horizontalOverflow(stylesB, scroll, attrs);
+        const overflowA = verticalOverflow(stylesA, scroll, overflowAttrs) + horizontalOverflow(stylesA, scroll, overflowAttrs);
+        const overflowB = verticalOverflow(stylesB, scroll, overflowAttrs) + horizontalOverflow(stylesB, scroll, overflowAttrs);
         return overflowA - overflowB;
       });
       styles = sortedByIncreasingOverflow[0].styles;
@@ -253,13 +256,15 @@ function position(attrs) {
   }
 
   if (autoCorrectTopOverflow) {
+    var _popup$scrollHeight;
+
     styles = handleTopOffScreen({
       sidePadding,
       styles,
       anchorRect,
       maxHeight,
       direction: chosenDirection,
-      popupScrollHeight: popup.scrollHeight,
+      popupScrollHeight: (_popup$scrollHeight = popup === null || popup === void 0 ? void 0 : popup.scrollHeight) !== null && _popup$scrollHeight !== void 0 ? _popup$scrollHeight : 0,
       scroll
     });
   }

package/dist/popup-menu/popup-menu.d.ts

@@ -0,0 +1,59 @@
+import { SyntheticEvent } from 'react';
+import Popup, { BasePopupProps } from '../popup/popup';
+import List, { ListProps as ListPropsType } from '../list/list';
+import { ListDataItem } from '../list/consts';
+export interface PopupMenuProps<T = unknown> extends Omit<ListPropsType<T>, 'maxHeight' | 'hidden'>, Omit<BasePopupProps, 'onMouseOut'> {
+    closeOnSelect: boolean;
+}
+/**
+ * @name Popup Menu
+ */
+export default class PopupMenu<T = unknown> extends Popup<PopupMenuProps<T>> {
+    static isItemType: <T_1>(listItemType: import("../list/consts").Type, item: ListDataItem<T_1>) => boolean;
+    static ListProps: {
+        Type: typeof import("../list/consts").Type;
+        Dimension: typeof import("../list/consts").Dimension;
+    };
+    static defaultProps: {
+        renderOptimization: boolean;
+        closeOnSelect: boolean;
+        shortcuts: boolean;
+        hidden: boolean;
+        onOutsideClick(): void;
+        onEscPress(): void;
+        onCloseAttempt(): void;
+        dontCloseOnAnchorClick: boolean;
+        keepMounted: boolean;
+        directions: import("../popup/popup.consts").Directions[];
+        autoPositioning: boolean;
+        autoCorrectTopOverflow: boolean;
+        left: number;
+        top: number;
+        offset: number;
+        sidePadding: number;
+        attached: boolean;
+        trapFocus: boolean;
+        autoFocusFirst: boolean;
+        legacy: boolean;
+        data: never[];
+        restoreActiveIndex: boolean;
+        activateSingleItem: boolean;
+        activateFirstItem: boolean;
+        onMouseOut: () => void;
+        onSelect: () => void;
+        onScrollToBottom: () => void;
+        onResize: () => void;
+        disableMoveDownOverflow: boolean;
+        ariaLabel: string;
+    };
+    onSelect: (item: ListDataItem<T>, event: Event | SyntheticEvent) => void;
+    list?: List<T> | null;
+    listRef: (el: List<T> | null) => void;
+    /** @override */
+    getInternalContent(): JSX.Element;
+}
+export declare type PopupMenuAttrs<T = unknown> = JSX.LibraryManagedAttributes<typeof PopupMenu, PopupMenuProps<T>>;
+export declare const ListProps: {
+    Type: typeof import("../list/consts").Type;
+    Dimension: typeof import("../list/consts").Dimension;
+};