@dnb/eufemia 9.30.0 → 9.32.0

package/cjs/components/tooltip/TooltipHelpers.js

@@ -3,14 +3,98 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.defaultProps = void 0;
+exports.getPropsFromTooltipProp = getPropsFromTooltipProp;
+exports.getRefElement = getRefElement;
+exports.getTargetElement = getTargetElement;
 exports.injectTooltipSemantic = injectTooltipSemantic;
+exports.isTouch = void 0;
+exports.useHandleAria = useHandleAria;
+
+require("core-js/modules/es.regexp.exec.js");
+
+var _react = _interopRequireDefault(require("react"));
 
 var _classnames = _interopRequireDefault(require("classnames"));
 
+var _componentHelper = require("../../shared/component-helper");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function injectTooltipSemantic(params) {
   params.tabIndex = '0';
   params.className = (0, _classnames.default)("dnb-tooltip__wrapper dnb-tab-focus", params.className);
   return params;
-}
+}
+
+var defaultProps = {
+  id: null,
+  group: null,
+  size: 'basis',
+  active: null,
+  position: 'top',
+  arrow: 'center',
+  align: null,
+  animatePosition: false,
+  fixedPosition: false,
+  skipPortal: null,
+  noAnimation: false,
+  showDelay: 300,
+  hideDelay: 500,
+  targetSelector: null,
+  targetElement: null,
+  className: null,
+  children: null,
+  tooltip: null
+};
+exports.defaultProps = defaultProps;
+
+function getTargetElement(target) {
+  if (typeof document !== 'undefined') {
+    return typeof target === 'string' ? typeof document !== 'undefined' && document.querySelector(target) : target;
+  }
+}
+
+function useHandleAria(targetElement, internalId) {
+  _react.default.useEffect(function () {
+    try {
+      var elem = getTargetElement(getRefElement(targetElement));
+
+      if (!(elem !== null && elem !== void 0 && elem.classList.contains('dnb-tooltip__wrapper'))) {
+        var existing = {
+          'aria-describedby': elem.getAttribute('aria-describedby')
+        };
+        elem.setAttribute('aria-describedby', (0, _componentHelper.combineDescribedBy)(existing, internalId));
+      }
+    } catch (e) {}
+  }, [targetElement, internalId]);
+}
+
+function getPropsFromTooltipProp(localProps) {
+  return localProps.tooltip ? _react.default.isValidElement(localProps.tooltip) && localProps.tooltip.props ? localProps.tooltip.props : {
+    children: localProps.tooltip
+  } : null;
+}
+
+function getRefElement(target) {
+  var _unknownTarget$curren;
+
+  var unknownTarget = target;
+  var element = target;
+
+  if (unknownTarget !== null && unknownTarget !== void 0 && (_unknownTarget$curren = unknownTarget.current) !== null && _unknownTarget$curren !== void 0 && _unknownTarget$curren._ref) {
+    element = getRefElement(unknownTarget.current._ref);
+  }
+
+  if (Object.prototype.hasOwnProperty.call(element, 'current')) {
+    element = element.current;
+  }
+
+  return element;
+}
+
+var isTouch = function isTouch(type) {
+  return /touch/i.test(type);
+};
+
+exports.isTouch = isTouch;

package/cjs/components/tooltip/TooltipPortal.d.ts

@@ -1,33 +1,15 @@
-import * as React from 'react';
-export type TooltipPortalTarget = string | Object;
-export type TooltipPortalHideDelay = string | number;
-
 /**
- * NB: Do not change the docs (comments) in here. The docs are updated during build time by "generateTypes.js" and "fetchPropertiesFromDocs.js".
+ * Web Tooltip Component
+ *
  */
-export interface TooltipPortalProps extends React.HTMLProps<HTMLElement> {
-  internal_id?: string;
-  target: TooltipPortalTarget;
-
-  /**
-   * Set to `true` the tooltip will show up.
-   */
-  active?: boolean;
-
-  /**
-   * If the tooltip should animate from one target to the next, define a unique ID.
-   */
-  group?: string;
-
-  /**
-   * Define the delay until the tooltip should disappear up after initial visibility.
-   */
-  hide_delay?: TooltipPortalHideDelay;
-}
-export default class TooltipPortal extends React.Component<
-  TooltipPortalProps,
-  any
-> {
-  static defaultProps: object;
-  render(): JSX.Element;
-}
+import React from 'react';
+import { TooltipProps } from './types';
+declare type TooltipPortalProps = {
+    target: HTMLElement;
+    active: boolean;
+    keepInDOM?: boolean;
+    group?: string;
+    children?: React.ReactNode;
+};
+declare function TooltipPortal(props: TooltipProps & TooltipPortalProps): React.ReactPortal;
+export default TooltipPortal;

