@atlaskit/teams-app-internal-popup-adaptor 1.1.0

package/dist/esm/useHoverDelay.js

@@ -0,0 +1,34 @@
+import { useCallback, useEffect, useRef } from 'react';
+
+/**
+ * Hook for managing delayed hover actions with timeout management.
+ */
+function useHoverDelay(callback, delay) {
+  var timeoutRef = useRef(null);
+  var callbackRef = useRef(callback);
+  useEffect(function () {
+    callbackRef.current = callback;
+  }, [callback]);
+  var clear = useCallback(function () {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  var schedule = useCallback(function () {
+    clear();
+    timeoutRef.current = window.setTimeout(function () {
+      callbackRef.current();
+    }, delay);
+  }, [delay, clear]);
+  useEffect(function () {
+    return function () {
+      return clear();
+    };
+  }, [clear]);
+  return {
+    schedule: schedule,
+    clear: clear
+  };
+}
+export { useHoverDelay };

package/dist/esm/useHoverTriggerRef.js

@@ -0,0 +1,149 @@
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
+import { bind } from 'bind-event-listener';
+import { useHoverDelay } from './useHoverDelay';
+import { getChildPortalFromParentPopup, hasRelatedTarget, isMovingToKudos } from './utils';
+var HOVER_OPEN_DELAY = 800;
+var HOVER_CLOSE_DELAY = 200;
+/**
+ * Hover behavior for popup trigger and content with delayed open/close.
+ */
+export function useHoverTriggerRef(_ref) {
+  var onOpen = _ref.onOpen,
+    onClose = _ref.onClose,
+    _ref$isOpen = _ref.isOpen,
+    isOpen = _ref$isOpen === void 0 ? false : _ref$isOpen,
+    _ref$isDisabled = _ref.isDisabled,
+    isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled,
+    openedByRef = _ref.openedByRef,
+    _ref$delays = _ref.delays,
+    delays = _ref$delays === void 0 ? {} : _ref$delays;
+  var _delays$hoverOpen = delays.hoverOpen,
+    hoverOpen = _delays$hoverOpen === void 0 ? HOVER_OPEN_DELAY : _delays$hoverOpen,
+    _delays$hoverClose = delays.hoverClose,
+    hoverClose = _delays$hoverClose === void 0 ? HOVER_CLOSE_DELAY : _delays$hoverClose;
+  var triggerNodeRef = useRef(null);
+  var triggerListeners = useRef([]);
+  var contentNodeRef = useRef(null);
+  var contentListeners = useRef(new Map());
+  var isOpenRef = useRef(isOpen);
+  useLayoutEffect(function () {
+    isOpenRef.current = isOpen;
+  }, [isOpen]);
+  var openDelay = useHoverDelay(function () {
+    if (isOpenRef.current) {
+      return;
+    }
+    if (openedByRef) {
+      openedByRef.current = 'hover';
+    }
+    onOpen();
+  }, hoverOpen);
+  var closeDelay = useHoverDelay(function () {
+    if (!isOpenRef.current) {
+      return;
+    }
+    if (!openedByRef || openedByRef.current === 'hover') {
+      onClose === null || onClose === void 0 || onClose();
+    }
+  }, hoverClose);
+  var openDelayRef = useRef(openDelay);
+  var closeDelayRef = useRef(closeDelay);
+  openDelayRef.current = openDelay;
+  closeDelayRef.current = closeDelay;
+  var handleTriggerEnter = useCallback(function () {
+    closeDelayRef.current.clear();
+    openDelayRef.current.schedule();
+  }, []);
+  var handleTriggerLeave = useCallback(function () {
+    openDelayRef.current.clear();
+    closeDelayRef.current.schedule();
+  }, []);
+  var triggerRef = useCallback(function (element) {
+    if (element === triggerNodeRef.current) {
+      return;
+    }
+    triggerListeners.current.forEach(function (unbind) {
+      return unbind();
+    });
+    triggerListeners.current = [];
+    triggerNodeRef.current = element;
+    if (element && !isDisabled) {
+      triggerListeners.current.push(bind(element, {
+        type: 'mouseenter',
+        listener: handleTriggerEnter
+      }), bind(element, {
+        type: 'mouseleave',
+        listener: handleTriggerLeave
+      }));
+    }
+  }, [handleTriggerEnter, handleTriggerLeave, isDisabled]);
+  var handleContentEnter = useCallback(function () {
+    closeDelayRef.current.clear();
+  }, []);
+  var cleanupContentListeners = useCallback(function () {
+    contentListeners.current.forEach(function (unbind) {
+      return unbind();
+    });
+    contentListeners.current.clear();
+  }, []);
+  var attachContentListeners = useCallback(function (element) {
+    if (contentListeners.current.has(element)) {
+      return;
+    }
+    var handleMouseLeave = function handleMouseLeave(event) {
+      if (!hasRelatedTarget(event)) {
+        return;
+      }
+      var relatedTarget = event.relatedTarget;
+      if (isMovingToKudos(relatedTarget)) {
+        return;
+      }
+      var childPortal = getChildPortalFromParentPopup(relatedTarget, contentNodeRef.current);
+      if (childPortal) {
+        attachContentListeners(childPortal);
+        return;
+      }
+      closeDelayRef.current.schedule();
+    };
+    var unbindEnter = bind(element, {
+      type: 'mouseenter',
+      listener: handleContentEnter
+    });
+    var unbindLeave = bind(element, {
+      type: 'mouseleave',
+      listener: handleMouseLeave
+    });
+    contentListeners.current.set(element, function () {
+      unbindEnter();
+      unbindLeave();
+    });
+  }, [handleContentEnter]);
+  var contentRef = useCallback(function (element) {
+    if (element === contentNodeRef.current) {
+      return;
+    }
+    cleanupContentListeners();
+    contentNodeRef.current = element;
+    if (element && !isDisabled) {
+      attachContentListeners(element);
+    }
+  }, [attachContentListeners, cleanupContentListeners, isDisabled]);
+  useEffect(function () {
+    var listeners = contentListeners.current;
+    var triggers = triggerListeners.current;
+    return function () {
+      openDelayRef.current.clear();
+      closeDelayRef.current.clear();
+      triggers.forEach(function (unbind) {
+        return unbind();
+      });
+      listeners.forEach(function (unbind) {
+        return unbind();
+      });
+    };
+  }, []);
+  return {
+    triggerRef: triggerRef,
+    contentRef: contentRef
+  };
+}

package/dist/esm/usePreloadRef.js

@@ -0,0 +1,113 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { bind } from 'bind-event-listener';
+var PRELOAD_MAX_AGE = 5 * 60 * 1000;
+var TIME_TO_INTENT = 200;
+export function usePreloadRef(_ref) {
+  var load = _ref.load,
+    onLoad = _ref.onLoad;
+  var nodeRef = useRef(null);
+  var eventListeners = useRef([]);
+  var _useMemo = useMemo(function () {
+      var request = {};
+      var clearPreloadTimeouts = function clearPreloadTimeouts() {
+        if (request.preloadIntentTimeout != null) {
+          clearTimeout(request.preloadIntentTimeout);
+          delete request.preloadIntentTimeout;
+        }
+        if (request.preloadMaxAgeTimeout != null) {
+          clearTimeout(request.preloadMaxAgeTimeout);
+          delete request.preloadMaxAgeTimeout;
+        }
+      };
+      var cancelPreload = function cancelPreload() {
+        var _request$preload;
+        clearPreloadTimeouts();
+        (_request$preload = request.preload) === null || _request$preload === void 0 || _request$preload.dispose();
+      };
+      var loadReference = function loadReference() {
+        var _request$preload$refe, _request$preload2;
+        if (request.load) {
+          return request.load;
+        }
+        var reference = (_request$preload$refe = (_request$preload2 = request.preload) === null || _request$preload2 === void 0 ? void 0 : _request$preload2.reference) !== null && _request$preload$refe !== void 0 ? _request$preload$refe : load();
+        if (request.preload) {
+          delete request.preload;
+        }
+        request.load = {
+          reference: reference,
+          dispose: function dispose() {
+            reference.dispose();
+            delete request.load;
+          }
+        };
+        return request.load;
+      };
+      var loadAndOpen = function loadAndOpen() {
+        clearPreloadTimeouts();
+        onLoad(loadReference());
+      };
+      var preloadReference = function preloadReference() {
+        if (request.preloadIntentTimeout || request.preload) {
+          return;
+        }
+        request.preloadIntentTimeout = setTimeout(function () {
+          delete request.preloadIntentTimeout;
+          var reference = load();
+          request.preload = {
+            reference: reference,
+            dispose: function dispose() {
+              reference.dispose();
+              delete request.preload;
+            }
+          };
+          request.preloadMaxAgeTimeout = setTimeout(function () {
+            var _request$preload3;
+            delete request.preloadMaxAgeTimeout;
+            (_request$preload3 = request.preload) === null || _request$preload3 === void 0 || _request$preload3.dispose();
+          }, PRELOAD_MAX_AGE);
+        }, TIME_TO_INTENT);
+      };
+      return {
+        loadAndOpen: loadAndOpen,
+        preloadReference: preloadReference,
+        cancelPreload: cancelPreload
+      };
+    }, [load, onLoad]),
+    loadAndOpen = _useMemo.loadAndOpen,
+    preloadReference = _useMemo.preloadReference,
+    cancelPreload = _useMemo.cancelPreload;
+  var cleanUpEventListeners = useCallback(function () {
+    eventListeners.current.forEach(function (unbind) {
+      unbind();
+    });
+    eventListeners.current = [];
+  }, []);
+  var addEventListener = useCallback(function (element, type, callback) {
+    var unbind = bind(element, {
+      type: type,
+      listener: callback
+    });
+    eventListeners.current.push(unbind);
+  }, []);
+  var refCallback = useCallback(function (element) {
+    if (element !== nodeRef.current) {
+      if (nodeRef.current) {
+        cancelPreload();
+        cleanUpEventListeners();
+      }
+      if (element) {
+        addEventListener(element, 'mouseenter', preloadReference);
+        addEventListener(element, 'mouseleave', cancelPreload);
+      }
+      nodeRef.current = element;
+    }
+  }, [preloadReference, cancelPreload, addEventListener, cleanUpEventListeners]);
+  useEffect(function () {
+    return function () {
+      cleanUpEventListeners();
+    };
+  }, [cleanUpEventListeners]);
+  return Object.assign(refCallback, {
+    loadAndOpen: loadAndOpen
+  });
+}

package/dist/esm/usePressableTriggerRef.js

@@ -0,0 +1,63 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { bind } from 'bind-event-listener';
+export function usePressableTriggerRef(_ref) {
+  var onOpen = _ref.onOpen,
+    onClose = _ref.onClose,
+    _ref$isOpen = _ref.isOpen,
+    isOpen = _ref$isOpen === void 0 ? false : _ref$isOpen,
+    _ref$isDisabled = _ref.isDisabled,
+    isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled,
+    openedByRef = _ref.openedByRef;
+  var nodeRef = useRef(null);
+  var eventListeners = useRef([]);
+  var handleOpen = useCallback(function () {
+    if (isOpen) {
+      onClose === null || onClose === void 0 || onClose();
+    } else {
+      if (openedByRef) {
+        openedByRef.current = 'click';
+      }
+      onOpen();
+    }
+  }, [isOpen, onClose, openedByRef, onOpen]);
+  var keydownListener = useCallback(function (event) {
+    if (event instanceof KeyboardEvent && (event.key === 'Enter' || event.key === ' ')) {
+      event.preventDefault();
+      handleOpen();
+    }
+  }, [handleOpen]);
+  var cleanUpEventListeners = useCallback(function () {
+    eventListeners.current.forEach(function (unbind) {
+      unbind();
+    });
+    eventListeners.current = [];
+  }, []);
+  var addEventListener = useCallback(function (element, type, callback) {
+    var unbind = bind(element, {
+      type: type,
+      listener: callback
+    });
+    eventListeners.current.push(unbind);
+  }, []);
+  var refCallback = useCallback(function (element) {
+    if (element !== nodeRef.current) {
+      if (nodeRef.current) {
+        cleanUpEventListeners();
+      }
+      if (element) {
+        if (!isDisabled) {
+          addEventListener(element, 'click', handleOpen);
+        }
+        // Always attach keydown for keyboard accessibility
+        addEventListener(element, 'keydown', keydownListener);
+      }
+      nodeRef.current = element;
+    }
+  }, [handleOpen, keydownListener, addEventListener, cleanUpEventListeners, isDisabled]);
+  useEffect(function () {
+    return function () {
+      cleanUpEventListeners();
+    };
+  }, [cleanUpEventListeners]);
+  return refCallback;
+}

package/dist/esm/utils.js

@@ -0,0 +1,41 @@
+/**
+ * Type guard to check if an event has a relatedTarget property.
+ */
+function hasRelatedTarget(event) {
+  return 'relatedTarget' in event;
+}
+
+/**
+ * Checks if the mouse is moving to an atlaskit portal or kudos modal
+ * where we should prevent the popup from closing
+ */
+function isMovingToKudos(relatedTarget) {
+  var _relatedTarget$closes;
+  if (!(relatedTarget instanceof HTMLElement)) {
+    return false;
+  }
+  var iframe = ((_relatedTarget$closes = relatedTarget.closest('.atlaskit-portal')) === null || _relatedTarget$closes === void 0 ? void 0 : _relatedTarget$closes.querySelector('iframe')) || relatedTarget.closest('iframe');
+  return iframe instanceof HTMLIFrameElement && iframe.src.includes('give-kudos');
+}
+
+/**
+ * Returns the child portal if mouse is moving to a portal controlled by the parent popup.
+ */
+function getChildPortalFromParentPopup(relatedTarget, parentPopupElement) {
+  if (!(relatedTarget instanceof HTMLElement) || !parentPopupElement) {
+    return null;
+  }
+  var portal = relatedTarget.closest('.atlaskit-portal');
+  if (!portal) {
+    return null;
+  }
+  for (var _i = 0, _Array$from = Array.from(parentPopupElement.querySelectorAll('[aria-controls]')); _i < _Array$from.length; _i++) {
+    var trigger = _Array$from[_i];
+    var controlsId = trigger.getAttribute('aria-controls');
+    if (controlsId && portal.querySelector("#".concat(controlsId))) {
+      return portal;
+    }
+  }
+  return null;
+}
+export { hasRelatedTarget, isMovingToKudos, getChildPortalFromParentPopup };

package/dist/types/PopupTriggerWithHover.d.ts

@@ -0,0 +1,28 @@
+import React, { type ReactNode } from 'react';
+import { type ContentProps, type PopupProps, type TriggerProps } from '@atlaskit/popup';
+import type { AnyEntryPoint, GetRuntimePropsFromEntryPoint, ParamsOfEntryPoint } from '@atlassian/entry-point-types';
+import { type ErrorCallback, type ErrorFallback } from '@atlassian/internal-entry-point-container';
+export type TriggerMode = 'hover' | 'click' | Array<'hover' | 'click'>;
+type UnionOmit<T, K extends string | number | symbol> = T extends unknown ? Omit<T, K> : never;
+type CustomPopupProps = UnionOmit<PopupProps, 'isOpen' | 'content'>;
+type EntryPointPropsType<TEntryPoint> = GetRuntimePropsFromEntryPoint<TEntryPoint>;
+export type PopupTriggerWithHoverProps<TEntryPoint> = {
+    entryPoint: TEntryPoint;
+    entryPointParams?: ParamsOfEntryPoint<TEntryPoint>;
+    entryPointProps?: Omit<EntryPointPropsType<TEntryPoint>, 'onClose' | 'onContentResized'> & {
+        onClose?: () => void;
+        onContentResized?: ContentProps['update'];
+    };
+    errorFallback?: ErrorFallback;
+    fallback?: ReactNode;
+    forcedReportErrorUFO?: boolean;
+    onError?: ErrorCallback;
+    onOpen?: (method: 'hover' | 'click') => void;
+    trigger: (triggerProps: TriggerProps) => ReactNode;
+    /**
+     * How the popup should be triggered. Defaults to `'click'` when omitted.
+     */
+    triggerMode?: TriggerMode;
+} & CustomPopupProps;
+export declare function PopupTriggerWithHover<TEntryPoint extends AnyEntryPoint>({ trigger, triggerMode, entryPoint, entryPointParams, entryPointProps, fallback, errorFallback, onError, forcedReportErrorUFO, onOpen, onClose, ...popupProps }: PopupTriggerWithHoverProps<TEntryPoint>): React.JSX.Element;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { PopupTriggerWithHover, type PopupTriggerWithHoverProps, type TriggerMode, } from './PopupTriggerWithHover';

package/dist/types/useHoverDelay.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook for managing delayed hover actions with timeout management.
+ */
+declare function useHoverDelay(callback: () => void, delay: number): {
+    schedule: () => void;
+    clear: () => void;
+};
+export { useHoverDelay };

package/dist/types/useHoverTriggerRef.d.ts

@@ -0,0 +1,19 @@
+import { type MutableRefObject } from 'react';
+export type UseHoverTriggerRefProps = {
+    onOpen: () => void;
+    onClose?: () => void;
+    isOpen?: boolean;
+    isDisabled?: boolean;
+    openedByRef?: MutableRefObject<'hover' | 'click' | null>;
+    delays?: {
+        hoverOpen?: number;
+        hoverClose?: number;
+    };
+};
+/**
+ * Hover behavior for popup trigger and content with delayed open/close.
+ */
+export declare function useHoverTriggerRef({ onOpen, onClose, isOpen, isDisabled, openedByRef, delays, }: UseHoverTriggerRefProps): {
+    triggerRef: (element: HTMLElement | null) => void;
+    contentRef: (element: HTMLElement | null) => void;
+};

package/dist/types/usePreloadRef.d.ts

@@ -0,0 +1,13 @@
+export type OnLoad<T> = (obj: {
+    dispose: () => void;
+    reference: T;
+}) => void;
+export type UsePreloadRefProps<T> = {
+    load: () => T;
+    onLoad: OnLoad<T>;
+};
+export declare function usePreloadRef<T extends {
+    dispose: () => void;
+}>({ load, onLoad, }: UsePreloadRefProps<T>): ((element: HTMLElement | null) => void) & {
+    loadAndOpen: () => void;
+};

package/dist/types/usePressableTriggerRef.d.ts

@@ -0,0 +1,9 @@
+import { type MutableRefObject } from 'react';
+export type UsePressableTriggerRefProps = {
+    onOpen: () => void;
+    onClose?: () => void;
+    isOpen?: boolean;
+    isDisabled?: boolean;
+    openedByRef?: MutableRefObject<'hover' | 'click' | null>;
+};
+export declare function usePressableTriggerRef({ onOpen, onClose, isOpen, isDisabled, openedByRef, }: UsePressableTriggerRefProps): (element: HTMLElement | null) => void;

package/dist/types/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type guard to check if an event has a relatedTarget property.
+ */
+declare function hasRelatedTarget(event: Event): event is Event & {
+    relatedTarget: EventTarget | null;
+};
+/**
+ * Checks if the mouse is moving to an atlaskit portal or kudos modal
+ * where we should prevent the popup from closing
+ */
+declare function isMovingToKudos(relatedTarget: EventTarget | null): boolean;
+/**
+ * Returns the child portal if mouse is moving to a portal controlled by the parent popup.
+ */
+declare function getChildPortalFromParentPopup(relatedTarget: EventTarget | null, parentPopupElement: HTMLElement | null): Element | null;
+export { hasRelatedTarget, isMovingToKudos, getChildPortalFromParentPopup };

package/dist/types-ts4.5/PopupTriggerWithHover.d.ts

@@ -0,0 +1,28 @@
+import React, { type ReactNode } from 'react';
+import { type ContentProps, type PopupProps, type TriggerProps } from '@atlaskit/popup';
+import type { AnyEntryPoint, GetRuntimePropsFromEntryPoint, ParamsOfEntryPoint } from '@atlassian/entry-point-types';
+import { type ErrorCallback, type ErrorFallback } from '@atlassian/internal-entry-point-container';
+export type TriggerMode = 'hover' | 'click' | Array<'hover' | 'click'>;
+type UnionOmit<T, K extends string | number | symbol> = T extends unknown ? Omit<T, K> : never;
+type CustomPopupProps = UnionOmit<PopupProps, 'isOpen' | 'content'>;
+type EntryPointPropsType<TEntryPoint> = GetRuntimePropsFromEntryPoint<TEntryPoint>;
+export type PopupTriggerWithHoverProps<TEntryPoint> = {
+    entryPoint: TEntryPoint;
+    entryPointParams?: ParamsOfEntryPoint<TEntryPoint>;
+    entryPointProps?: Omit<EntryPointPropsType<TEntryPoint>, 'onClose' | 'onContentResized'> & {
+        onClose?: () => void;
+        onContentResized?: ContentProps['update'];
+    };
+    errorFallback?: ErrorFallback;
+    fallback?: ReactNode;
+    forcedReportErrorUFO?: boolean;
+    onError?: ErrorCallback;
+    onOpen?: (method: 'hover' | 'click') => void;
+    trigger: (triggerProps: TriggerProps) => ReactNode;
+    /**
+     * How the popup should be triggered. Defaults to `'click'` when omitted.
+     */
+    triggerMode?: TriggerMode;
+} & CustomPopupProps;
+export declare function PopupTriggerWithHover<TEntryPoint extends AnyEntryPoint>({ trigger, triggerMode, entryPoint, entryPointParams, entryPointProps, fallback, errorFallback, onError, forcedReportErrorUFO, onOpen, onClose, ...popupProps }: PopupTriggerWithHoverProps<TEntryPoint>): React.JSX.Element;
+export {};

package/dist/types-ts4.5/index.d.ts

@@ -0,0 +1 @@
+export { PopupTriggerWithHover, type PopupTriggerWithHoverProps, type TriggerMode, } from './PopupTriggerWithHover';

package/dist/types-ts4.5/useHoverDelay.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook for managing delayed hover actions with timeout management.
+ */
+declare function useHoverDelay(callback: () => void, delay: number): {
+    schedule: () => void;
+    clear: () => void;
+};
+export { useHoverDelay };

package/dist/types-ts4.5/useHoverTriggerRef.d.ts

@@ -0,0 +1,19 @@
+import { type MutableRefObject } from 'react';
+export type UseHoverTriggerRefProps = {
+    onOpen: () => void;
+    onClose?: () => void;
+    isOpen?: boolean;
+    isDisabled?: boolean;
+    openedByRef?: MutableRefObject<'hover' | 'click' | null>;
+    delays?: {
+        hoverOpen?: number;
+        hoverClose?: number;
+    };
+};
+/**
+ * Hover behavior for popup trigger and content with delayed open/close.
+ */
+export declare function useHoverTriggerRef({ onOpen, onClose, isOpen, isDisabled, openedByRef, delays, }: UseHoverTriggerRefProps): {
+    triggerRef: (element: HTMLElement | null) => void;
+    contentRef: (element: HTMLElement | null) => void;
+};

package/dist/types-ts4.5/usePreloadRef.d.ts

@@ -0,0 +1,13 @@
+export type OnLoad<T> = (obj: {
+    dispose: () => void;
+    reference: T;
+}) => void;
+export type UsePreloadRefProps<T> = {
+    load: () => T;
+    onLoad: OnLoad<T>;
+};
+export declare function usePreloadRef<T extends {
+    dispose: () => void;
+}>({ load, onLoad, }: UsePreloadRefProps<T>): ((element: HTMLElement | null) => void) & {
+    loadAndOpen: () => void;
+};

package/dist/types-ts4.5/usePressableTriggerRef.d.ts

@@ -0,0 +1,9 @@
+import { type MutableRefObject } from 'react';
+export type UsePressableTriggerRefProps = {
+    onOpen: () => void;
+    onClose?: () => void;
+    isOpen?: boolean;
+    isDisabled?: boolean;
+    openedByRef?: MutableRefObject<'hover' | 'click' | null>;
+};
+export declare function usePressableTriggerRef({ onOpen, onClose, isOpen, isDisabled, openedByRef, }: UsePressableTriggerRefProps): (element: HTMLElement | null) => void;

package/dist/types-ts4.5/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type guard to check if an event has a relatedTarget property.
+ */
+declare function hasRelatedTarget(event: Event): event is Event & {
+    relatedTarget: EventTarget | null;
+};
+/**
+ * Checks if the mouse is moving to an atlaskit portal or kudos modal
+ * where we should prevent the popup from closing
+ */
+declare function isMovingToKudos(relatedTarget: EventTarget | null): boolean;
+/**
+ * Returns the child portal if mouse is moving to a portal controlled by the parent popup.
+ */
+declare function getChildPortalFromParentPopup(relatedTarget: EventTarget | null, parentPopupElement: HTMLElement | null): Element | null;
+export { hasRelatedTarget, isMovingToKudos, getChildPortalFromParentPopup };