@jetbrains/ring-ui-built 6.0.1

package/components/popup/popup.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @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;
+    autoPositioningOnScroll: boolean;
+    autoCorrectTopOverflow: boolean;
+    left: number;
+    top: number;
+    sidePadding: number;
+    attached: boolean;
+    trapFocus: boolean;
+    autoFocusFirst: boolean;
+    offset: number;
+    legacy: boolean;
+    withTail?: boolean;
+    tailOffset?: number;
+    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;
+    children?: ReactNode;
+}
+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;
+        autoPositioningOnScroll: 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.JSX.Element | P["children"] | undefined;
+    shortcutsScope: string;
+    shortcutsMap: {
+        esc: (evt: KeyboardEvent) => void;
+    };
+    render(): React.JSX.Element;
+}
+export type PopupAttrs = JSX.LibraryManagedAttributes<typeof Popup, PopupProps>;
+export type BasePopupAttrs = JSX.LibraryManagedAttributes<typeof Popup, BasePopupProps>;

package/components/popup/popup.js

@@ -0,0 +1,424 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, g as _objectSpread2, j as _slicedToArray, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import React, { PureComponent } from 'react';
+import { createPortal } from 'react-dom';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import getUID from '../global/get-uid.js';
+import scheduleRAF from '../global/schedule-raf.js';
+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 from './position.js';
+import { Display, DEFAULT_DIRECTIONS, Directions, Dimension, MinWidth, MaxHeight } from './popup.consts.js';
+import { PopupTargetContext, PopupTarget } from './popup.target.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.array.map.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.array.sort.js';
+
+var modules_2f69e2e2 = {"light":"light_rui_2ac4","popup":"popup_rui_7cd4 font_rui_8bff","hidden":"hidden_rui_7cd4","showing":"showing_rui_7cd4","attached":"attached_rui_7cd4"};
+
+var stop = function stop(e) {
+  return e.stopPropagation();
+};
+var getPopupContainer = function getPopupContainer(target) {
+  return typeof target === 'string' ? document.querySelector("[data-portaltarget=".concat(target, "]")) : target;
+};
+/**
+ * @constructor
+ * @name Popup
+ * @extends {ReactComponent}
+ */
+var Popup = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Popup, _PureComponent);
+  var _super = _createSuper(Popup);
+  function Popup() {
+    var _this;
+    _classCallCheck(this, Popup);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "state", {
+      display: Display.SHOWING
+    });
+    _defineProperty(_assertThisInitialized(_this), "popup", void 0);
+    _defineProperty(_assertThisInitialized(_this), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "parent", void 0);
+    _defineProperty(_assertThisInitialized(_this), "container", void 0);
+    _defineProperty(_assertThisInitialized(_this), "ringPopupTarget", void 0);
+    _defineProperty(_assertThisInitialized(_this), "listeners", new Listeners());
+    _defineProperty(_assertThisInitialized(_this), "redrawScheduler", scheduleRAF(true));
+    _defineProperty(_assertThisInitialized(_this), "uid", getUID('popup-'));
+    _defineProperty(_assertThisInitialized(_this), "calculateDisplay", function (prevState) {
+      return _objectSpread2(_objectSpread2({}, prevState), {}, {
+        display: _this.props.hidden ? Display.SHOWING : Display.SHOWN
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "portalRef", function (el) {
+      _this.node = el;
+      _this.parent = el && el.parentElement;
+      if (el && _this.getContainer()) {
+        _this._redraw();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "popupRef", function (el) {
+      _this.popup = el;
+      _this._redraw();
+    });
+    _defineProperty(_assertThisInitialized(_this), "containerRef", function (el) {
+      _this.container = el;
+    });
+    _defineProperty(_assertThisInitialized(_this), "_updateDirection", function (newDirection) {
+      if (_this.state.direction !== newDirection) {
+        _this.setState({
+          direction: newDirection
+        });
+        if (_this.props.onDirectionChange) {
+          _this.props.onDirectionChange(newDirection);
+        }
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "_updatePosition", function () {
+      var popup = _this.popup;
+      if (popup) {
+        popup.style.position = 'absolute';
+        if (_this.isVisible()) {
+          var _this$position = _this.position(),
+            style = _this$position.styles,
+            direction = _this$position.direction;
+          Object.entries(style).forEach(function (_ref) {
+            var _ref2 = _slicedToArray(_ref, 2),
+              key = _ref2[0],
+              value = _ref2[1];
+            var propKey = key;
+            if (typeof value === 'number') {
+              popup.style[propKey] = "".concat(value, "px");
+            } else {
+              popup.style[propKey] = value.toString();
+            }
+          });
+          if (direction != null) {
+            _this._updateDirection(direction);
+          }
+        }
+        _this.setState(_this.calculateDisplay);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "_redraw", function () {
+      if (_this.isVisible()) {
+        _this.redrawScheduler(_this._updatePosition);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "_listenersEnabled", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_onEscPress", function (evt) {
+      _this.props.onEscPress(evt);
+      _this._onCloseAttempt(evt, true);
+    });
+    /**
+     * @param {jQuery.Event} evt
+     * @private
+     */
+    _defineProperty(_assertThisInitialized(_this), "_onDocumentClick", function (evt) {
+      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;
+      }
+      _this.props.onOutsideClick(evt);
+      _this._onCloseAttempt(evt, false);
+    });
+    _defineProperty(_assertThisInitialized(_this), "shortcutsScope", _this.uid);
+    _defineProperty(_assertThisInitialized(_this), "shortcutsMap", {
+      esc: _this._onEscPress
+    });
+    return _this;
+  }
+  _createClass(Popup, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (!this.props.client) {
+        this.setState({
+          client: true
+        });
+      }
+      if (!this.props.hidden) {
+        this._setListenersEnabled(true);
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var hidden = this.props.hidden;
+      if (this.props !== prevProps) {
+        if (prevProps.hidden !== hidden) {
+          this._setListenersEnabled(!hidden);
+        }
+        this._redraw();
+      }
+      if (this.props.onShow && !hidden && this.state.display === Display.SHOWN && (prevProps.hidden || prevState.display !== Display.SHOWN)) {
+        this.props.onShow();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._setListenersEnabled(false);
+    }
+  }, {
+    key: "shouldUseShortcuts",
+    value: function shouldUseShortcuts() {
+      var _this$props = this.props,
+        shortcuts = _this$props.shortcuts,
+        hidden = _this$props.hidden;
+      return shortcuts && !hidden;
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      var target = this.props.target || this.ringPopupTarget;
+      return target && getPopupContainer(target);
+    }
+  }, {
+    key: "position",
+    value: function position$1() {
+      var _this$props2 = this.props,
+        directions = _this$props2.directions,
+        autoPositioning = _this$props2.autoPositioning,
+        autoCorrectTopOverflow = _this$props2.autoCorrectTopOverflow,
+        sidePadding = _this$props2.sidePadding,
+        top = _this$props2.top,
+        left = _this$props2.left,
+        offset = _this$props2.offset,
+        maxHeight = _this$props2.maxHeight,
+        minWidth = _this$props2.minWidth;
+      var container = this.getContainer();
+      return position({
+        popup: this.popup,
+        container: container && getStyles(container).position !== 'static' ? container : null,
+        anchor: this._getAnchor(),
+        directions,
+        autoPositioning,
+        autoCorrectTopOverflow,
+        sidePadding,
+        top,
+        left,
+        offset,
+        maxHeight,
+        minWidth
+      });
+    }
+  }, {
+    key: "_getAnchor",
+    value: function _getAnchor() {
+      return this.props.anchorElement || this.parent;
+    }
+  }, {
+    key: "_setListenersEnabled",
+    value:
+    /**
+     * @param {boolean} enable
+     * @private
+     */
+    function _setListenersEnabled(enable) {
+      var _this2 = this;
+      if (enable && !this._listenersEnabled) {
+        setTimeout(function () {
+          _this2._listenersEnabled = true;
+          _this2.listeners.add(window, 'resize', _this2._redraw);
+          if (_this2.props.autoPositioningOnScroll) {
+            _this2.listeners.add(window, 'scroll', _this2._redraw);
+          }
+          _this2.listeners.add(document, 'pointerdown', _this2._onDocumentClick, true);
+          var el = _this2._getAnchor();
+          while (el) {
+            _this2.listeners.add(el, 'scroll', _this2._redraw);
+            el = el.parentElement;
+          }
+        }, 0);
+        return;
+      }
+      if (!enable && this._listenersEnabled) {
+        this.listeners.removeAll();
+        this._listenersEnabled = false;
+      }
+    }
+    /**
+     * Returns visibility state
+     * @return {boolean}
+     */
+  }, {
+    key: "isVisible",
+    value: function isVisible() {
+      return !this.props.hidden;
+    }
+  }, {
+    key: "_onCloseAttempt",
+    value: function _onCloseAttempt(evt, isEsc) {
+      this.props.onCloseAttempt(evt, isEsc);
+    }
+  }, {
+    key: "getInternalContent",
+    value: function getInternalContent() {
+      var _this$props3 = this.props,
+        trapFocus = _this$props3.trapFocus,
+        autoFocusFirst = _this$props3.autoFocusFirst,
+        children = _this$props3.children;
+      return trapFocus ? /*#__PURE__*/React.createElement(TabTrap, {
+        autoFocusFirst: autoFocusFirst,
+        focusBackOnExit: true
+      }, children) : children;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      var _this$props4 = this.props,
+        className = _this$props4.className,
+        style = _this$props4.style,
+        hidden = _this$props4.hidden,
+        attached = _this$props4.attached,
+        keepMounted = _this$props4.keepMounted,
+        client = _this$props4.client,
+        onMouseDown = _this$props4.onMouseDown,
+        onMouseUp = _this$props4.onMouseUp,
+        onMouseOver = _this$props4.onMouseOver,
+        onMouseOut = _this$props4.onMouseOut,
+        onContextMenu = _this$props4.onContextMenu,
+        dataTest = _this$props4['data-test'];
+      var showing = this.state.display === Display.SHOWING;
+      var classes = classNames(className, modules_2f69e2e2.popup, {
+        [modules_2f69e2e2.attached]: attached,
+        [modules_2f69e2e2.hidden]: hidden,
+        [modules_2f69e2e2.showing]: showing
+      });
+      var direction = (this.state.direction || '').toLowerCase().replace(/[_]/g, '-');
+      return /*#__PURE__*/React.createElement(PopupTargetContext.Consumer, null, function (value) {
+        _this3.ringPopupTarget = value;
+        return /*#__PURE__*/React.createElement("span", {
+          // prevent bubbling through portal
+          onClick: stop
+          // This handler only blocks bubbling through React portal
+          ,
+          role: "presentation",
+          ref: _this3.portalRef
+        }, _this3.shouldUseShortcuts() && /*#__PURE__*/React.createElement(Shortcuts, {
+          map: _this3.shortcutsMap,
+          scope: _this3.shortcutsScope
+        }), (client || _this3.state.client) && (keepMounted || !hidden) && /*#__PURE__*/createPortal( /*#__PURE__*/React.createElement(PopupTarget, {
+          id: _this3.uid,
+          ref: _this3.containerRef,
+          onMouseOver: onMouseOver,
+          onFocus: onMouseOver,
+          onMouseOut: onMouseOut,
+          onBlur: onMouseOut,
+          onContextMenu: onContextMenu
+        }, /*#__PURE__*/React.createElement("div", {
+          "data-test": joinDataTestAttributes('ring-popup', dataTest),
+          "data-test-shown": !hidden && !showing,
+          "data-test-direction": direction,
+          ref: _this3.popupRef,
+          className: classes,
+          style: style,
+          onMouseDown: onMouseDown,
+          onMouseUp: onMouseUp
+          // mouse handlers are used to track clicking on inner elements
+          ,
+          role: "presentation"
+        }, _this3.getInternalContent())), _this3.getContainer() || document.body));
+      });
+    }
+  }]);
+  return Popup;
+}(PureComponent);
+_defineProperty(Popup, "defaultProps", {
+  shortcuts: true,
+  hidden: false,
+  onOutsideClick() {},
+  onEscPress() {},
+  onCloseAttempt() {},
+  dontCloseOnAnchorClick: false,
+  keepMounted: false,
+  directions: DEFAULT_DIRECTIONS,
+  autoPositioning: true,
+  autoPositioningOnScroll: 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,
+  style: PropTypes.object,
+  hidden: PropTypes.bool.isRequired,
+  onOutsideClick: PropTypes.func,
+  onEscPress: PropTypes.func,
+  // onCloseAttempt is a common callback for ESC pressing and outside clicking.
+  // Use it if you don't need different behaviors for this cases.
+  onCloseAttempt: PropTypes.func,
+  children: PropTypes.node.isRequired,
+  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,
+  left: PropTypes.number,
+  top: PropTypes.number,
+  maxHeight: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  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,
+  onMouseOut: PropTypes.func,
+  onContextMenu: PropTypes.func,
+  onDirectionChange: PropTypes.func,
+  onShow: PropTypes.func,
+  // set to true whenever popup contains focusable and scrollable content
+  trapFocus: PropTypes.bool,
+  autoFocusFirst: PropTypes.bool
+};
+
+export { PopupTarget, PopupTargetContext, Popup as default, getPopupContainer };

package/components/popup/popup.target.d.ts

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

package/components/popup/popup.target.js

@@ -0,0 +1,24 @@
+import { e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { createContext, forwardRef } from 'react';
+import PropTypes from 'prop-types';
+
+var _excluded = ["id", "children"];
+var PopupTargetContext = /*#__PURE__*/createContext(undefined);
+var PopupTarget = /*#__PURE__*/forwardRef(function PopupTarget(_ref, ref) {
+  var id = _ref.id,
+    children = _ref.children,
+    restProps = _objectWithoutProperties(_ref, _excluded);
+  var target = /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+    "data-portaltarget": id,
+    ref: ref
+  }), typeof children !== 'function' && children);
+  return /*#__PURE__*/React.createElement(PopupTargetContext.Provider, {
+    value: id
+  }, typeof children === 'function' ? children(target) : target);
+});
+PopupTarget.propTypes = {
+  id: PropTypes.string.isRequired,
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
+};
+
+export { PopupTarget, PopupTargetContext };

package/components/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: HTMLElement | 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;
+};