package/cjs/components/tooltip/TooltipPortal.js

@@ -1,19 +1,11 @@
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-require("core-js/modules/es.object.get-prototype-of.js");
-
-require("core-js/modules/es.object.to-string.js");
-
-require("core-js/modules/es.reflect.construct.js");
-
-require("core-js/modules/es.object.assign.js");
-
 require("core-js/modules/es.symbol.js");
 
 require("core-js/modules/es.symbol.description.js");
 
+require("core-js/modules/es.object.to-string.js");
+
 require("core-js/modules/es.symbol.iterator.js");
 
 require("core-js/modules/es.array.iterator.js");
@@ -22,12 +14,22 @@ require("core-js/modules/es.string.iterator.js");
 
 require("core-js/modules/web.dom-collections.iterator.js");
 
+require("core-js/modules/es.array.slice.js");
+
+require("core-js/modules/es.function.name.js");
+
+require("core-js/modules/es.array.from.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.object.assign.js");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-require("core-js/modules/es.array.concat.js");
+require("core-js/modules/esnext.global-this.js");
 
 require("core-js/modules/es.parse-float.js");
 
@@ -35,247 +37,191 @@ var _react = _interopRequireDefault(require("react"));
 
 var _reactDom = _interopRequireDefault(require("react-dom"));
 
-var _propTypes = _interopRequireDefault(require("prop-types"));
-
 var _componentHelper = require("../../shared/component-helper");
 
 var _TooltipContainer = _interopRequireDefault(require("./TooltipContainer"));
 
+var _TooltipHelpers = require("./TooltipHelpers");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
 var tooltipPortal;
 
