@jetbrains/ring-ui-built 6.0.1

package/components/tags-list/tags-list.d.ts

@@ -0,0 +1,46 @@
+import React, { Component, ComponentType, HTMLAttributes, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+import { TagAttrs } from '../tag/tag';
+declare function noop(): void;
+export interface TagType extends Omit<TagAttrs, 'onClick' | 'children'> {
+    label?: ReactNode;
+    key?: string | number | null | undefined;
+}
+export interface TagsListProps<T extends TagType> extends HTMLAttributes<HTMLElement> {
+    tags: readonly T[];
+    customTagComponent: ComponentType<TagAttrs>;
+    canNotBeEmpty: boolean;
+    disabled: boolean;
+    handleClick: (tag: T) => (e: React.MouseEvent<HTMLElement>) => void;
+    handleRemove: (tag: T) => (e: React.MouseEvent<HTMLElement>) => void;
+    activeIndex?: number | null | undefined;
+    tagClassName?: string | null | undefined;
+}
+/**
+ * @name Tags List
+ */
+export default class TagsList<T extends TagType> extends Component<TagsListProps<T>> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        tags: PropTypes.Requireable<any[]>;
+        customTagComponent: PropTypes.Requireable<PropTypes.ReactComponentLike>;
+        activeIndex: PropTypes.Requireable<number>;
+        canNotBeEmpty: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        handleClick: PropTypes.Requireable<(...args: any[]) => any>;
+        handleRemove: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        tagClassName: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        customTagComponent: null;
+        canNotBeEmpty: boolean;
+        disabled: boolean;
+        handleClick: typeof noop;
+        handleRemove: typeof noop;
+    };
+    renderTag(tag: T, focusTag: boolean): React.JSX.Element;
+    render(): React.JSX.Element;
+}
+export type TagsListAttrs<T extends TagType = TagType> = JSX.LibraryManagedAttributes<typeof TagsList, TagsListProps<T>>;
+export {};

package/components/tags-list/tags-list.js

@@ -0,0 +1,102 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, f as _extends, e as _objectWithoutProperties } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Tag from '../tag/tag.js';
+import 'core-js/modules/es.array.concat.js';
+import '@jetbrains/icons/close-12px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+
+var _excluded = ["children", "className", "customTagComponent", "canNotBeEmpty", "handleClick", "tagClassName", "handleRemove", "tags", "activeIndex"];
+function noop() {}
+/**
+ * @name Tags List
+ */
+var TagsList = /*#__PURE__*/function (_Component) {
+  _inherits(TagsList, _Component);
+  var _super = _createSuper(TagsList);
+  function TagsList() {
+    _classCallCheck(this, TagsList);
+    return _super.apply(this, arguments);
+  }
+  _createClass(TagsList, [{
+    key: "renderTag",
+    value: function renderTag(tag, focusTag) {
+      var TagComponent = this.props.customTagComponent || Tag;
+      var readOnly = this.props.disabled || tag.readOnly || this.props.canNotBeEmpty && this.props.tags.length === 1;
+      var tagClassName = this.props.tagClassName;
+      return /*#__PURE__*/React.createElement(TagComponent, _extends({}, tag, {
+        readOnly: readOnly,
+        disabled: this.props.disabled || tag.disabled,
+        focused: focusTag,
+        onClick: this.props.handleClick(tag),
+        onRemove: this.props.handleRemove(tag),
+        className: tagClassName
+      }), tag.label);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this = this;
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className;
+        _this$props.customTagComponent;
+        _this$props.canNotBeEmpty;
+        _this$props.handleClick;
+        _this$props.tagClassName;
+        _this$props.handleRemove;
+        _this$props.tags;
+        _this$props.activeIndex;
+        var props = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames('ring-js-shortcuts', className);
+      var tagsList = (this.props.tags || []).map(function (tag, index) {
+        return _this.renderTag(tag, _this.props.activeIndex === index);
+      });
+      return /*#__PURE__*/React.createElement("div", _extends({
+        "data-test": "ring-tags-list",
+        className: classes
+      }, props), tagsList, children);
+    }
+  }]);
+  return TagsList;
+}(Component);
+_defineProperty(TagsList, "propTypes", {
+  children: PropTypes.node,
+  tags: PropTypes.array,
+  customTagComponent: PropTypes.elementType,
+  activeIndex: PropTypes.number,
+  canNotBeEmpty: PropTypes.bool,
+  disabled: PropTypes.bool,
+  handleClick: PropTypes.func,
+  handleRemove: PropTypes.func,
+  className: PropTypes.string,
+  tagClassName: PropTypes.string
+});
+_defineProperty(TagsList, "defaultProps", {
+  customTagComponent: null,
+  canNotBeEmpty: false,
+  disabled: false,
+  handleClick: noop,
+  handleRemove: noop
+});
+
+export { TagsList as default };

