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

package/dist/permissions/permissions__cache.d.ts

@@ -0,0 +1,93 @@
+export interface PermissionType {
+    key: string;
+}
+export interface Project {
+    id: string;
+}
+export interface Permission {
+    permission: PermissionType;
+    global?: boolean | null | undefined;
+    projects?: readonly Project[] | null | undefined;
+}
+interface PermissionCacheItem {
+    global: boolean | null | undefined;
+    projectIdSet: Record<string, boolean> | null;
+}
+/**
+ * Converts an array of cached permissions to a a map of a permission key
+ * to the respective cached permission.
+ *
+ * @param { {
+ *   permission: {key: string},
+ *   global: boolean?,
+ *   projects: {id: string}[]?
+ * }[] } permissions
+ * @param {function} namesConverter a function, which maps a server-side permission name to client-side permission name
+ * @return {object} permission cache
+ * @private
+ */
+export default class PermissionCache {
+    static GLOBAL_PROJECT_ID: string;
+    /**
+     * Convert an array of projects to a set of project ids.
+     *
+     * @param {object[]=} projects
+     * @return {object} a set of project ids
+     * @private
+     */
+    private static _toProjectIdSet;
+    namesConverter: (name: string) => string | null | undefined;
+    constructor(permissions?: readonly Permission[] | null | undefined, namesConverter?: ((name: string) => string | null | undefined) | null | undefined);
+    private _permissions?;
+    permissionCache?: Record<string, PermissionCacheItem>;
+    set(permissions?: readonly Permission[] | null | undefined): this;
+    get(): readonly Permission[] | null | undefined;
+    /**
+     * Checks if the current user has the given permissions in the project with the given id.
+     *
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permission is granted in any project.
+     *
+     * @return {boolean}
+     */
+    has(permissions?: string | null | undefined, projectId?: string | null | undefined): boolean;
+    /**
+     * Lexes permission query string to an array of lexems.
+     *
+     * @param {string} query
+     * @return {string[]}
+     */
+    lex(query?: string | null | undefined): string[];
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    or(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    and(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    not(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string[]} lexems
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    term(lexems: string[], projectId?: string | null | undefined): boolean;
+    /**
+     * @param {string} permissionName
+     * @param {string=} projectId
+     * @return {boolean}
+     */
+    testPermission(permissionName: string, projectId?: string | null | undefined): boolean;
+}
+export {};

package/dist/permissions/permissions__cache.js

@@ -36,6 +36,12 @@ class PermissionCache {
   }
 
   constructor(permissions, namesConverter) {
+    _defineProperty(this, "namesConverter", void 0);
+
+    _defineProperty(this, "_permissions", void 0);
+
+    _defineProperty(this, "permissionCache", void 0);
+
     this.namesConverter = namesConverter || (key => key);
 
     this.set(permissions);
@@ -232,7 +238,7 @@ class PermissionCache {
         throw new Error('Operator \')\' was expected');
       }
     } else {
-      result = this.testPermission(t, projectId);
+      result = t != null && this.testPermission(t, projectId);
     }
 
     return result;
@@ -246,7 +252,8 @@ class PermissionCache {
 
   testPermission(permissionName, projectId) {
     const permissionCache = this.permissionCache;
-    const cachedPermission = permissionCache[permissionName] || permissionCache[this.namesConverter(permissionName)]; // Hasn't the permission in any project
+    const convertedName = this.namesConverter(permissionName);
+    const cachedPermission = (permissionCache === null || permissionCache === void 0 ? void 0 : permissionCache[permissionName]) || convertedName && (permissionCache === null || permissionCache === void 0 ? void 0 : permissionCache[convertedName]); // Hasn't the permission in any project
 
     if (!cachedPermission) {
       return false;
@@ -259,7 +266,7 @@ class PermissionCache {
 
     if (projectId) {
       // if projectId is specified check that the permission is given in the project
-      return cachedPermission.projectIdSet && projectId in cachedPermission.projectIdSet;
+      return cachedPermission.projectIdSet != null && projectId in cachedPermission.projectIdSet;
     } else {
       return true;
     }

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;
+};