-if (typeof window !== 'undefined') {
-  window.tooltipPortal = window.tooltipPortal || {};
-  tooltipPortal = window.tooltipPortal;
+if (typeof globalThis !== 'undefined') {
+  globalThis.tooltipPortal = globalThis.tooltipPortal || {};
+  tooltipPortal = globalThis.tooltipPortal;
 } else {
   tooltipPortal = {};
 }
 
-var TooltipPortal = function (_React$PureComponent) {
-  _inherits(TooltipPortal, _React$PureComponent);
+function TooltipPortal(props) {
+  var active = props.active,
+      target = props.target,
+      hideDelay = props.hideDelay,
+      keepInDOM = props.keepInDOM,
+      noAnimation = props.noAnimation,
+      children = props.children;
 
-  var _super = _createSuper(TooltipPortal);
+  var _React$useState = _react.default.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      isMounted = _React$useState2[0],
+      setIsMounted = _React$useState2[1];
 
-  function TooltipPortal() {
-    var _this;
+  var _React$useState3 = _react.default.useState(active),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      isActive = _React$useState4[0],
+      setIsActive = _React$useState4[1];
 
-    _classCallCheck(this, TooltipPortal);
+  var _React$useState5 = _react.default.useState(function () {
+    return props.group || (0, _componentHelper.makeUniqueId)();
+  }),
+      _React$useState6 = _slicedToArray(_React$useState5, 1),
+      group = _React$useState6[0];
 
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
+  var isInDOM = _react.default.useRef(false);
 
-    _this = _super.call.apply(_super, [this].concat(args));
+  var hasGroup = props.group;
 
-    _defineProperty(_assertThisInitialized(_this), "state", {
-      isMounted: false
-    });
+  if (tooltipPortal[group]) {
+    tooltipPortal[group].inDOM = isInDOM.current;
+  }
 
-    _defineProperty(_assertThisInitialized(_this), "init", function () {
-      var _this$props = _this.props,
-          group = _this$props.group,
-          active = _this$props.active;
-      tooltipPortal[group] = tooltipPortal[group] || {
-        node: _this.useRootElement(),
-        count: 0
+  var makePortal = function makePortal() {
+    if (!tooltipPortal[group]) {
+      tooltipPortal[group] = {
+        node: hasGroup ? createGroupElement(group) : createRootElement('dnb-tooltip__portal')
       };
-      tooltipPortal[group].count++;
-
-      _this.setState({
-        isMounted: true,
-        active: active
-      }, function () {
-        if (!_this.isMainGorup()) {
-          _this.renderPortal();
-        }
-      });
-    });
+    }
+  };
 
-    _defineProperty(_assertThisInitialized(_this), "renderPortal", function () {
-      var targetElement = _this.getTargetElement();
+  var removeFromDOM = function removeFromDOM() {
+    if (!keepInDOM && hasGroup && tooltipPortal[group] && !tooltipPortal[group].inDOM) {
+      _reactDom.default.unmountComponentAtNode(tooltipPortal[group].node);
+    }
+  };
 
-      var group = _this.props.group;
+  _react.default.useEffect(function () {
+    var _tooltipPortal$group, _tooltipPortal$group2;
 
-      if (!_this.isMainGorup() && tooltipPortal[group]) {
-        clearTimeout(tooltipPortal[group].timeout);
-      }
+    setIsMounted(true);
+    clearTimeout((_tooltipPortal$group = tooltipPortal[group]) === null || _tooltipPortal$group === void 0 ? void 0 : _tooltipPortal$group.delayTimeout);
+    clearTimeout((_tooltipPortal$group2 = tooltipPortal[group]) === null || _tooltipPortal$group2 === void 0 ? void 0 : _tooltipPortal$group2.hiddenTimeout);
 
-      _this.handleAria(targetElement);
-
-      if (_this.isMainGorup()) {
-        return _reactDom.default.createPortal(_react.default.createElement(_TooltipContainer.default, _extends({
-          targetElement: targetElement
-        }, _this.props, {
-          active: _this.state.active
-        })), tooltipPortal[group].node);
-      } else {
-        _reactDom.default.render(_react.default.createElement(_TooltipContainer.default, _extends({
-          targetElement: targetElement
-        }, _this.props, {
-          active: _this.state.active
-        })), tooltipPortal[group].node);
-      }
-    });
+    if (active) {
+      makePortal();
+      setIsActive(true);
+      isInDOM.current = true;
 
-    return _this;
-  }
-
-  _createClass(TooltipPortal, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      if (document.readyState === 'complete') {
-        this.init();
-      } else if (typeof window !== 'undefined') {
-        window.addEventListener('load', this.init);
+      if (hasGroup) {
+        renderPortal(true);
       }
-    }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps) {
-      var _this2 = this;
-
-      var _this$props2 = this.props,
-          group = _this$props2.group,
-          active = _this$props2.active,
-          hide_delay = _this$props2.hide_delay;
-
-      if (tooltipPortal[group] && active !== prevProps.active) {
-        if (active && !prevProps.active) {
-          this.setState({
-            active: true
-          }, function () {
-            if (!_this2.isMainGorup()) {
-              _this2.renderPortal();
-            }
-          });
-        } else if (!active && prevProps.active) {
-          this.timeout = tooltipPortal[group].timeout = setTimeout(function () {
-            _this2.setState({
-              active: false
-            }, function () {
-              if (!_this2.isMainGorup()) {
-                _this2.renderPortal();
-              }
-            });
-          }, parseFloat(hide_delay));
+    } else if (!active && isMounted) {
+      var delayRender = function delayRender() {
+        setIsActive(false);
+
+        if (hasGroup) {
+          renderPortal(false);
         }
+      };
+
+      var delayHidden = function delayHidden() {
+        isInDOM.current = false;
+        removeFromDOM();
+      };
+
+      if (noAnimation || globalThis.IS_TEST) {
+        delayRender();
+        delayHidden();
+      } else if (tooltipPortal[group]) {
+        var delay = parseFloat(String(hideDelay));
+        tooltipPortal[group].delayTimeout = setTimeout(delayRender, delay);
+        tooltipPortal[group].hiddenTimeout = setTimeout(delayHidden, delay + 300);
       }
     }
-  }, {
-    key: "isMainGorup",
-    value: function isMainGorup() {
-      var group = this.props.group;
-      return group === 'main';
+  }, [children, active, group, hideDelay, noAnimation]);
+
+  _react.default.useEffect(function () {
+    if (keepInDOM) {
+      makePortal();
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      var group = this.props.group;
-      clearTimeout(this.timeout);
 
-      if (tooltipPortal[group]) {
-        tooltipPortal[group].count--;
+    return removeFromDOM;
+  }, []);
 
-        if (!this.isMainGorup()) {
-          _reactDom.default.unmountComponentAtNode(tooltipPortal[group].node);
-        }
+  var renderPortal = function renderPortal(isActive) {
+    var _tooltipPortal$group3;
 
-        if (tooltipPortal[group].count === 0) {
-          try {
-            document.body.removeChild(tooltipPortal[group].node);
-          } catch (e) {}
+    var root = (_tooltipPortal$group3 = tooltipPortal[group]) === null || _tooltipPortal$group3 === void 0 ? void 0 : _tooltipPortal$group3.node;
 
-          tooltipPortal[group] = null;
-        }
-      }
+    if (root && hasGroup && isInDOM.current) {
+      _reactDom.default.render(_react.default.createElement(_TooltipContainer.default, _extends({}, props, {
+        targetElement: (0, _TooltipHelpers.getTargetElement)(target),
+        active: isActive
+      })), root);
     }
-  }, {
-    key: "getTargetElement",
-    value: function getTargetElement() {
-      if (typeof document !== 'undefined') {
-        var target = this.props.target;
-        return typeof target === 'string' ? typeof document !== 'undefined' && document.querySelector(target) : target;
-      }
-    }
-  }, {
-    key: "useRootElement",
-    value: function useRootElement() {
-      if (typeof document !== 'undefined') {
-        try {
-          var elem = document.createElement('div');
-          elem.classList.add('dnb-tooltip__portal');
-          elem.classList.add('dnb-core-style');
-          document.body.appendChild(elem);
-          return elem;
-        } catch (e) {
-          (0, _componentHelper.warn)(e);
-        }
-      }
-    }
-  }, {
-    key: "handleAria",
-    value: function handleAria(elem) {
-      try {
-        if (!elem.classList.contains('dnb-tooltip__wrapper')) {
-          var existing = {
-            'aria-describedby': elem.getAttribute('aria-describedby')
-          };
-          elem.setAttribute('aria-describedby', (0, _componentHelper.combineDescribedBy)(existing, this.props.internal_id));
-        }
-      } catch (e) {}
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      if (this.state.isMounted && this.isMainGorup()) {
-        return this.renderPortal();
-      }
 
-      return null;
+    return null;
+  };
+
+  if (!hasGroup) {
+    var _tooltipPortal$group4;
+
+    var root = (_tooltipPortal$group4 = tooltipPortal[group]) === null || _tooltipPortal$group4 === void 0 ? void 0 : _tooltipPortal$group4.node;
+
+    if (root) {
+      return _reactDom.default.createPortal(isInDOM.current || keepInDOM ? _react.default.createElement(_TooltipContainer.default, _extends({}, props, {
+        targetElement: (0, _TooltipHelpers.getTargetElement)(target),
+        active: isActive
+      }), children) : null, root);
     }
-  }]);
+  }
 
-  return TooltipPortal;
-}(_react.default.PureComponent);
+  return null;
+}
 
-exports.default = TooltipPortal;
+var _default = TooltipPortal;
+exports.default = _default;
+
+var createGroupElement = function createGroupElement(id) {
+  try {
+    var elem = document.createElement('div');
+    elem.classList.add('dnb-tooltip__group');
+    elem.setAttribute('id', id);
+    createRootElement('dnb-tooltip__portal').appendChild(elem);
+    return elem;
+  } catch (e) {
+    (0, _componentHelper.warn)(e);
+  }
+};
 
-_defineProperty(TooltipPortal, "defaultProps", {
-  internal_id: null,
-  active: false,
-  group: 'main',
-  hide_delay: 500
-});
+var createRootElement = function createRootElement(className) {
+  try {
+    var element = document.querySelector(".".concat(className));
 
-process.env.NODE_ENV !== "production" ? TooltipPortal.propTypes = {
-  internal_id: _propTypes.default.string,
-  target: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]).isRequired,
-  active: _propTypes.default.bool,
-  group: _propTypes.default.string,
-  hide_delay: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
-} : void 0;
+    if (element) {
+      return element;
+    }
+
+    var elem = document.createElement('div');
+    elem.classList.add(className);
+    elem.classList.add('dnb-core-style');
+    document.body.appendChild(elem);
+    return elem;
+  } catch (e) {
+    (0, _componentHelper.warn)(e);
+  }
+};

package/cjs/components/tooltip/TooltipWithEvents.d.ts

@@ -1,37 +1,13 @@
-import * as React from 'react';
-export type TooltipWithEventsShowDelay = string | number;
-export type TooltipWithEventsTarget =
-  | string
-  | Object
-  | ((...args: any[]) => any)
-  | React.ReactNode;
-export type TooltipWithEventsChildren =
-  | string
-  | ((...args: any[]) => any)
-  | React.ReactNode;
-
 /**
- * NB: Do not change the docs (comments) in here. The docs are updated during build time by "generateTypes.js" and "fetchPropertiesFromDocs.js".
+ * Web Tooltip Component
+ *
  */
-export interface TooltipWithEventsProps
-  extends React.HTMLProps<HTMLElement> {
-  internal_id?: string;
-
-  /**
-   * Define the delay until the tooltip should show up after the initial hover / active state.
-   */
-  show_delay?: TooltipWithEventsShowDelay;
-  target?: TooltipWithEventsTarget;
-
-  /**
-   * Provide a string or a React Element to be shown as the tooltip content.
-   */
-  children?: TooltipWithEventsChildren;
-}
-export default class TooltipWithEvents extends React.Component<
-  TooltipWithEventsProps,
-  any
-> {
-  static defaultProps: object;
-  render(): JSX.Element;
-}
+import React from 'react';
+import { TooltipProps } from './types';
+declare type TooltipWithEventsProps = {
+    target: React.ReactElement & React.RefObject<HTMLElement>;
+    active: boolean;
+    internalId: string;
+};
+declare function TooltipWithEvents(props: TooltipProps & TooltipWithEventsProps): JSX.Element;
+export default TooltipWithEvents;