package/components/text/text.d.ts

@@ -0,0 +1,23 @@
+import React, { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+type TextSize = 's' | 'm' | 'l';
+export interface TextProps extends HTMLAttributes<HTMLElement> {
+    info?: boolean | null | undefined;
+    size?: TextSize;
+    'data-test'?: string | null | undefined;
+}
+declare const TextSize: Record<string, TextSize>;
+/**
+ * @name Text
+ */
+export default class Text extends Component<TextProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        info: PropTypes.Requireable<boolean>;
+        size: PropTypes.Requireable<TextSize>;
+        className: PropTypes.Requireable<string>;
+    };
+    static Size: Record<string, TextSize>;
+    render(): React.JSX.Element;
+}
+export {};

package/components/text/text.js

@@ -0,0 +1,57 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+var modules_78d1bce6 = {"light":"light_rui_2ac4","text":"text_rui_6f30","sizeS":"sizeS_rui_6f30","sizeM":"sizeM_rui_6f30","sizeL":"sizeL_rui_6f30","info":"info_rui_6f30"};
+
+var _excluded = ["children", "className", "info", "size"];
+var TextSize = {
+  S: 's',
+  M: 'm',
+  L: 'l'
+};
+/**
+ * @name Text
+ */
+var Text = /*#__PURE__*/function (_Component) {
+  _inherits(Text, _Component);
+  var _super = _createSuper(Text);
+  function Text() {
+    _classCallCheck(this, Text);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Text, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        info = _this$props.info,
+        size = _this$props.size,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_78d1bce6.text, className, {
+        [modules_78d1bce6.info]: info,
+        [modules_78d1bce6.sizeS]: size === Text.Size.S,
+        [modules_78d1bce6.sizeM]: size === Text.Size.M,
+        [modules_78d1bce6.sizeL]: size === Text.Size.L
+      });
+      return /*#__PURE__*/React.createElement("span", _extends({
+        className: classes
+      }, restProps), children);
+    }
+  }]);
+  return Text;
+}(Component);
+_defineProperty(Text, "propTypes", {
+  children: PropTypes.node,
+  info: PropTypes.bool,
+  size: PropTypes.oneOf(Object.keys(TextSize).map(function (it) {
+    return TextSize[it];
+  })),
+  className: PropTypes.string
+});
+_defineProperty(Text, "Size", TextSize);
+
+export { Text as default };

package/components/toggle/toggle.d.ts

@@ -0,0 +1,39 @@
+import React, { InputHTMLAttributes, PureComponent, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+export declare const Size: {
+    Size14: string;
+    Size16: string;
+    Size20: string;
+};
+/**
+  * @name Toggle
+  */
+export interface ToggleProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    size: string;
+    pale?: boolean | null | undefined;
+    leftLabel?: ReactNode;
+    'data-test'?: string | null | undefined;
+}
+declare class Toggle extends PureComponent<ToggleProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        name: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        title: PropTypes.Requireable<string>;
+        leftLabel: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        defaultChecked: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        pale: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onTransitionEnd: PropTypes.Requireable<(...args: any[]) => any>;
+        size: PropTypes.Requireable<string>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        size: string;
+    };
+    render(): React.JSX.Element;
+}
+export type ToggleAttrs = JSX.LibraryManagedAttributes<typeof Toggle, ToggleProps>;
+export default Toggle;

package/components/toggle/toggle.js

@@ -0,0 +1,86 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.values.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import joinDataTestAttributes from '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
+
+var modules_331c5aa7 = {"padding":"2px","disabled-line-color":"rgba(255, 255, 255, 0.9)","duration":"300ms","timing-function":"cubic-bezier(0.23, 1, 0.32, 1)","light":"light_rui_2ac4","toggle":"toggle_rui_773f","switch":"switch_rui_773f","disabled":"disabled_rui_773f","label":"label_rui_773f","leftLabel":"leftLabel_rui_773f","switchWrapper":"switchWrapper_rui_773f","input":"input_rui_773f","size16":"size16_rui_773f","size14":"size14_rui_773f","size20":"size20_rui_773f","paleSwitch":"paleSwitch_rui_773f"};
+
+var _excluded = ["className", "children", "disabled", "pale", "title", "leftLabel", "size", "data-test", "onTransitionEnd"];
+var Size = {
+  Size14: modules_331c5aa7.size14,
+  Size16: modules_331c5aa7.size16,
+  Size20: modules_331c5aa7.size20
+};
+var Toggle = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Toggle, _PureComponent);
+  var _super = _createSuper(Toggle);
+  function Toggle() {
+    _classCallCheck(this, Toggle);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Toggle, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        disabled = _this$props.disabled,
+        pale = _this$props.pale,
+        title = _this$props.title,
+        leftLabel = _this$props.leftLabel,
+        _this$props$size = _this$props.size,
+        size = _this$props$size === void 0 ? Size.Size16 : _this$props$size,
+        dataTest = _this$props['data-test'],
+        onTransitionEnd = _this$props.onTransitionEnd,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(className, size, modules_331c5aa7.toggle, disabled && modules_331c5aa7.disabled);
+      return /*#__PURE__*/React.createElement("label", {
+        className: classes,
+        title: title,
+        "data-test": joinDataTestAttributes('ring-toggle', dataTest)
+      }, leftLabel && /*#__PURE__*/React.createElement("span", {
+        className: modules_331c5aa7.leftLabel
+      }, leftLabel), /*#__PURE__*/React.createElement("span", {
+        className: modules_331c5aa7.switchWrapper
+      }, /*#__PURE__*/React.createElement("input", _extends({
+        "data-test": "ring-toggle-input"
+      }, restProps, {
+        type: "checkbox",
+        disabled: disabled,
+        className: modules_331c5aa7.input
+      })), /*#__PURE__*/React.createElement("span", {
+        className: classNames(modules_331c5aa7.switch, pale && modules_331c5aa7.paleSwitch),
+        onTransitionEnd: onTransitionEnd
+      })), children && /*#__PURE__*/React.createElement("span", {
+        className: modules_331c5aa7.label
+      }, children));
+    }
+  }]);
+  return Toggle;
+}(PureComponent);
+_defineProperty(Toggle, "propTypes", {
+  children: PropTypes.node,
+  name: PropTypes.string,
+  className: PropTypes.string,
+  title: PropTypes.string,
+  leftLabel: PropTypes.node,
+  defaultChecked: PropTypes.bool,
+  checked: PropTypes.bool,
+  disabled: PropTypes.bool,
+  pale: PropTypes.bool,
+  onChange: PropTypes.func,
+  onTransitionEnd: PropTypes.func,
+  size: PropTypes.oneOf(Object.values(Size)),
+  'data-test': PropTypes.string
+});
+_defineProperty(Toggle, "defaultProps", {
+  size: Size.Size14
+});
+
+export { Size, Toggle as default };

package/components/tooltip/tooltip.d.ts

@@ -0,0 +1,65 @@
+import React, { AllHTMLAttributes, Component, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+import Popup, { PopupAttrs } from '../popup/popup';
+import { Listeners } from '../global/dom';
+interface Context {
+    onNestedTooltipShow: () => void;
+    onNestedTooltipHide: () => void;
+}
+declare const TooltipContext: React.Context<Context | undefined>;
+export interface TooltipProps extends Omit<AllHTMLAttributes<HTMLSpanElement>, 'title'> {
+    delay?: number | null | undefined;
+    selfOverflowOnly?: boolean | null | undefined;
+    popupProps?: Partial<PopupAttrs> | null | undefined;
+    title?: ReactNode | null | undefined;
+    'data-test'?: string | null | undefined;
+    long?: boolean | null | undefined;
+}
+/**
+ * @name Tooltip
+ */
+export default class Tooltip extends Component<TooltipProps> {
+    static propTypes: {
+        delay: PropTypes.Requireable<number>;
+        selfOverflowOnly: PropTypes.Requireable<boolean>;
+        popupProps: PropTypes.Requireable<object>;
+        title: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        title: string;
+        selfOverflowOnly: boolean;
+        popupProps: {};
+    };
+    state: {
+        showPopup: boolean;
+        showNestedPopup: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: TooltipProps): void;
+    componentWillUnmount(): void;
+    static PopupProps: {
+        Directions: typeof import("../popup/popup.consts").Directions;
+        Dimension: typeof import("../popup/popup.consts").Dimension;
+        MinWidth: typeof import("../popup/popup.consts").MinWidth;
+        MaxHeight: typeof import("../popup/popup.consts").MaxHeight;
+    };
+    static contextType: React.Context<Context | undefined>;
+    context: React.ContextType<typeof TooltipContext>;
+    timeout?: number;
+    listeners: Listeners;
+    containerNode?: HTMLElement | null;
+    containerRef: (el: HTMLElement | null) => void;
+    tryToShowPopup: () => void;
+    showPopup: () => void;
+    hidePopup: () => void;
+    addListeners(): void;
+    popup?: Popup | null;
+    popupRef: (el: Popup | null) => void;
+    onNestedTooltipShow: () => void;
+    onNestedTooltipHide: () => void;
+    render(): React.JSX.Element;
+}
+export type TooltipAttrs = JSX.LibraryManagedAttributes<typeof Tooltip, TooltipProps>;
+export {};

package/components/tooltip/tooltip.js

@@ -0,0 +1,229 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { Component, createContext } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Popup from '../popup/popup.js';
+import { Listeners } from '../global/dom.js';
+import joinDataTestAttributes from '../global/data-tests.js';
+import scheduleRAF from '../global/schedule-raf.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-dom';
+import '../global/get-uid.js';
+import '../shortcuts/shortcuts.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.object.assign.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 '../tab-trap/tab-trap.js';
+import 'core-js/modules/es.array.filter.js';
+import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
+import '../popup/popup.consts.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 '../popup/popup.target.js';
+import 'core-js/modules/es.array.reduce.js';
+
+var modules_cd5e45a9 = {"light":"light_rui_2ac4","tooltip":"tooltip_rui_64ba","long":"long_rui_64ba"};
+
+var _excluded = ["children", "data-test", "title", "delay", "selfOverflowOnly", "popupProps", "long"];
+var scheduleScroll = scheduleRAF();
+var TooltipContext = /*#__PURE__*/createContext(undefined);
+/**
+ * @name Tooltip
+ */
+var Tooltip = /*#__PURE__*/function (_Component) {
+  _inherits(Tooltip, _Component);
+  var _super = _createSuper(Tooltip);
+  function Tooltip() {
+    var _this;
+    _classCallCheck(this, Tooltip);
+    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", {
+      showPopup: false,
+      showNestedPopup: false
+    });
+    _defineProperty(_assertThisInitialized(_this), "timeout", void 0);
+    _defineProperty(_assertThisInitialized(_this), "listeners", new Listeners());
+    _defineProperty(_assertThisInitialized(_this), "containerNode", void 0);
+    _defineProperty(_assertThisInitialized(_this), "containerRef", function (el) {
+      _this.containerNode = el;
+    });
+    _defineProperty(_assertThisInitialized(_this), "tryToShowPopup", function () {
+      var _this$props = _this.props,
+        delay = _this$props.delay,
+        title = _this$props.title;
+      if (!title) {
+        return;
+      }
+      if (delay) {
+        _this.timeout = window.setTimeout(_this.showPopup, delay);
+      } else {
+        _this.showPopup();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "showPopup", function () {
+      var _this$context;
+      if (_this.props.selfOverflowOnly) {
+        var _assertThisInitialize = _assertThisInitialized(_this),
+          containerNode = _assertThisInitialize.containerNode;
+        // rare cases when containerNode is null are possible;
+        // probably the collision is due to the asynchronous nature of the code,
+        // i.e. this code runs after the component is unmounted,
+        // although at first glance it looks unlikely.
+        if (!containerNode) {
+          return;
+        }
+        // inline element?
+        if (containerNode.clientWidth === 0 && containerNode.clientHeight === 0) {
+          return;
+        }
+        if (containerNode.scrollWidth <= containerNode.clientWidth && containerNode.scrollHeight <= containerNode.clientHeight) {
+          return;
+        }
+      }
+      (_this$context = _this.context) === null || _this$context === void 0 || _this$context.onNestedTooltipShow();
+      _this.setState({
+        showPopup: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "hidePopup", function () {
+      var _this$context2;
+      clearTimeout(_this.timeout);
+      (_this$context2 = _this.context) === null || _this$context2 === void 0 || _this$context2.onNestedTooltipHide();
+      _this.setState({
+        showPopup: false
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "popup", void 0);
+    _defineProperty(_assertThisInitialized(_this), "popupRef", function (el) {
+      _this.popup = el;
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNestedTooltipShow", function () {
+      _this.setState({
+        showNestedPopup: true
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onNestedTooltipHide", function () {
+      _this.setState({
+        showNestedPopup: false
+      });
+    });
+    return _this;
+  }
+  _createClass(Tooltip, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.props.title) {
+        this.addListeners();
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (!prevProps.title && this.props.title) {
+        this.addListeners();
+      } else if (prevProps.title && !this.props.title) {
+        this.listeners.removeAll();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      clearTimeout(this.timeout);
+      this.listeners.removeAll();
+    }
+  }, {
+    key: "addListeners",
+    value: function addListeners() {
+      var _this2 = this;
+      if (this.containerNode != null) {
+        this.listeners.add(this.containerNode, 'mouseover', this.tryToShowPopup);
+        this.listeners.add(this.containerNode, 'mouseout', this.hidePopup);
+      }
+      this.listeners.add(document, 'scroll', function () {
+        return scheduleScroll(_this2.hidePopup);
+      }, {
+        passive: true
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        children = _this$props2.children,
+        dataTest = _this$props2['data-test'],
+        title = _this$props2.title;
+        _this$props2.delay;
+        _this$props2.selfOverflowOnly;
+        var popupProps = _this$props2.popupProps,
+        long = _this$props2.long,
+        restProps = _objectWithoutProperties(_this$props2, _excluded);
+      var ariaProps = typeof title === 'string' && !!title ? {
+        'aria-label': title,
+        role: 'tooltip'
+      } : {};
+      var onNestedTooltipShow = this.onNestedTooltipShow,
+        onNestedTooltipHide = this.onNestedTooltipHide;
+      return /*#__PURE__*/React.createElement(TooltipContext.Provider, {
+        value: {
+          onNestedTooltipShow,
+          onNestedTooltipHide
+        }
+      }, /*#__PURE__*/React.createElement("span", _extends({}, ariaProps, restProps, {
+        ref: this.containerRef,
+        "data-test": joinDataTestAttributes('ring-tooltip', dataTest),
+        "data-test-title": typeof title === 'string' ? title : undefined
+      }), children, /*#__PURE__*/React.createElement(Popup, _extends({
+        trapFocus: false,
+        hidden: !this.state.showPopup || this.state.showNestedPopup,
+        onCloseAttempt: this.hidePopup,
+        maxHeight: 400,
+        className: classNames(modules_cd5e45a9.tooltip, {
+          [modules_cd5e45a9.long]: long
+        }),
+        attached: false,
+        top: 4,
+        dontCloseOnAnchorClick: true,
+        ref: this.popupRef
+      }, popupProps), title)));
+    }
+  }]);
+  return Tooltip;
+}(Component);
+_defineProperty(Tooltip, "propTypes", {
+  delay: PropTypes.number,
+  selfOverflowOnly: PropTypes.bool,
+  popupProps: PropTypes.object,
+  title: PropTypes.node,
+  children: PropTypes.node,
+  'data-test': PropTypes.string
+});
+_defineProperty(Tooltip, "defaultProps", {
+  title: '',
+  selfOverflowOnly: false,
+  popupProps: {}
+});
+_defineProperty(Tooltip, "PopupProps", Popup.PopupProps);
+_defineProperty(Tooltip, "contextType", TooltipContext);
+
+export { Tooltip as default };