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

package/afm-cc/tsconfig.json

@@ -0,0 +1,40 @@
+{
+	"extends": "../../../../tsconfig.local-consumption.json",
+	"include": [
+		"../src/**/*.ts",
+		"../src/**/*.tsx"
+	],
+	"exclude": [
+		"../src/**/__tests__/*",
+		"../src/**/*.test.*",
+		"../src/**/test.*",
+		"../src/**/mocks/*",
+		"../src/**/examples.*"
+	],
+	"compilerOptions": {
+		"outDir": "../../../../../confluence/tsDist/@atlaskit__teams-app-internal-popup-adaptor",
+		"rootDir": "../",
+		"composite": true,
+		"noCheck": true
+	},
+	"references": [
+		{
+			"path": "../../../design-system/popup/afm-cc/tsconfig.json"
+		},
+		{
+			"path": "../../../design-system/spinner/afm-cc/tsconfig.json"
+		},
+		{
+			"path": "../../../entry-points/entry-point-types/afm-cc/tsconfig.json"
+		},
+		{
+			"path": "../../../entry-points/internal-entry-point-container/afm-cc/tsconfig.json"
+		},
+		{
+			"path": "../../../async/react-async/afm-cc/tsconfig.json"
+		},
+		{
+			"path": "../../../relay/relay-environment-provider/afm-cc/tsconfig.json"
+		}
+	]
+}

package/afm-products/tsconfig.json

@@ -0,0 +1,40 @@
+{
+	"extends": "../../../../tsconfig.local-consumption.json",
+	"include": [
+		"../src/**/*.ts",
+		"../src/**/*.tsx"
+	],
+	"exclude": [
+		"../src/**/__tests__/*",
+		"../src/**/*.test.*",
+		"../src/**/test.*",
+		"../src/**/mocks/*",
+		"../src/**/examples.*"
+	],
+	"compilerOptions": {
+		"outDir": "../../../../../tsDist/@atlaskit__teams-app-internal-popup-adaptor/app",
+		"rootDir": "../",
+		"composite": true,
+		"noCheck": true
+	},
+	"references": [
+		{
+			"path": "../../../design-system/popup/afm-products/tsconfig.json"
+		},
+		{
+			"path": "../../../design-system/spinner/afm-products/tsconfig.json"
+		},
+		{
+			"path": "../../../entry-points/entry-point-types/afm-products/tsconfig.json"
+		},
+		{
+			"path": "../../../entry-points/internal-entry-point-container/afm-products/tsconfig.json"
+		},
+		{
+			"path": "../../../async/react-async/afm-products/tsconfig.json"
+		},
+		{
+			"path": "../../../relay/relay-environment-provider/afm-products/tsconfig.json"
+		}
+	]
+}

package/dist/cjs/PopupTriggerWithHover.js

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PopupTriggerWithHover = PopupTriggerWithHover;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactRelay = require("react-relay");
+var _useCallbackRef = require("use-callback-ref");
+var _popup = require("@atlaskit/popup");
+var _spinner = _interopRequireDefault(require("@atlaskit/spinner"));
+var _internalEntryPointContainer = require("@atlassian/internal-entry-point-container");
+var _relayEnvironmentProvider = require("@atlassian/relay-environment-provider");
+var _useHoverTriggerRef2 = require("./useHoverTriggerRef");
+var _usePreloadRef = require("./usePreloadRef");
+var _usePressableTriggerRef = require("./usePressableTriggerRef");
+var _excluded = ["trigger", "triggerMode", "entryPoint", "entryPointParams", "entryPointProps", "fallback", "errorFallback", "onError", "forcedReportErrorUFO", "onOpen", "onClose"];
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var emptyEntryPointParams = {};
+var emptyEntryPointProps = {};
+var FallbackComponent = function FallbackComponent(_ref) {
+  var fallback = _ref.fallback,
+    onUnmount = _ref.onUnmount;
+  (0, _react.useEffect)(function () {
+    return function () {
+      return onUnmount();
+    };
+  }, [onUnmount]);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, fallback || /*#__PURE__*/_react.default.createElement(_spinner.default, null));
+};
+function PopupTriggerWithHover(_ref2) {
+  var trigger = _ref2.trigger,
+    _ref2$triggerMode = _ref2.triggerMode,
+    triggerMode = _ref2$triggerMode === void 0 ? 'click' : _ref2$triggerMode,
+    entryPoint = _ref2.entryPoint,
+    entryPointParams = _ref2.entryPointParams,
+    entryPointProps = _ref2.entryPointProps,
+    fallback = _ref2.fallback,
+    errorFallback = _ref2.errorFallback,
+    onError = _ref2.onError,
+    forcedReportErrorUFO = _ref2.forcedReportErrorUFO,
+    onOpen = _ref2.onOpen,
+    onClose = _ref2.onClose,
+    popupProps = (0, _objectWithoutProperties2.default)(_ref2, _excluded);
+  var environmentProvider = (0, _relayEnvironmentProvider.useRelayEnvironmentProvider)();
+  var id = (0, _react.useMemo)(function () {
+    return entryPoint.root.getModuleName() || 'unknown';
+  }, [entryPoint]);
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    isOpen = _useState2[0],
+    setIsOpen = _useState2[1];
+  var _useState3 = (0, _react.useState)(null),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    content = _useState4[0],
+    setContent = _useState4[1];
+  var updateRef = (0, _react.useRef)(null);
+  var openedByRef = (0, _react.useRef)(null);
+  var isOpenRef = (0, _react.useRef)(isOpen);
+  var triggers = Array.isArray(triggerMode) ? triggerMode : [triggerMode];
+  (0, _react.useLayoutEffect)(function () {
+    isOpenRef.current = isOpen;
+  }, [isOpen]);
+  var handleOpen = (0, _react.useCallback)(function (method) {
+    setIsOpen(true);
+    if (method) {
+      onOpen === null || onOpen === void 0 || onOpen(method);
+    }
+  }, [onOpen]);
+  var handleClose = (0, _react.useCallback)(function (event, currentLevel) {
+    setIsOpen(false);
+    onClose === null || onClose === void 0 || onClose(event !== null && event !== void 0 ? event : null, currentLevel);
+  }, [onClose]);
+  var load = (0, _react.useCallback)(function () {
+    return (0, _reactRelay.loadEntryPoint)(environmentProvider, entryPoint, entryPointParams !== null && entryPointParams !== void 0 ? entryPointParams : emptyEntryPointParams);
+  }, [entryPoint, entryPointParams, environmentProvider]);
+  var onLoad = (0, _react.useCallback)(function (_ref3) {
+    var entryPointReference = _ref3.reference;
+    if (isOpenRef.current) {
+      return;
+    }
+    handleOpen(openedByRef.current);
+    setContent( /*#__PURE__*/_react.default.createElement(_internalEntryPointContainer.InternalEntryPointContainer, {
+      id: id,
+      entryPointReference: entryPointReference,
+      fallback: /*#__PURE__*/_react.default.createElement(FallbackComponent, {
+        fallback: fallback,
+        onUnmount: function onUnmount() {
+          var _updateRef$current;
+          return (_updateRef$current = updateRef.current) === null || _updateRef$current === void 0 ? void 0 : _updateRef$current.call(updateRef);
+        }
+      }),
+      errorFallback: errorFallback,
+      runtimeProps: _objectSpread(_objectSpread({}, entryPointProps !== null && entryPointProps !== void 0 ? entryPointProps : emptyEntryPointProps), {}, {
+        onContentResized: function onContentResized() {
+          var _updateRef$current2;
+          (_updateRef$current2 = updateRef.current) === null || _updateRef$current2 === void 0 || _updateRef$current2.call(updateRef);
+        },
+        onClose: handleClose
+      }),
+      onError: onError,
+      forcedError: forcedReportErrorUFO
+    }));
+  }, [setContent, id, entryPointProps, fallback, forcedReportErrorUFO, errorFallback, handleOpen, onError, handleClose]);
+  var preloadRef = (0, _usePreloadRef.usePreloadRef)({
+    load: load,
+    onLoad: onLoad
+  });
+  var pressableRef = (0, _usePressableTriggerRef.usePressableTriggerRef)({
+    onOpen: preloadRef.loadAndOpen,
+    onClose: handleClose,
+    isOpen: isOpen,
+    isDisabled: !triggers.includes('click'),
+    openedByRef: openedByRef
+  });
+  var _useHoverTriggerRef = (0, _useHoverTriggerRef2.useHoverTriggerRef)({
+      onOpen: preloadRef.loadAndOpen,
+      onClose: handleClose,
+      isOpen: isOpen,
+      isDisabled: !triggers.includes('hover'),
+      openedByRef: openedByRef
+    }),
+    hoverTriggerRef = _useHoverTriggerRef.triggerRef,
+    hoverContentRef = _useHoverTriggerRef.contentRef;
+  (0, _react.useEffect)(function () {
+    if (!isOpen) {
+      openedByRef.current = null;
+    }
+  }, [isOpen]);
+  var popupTrigger = (0, _react.useCallback)(function (triggerProps) {
+    var mergedRef = (0, _useCallbackRef.mergeRefs)([preloadRef, pressableRef, hoverTriggerRef, triggerProps.ref]);
+    return trigger(_objectSpread(_objectSpread({}, triggerProps), {}, {
+      ref: mergedRef
+    }));
+  }, [trigger, preloadRef, pressableRef, hoverTriggerRef]);
+  var popupContent = (0, _react.useCallback)(function (_ref4) {
+    var update = _ref4.update;
+    updateRef.current = update;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      ref: hoverContentRef,
+      role: "none"
+    }, content);
+  }, [content, hoverContentRef]);
+  return /*#__PURE__*/_react.default.createElement(_popup.Popup, (0, _extends2.default)({}, popupProps, {
+    isOpen: isOpen,
+    onClose: handleClose,
+    trigger: popupTrigger,
+    content: popupContent
+  }));
+}

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "PopupTriggerWithHover", {
+  enumerable: true,
+  get: function get() {
+    return _PopupTriggerWithHover.PopupTriggerWithHover;
+  }
+});
+var _PopupTriggerWithHover = require("./PopupTriggerWithHover");

package/dist/cjs/useHoverDelay.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHoverDelay = useHoverDelay;
+var _react = require("react");
+/**
+ * Hook for managing delayed hover actions with timeout management.
+ */
+function useHoverDelay(callback, delay) {
+  var timeoutRef = (0, _react.useRef)(null);
+  var callbackRef = (0, _react.useRef)(callback);
+  (0, _react.useEffect)(function () {
+    callbackRef.current = callback;
+  }, [callback]);
+  var clear = (0, _react.useCallback)(function () {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  var schedule = (0, _react.useCallback)(function () {
+    clear();
+    timeoutRef.current = window.setTimeout(function () {
+      callbackRef.current();
+    }, delay);
+  }, [delay, clear]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      return clear();
+    };
+  }, [clear]);
+  return {
+    schedule: schedule,
+    clear: clear
+  };
+}

package/dist/cjs/useHoverTriggerRef.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useHoverTriggerRef = useHoverTriggerRef;
+var _react = require("react");
+var _bindEventListener = require("bind-event-listener");
+var _useHoverDelay = require("./useHoverDelay");
+var _utils = require("./utils");
+var HOVER_OPEN_DELAY = 800;
+var HOVER_CLOSE_DELAY = 200;
+/**
+ * Hover behavior for popup trigger and content with delayed open/close.
+ */
+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 = (0, _react.useRef)(null);
+  var triggerListeners = (0, _react.useRef)([]);
+  var contentNodeRef = (0, _react.useRef)(null);
+  var contentListeners = (0, _react.useRef)(new Map());
+  var isOpenRef = (0, _react.useRef)(isOpen);
+  (0, _react.useLayoutEffect)(function () {
+    isOpenRef.current = isOpen;
+  }, [isOpen]);
+  var openDelay = (0, _useHoverDelay.useHoverDelay)(function () {
+    if (isOpenRef.current) {
+      return;
+    }
+    if (openedByRef) {
+      openedByRef.current = 'hover';
+    }
+    onOpen();
+  }, hoverOpen);
+  var closeDelay = (0, _useHoverDelay.useHoverDelay)(function () {
+    if (!isOpenRef.current) {
+      return;
+    }
+    if (!openedByRef || openedByRef.current === 'hover') {
+      onClose === null || onClose === void 0 || onClose();
+    }
+  }, hoverClose);
+  var openDelayRef = (0, _react.useRef)(openDelay);
+  var closeDelayRef = (0, _react.useRef)(closeDelay);
+  openDelayRef.current = openDelay;
+  closeDelayRef.current = closeDelay;
+  var handleTriggerEnter = (0, _react.useCallback)(function () {
+    closeDelayRef.current.clear();
+    openDelayRef.current.schedule();
+  }, []);
+  var handleTriggerLeave = (0, _react.useCallback)(function () {
+    openDelayRef.current.clear();
+    closeDelayRef.current.schedule();
+  }, []);
+  var triggerRef = (0, _react.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((0, _bindEventListener.bind)(element, {
+        type: 'mouseenter',
+        listener: handleTriggerEnter
+      }), (0, _bindEventListener.bind)(element, {
+        type: 'mouseleave',
+        listener: handleTriggerLeave
+      }));
+    }
+  }, [handleTriggerEnter, handleTriggerLeave, isDisabled]);
+  var handleContentEnter = (0, _react.useCallback)(function () {
+    closeDelayRef.current.clear();
+  }, []);
+  var cleanupContentListeners = (0, _react.useCallback)(function () {
+    contentListeners.current.forEach(function (unbind) {
+      return unbind();
+    });
+    contentListeners.current.clear();
+  }, []);
+  var attachContentListeners = (0, _react.useCallback)(function (element) {
+    if (contentListeners.current.has(element)) {
+      return;
+    }
+    var handleMouseLeave = function handleMouseLeave(event) {
+      if (!(0, _utils.hasRelatedTarget)(event)) {
+        return;
+      }
+      var relatedTarget = event.relatedTarget;
+      if ((0, _utils.isMovingToKudos)(relatedTarget)) {
+        return;
+      }
+      var childPortal = (0, _utils.getChildPortalFromParentPopup)(relatedTarget, contentNodeRef.current);
+      if (childPortal) {
+        attachContentListeners(childPortal);
+        return;
+      }
+      closeDelayRef.current.schedule();
+    };
+    var unbindEnter = (0, _bindEventListener.bind)(element, {
+      type: 'mouseenter',
+      listener: handleContentEnter
+    });
+    var unbindLeave = (0, _bindEventListener.bind)(element, {
+      type: 'mouseleave',
+      listener: handleMouseLeave
+    });
+    contentListeners.current.set(element, function () {
+      unbindEnter();
+      unbindLeave();
+    });
+  }, [handleContentEnter]);
+  var contentRef = (0, _react.useCallback)(function (element) {
+    if (element === contentNodeRef.current) {
+      return;
+    }
+    cleanupContentListeners();
+    contentNodeRef.current = element;
+    if (element && !isDisabled) {
+      attachContentListeners(element);
+    }
+  }, [attachContentListeners, cleanupContentListeners, isDisabled]);
+  (0, _react.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/cjs/usePreloadRef.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePreloadRef = usePreloadRef;
+var _react = require("react");
+var _bindEventListener = require("bind-event-listener");
+var PRELOAD_MAX_AGE = 5 * 60 * 1000;
+var TIME_TO_INTENT = 200;
+function usePreloadRef(_ref) {
+  var load = _ref.load,
+    onLoad = _ref.onLoad;
+  var nodeRef = (0, _react.useRef)(null);
+  var eventListeners = (0, _react.useRef)([]);
+  var _useMemo = (0, _react.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 = (0, _react.useCallback)(function () {
+    eventListeners.current.forEach(function (unbind) {
+      unbind();
+    });
+    eventListeners.current = [];
+  }, []);
+  var addEventListener = (0, _react.useCallback)(function (element, type, callback) {
+    var unbind = (0, _bindEventListener.bind)(element, {
+      type: type,
+      listener: callback
+    });
+    eventListeners.current.push(unbind);
+  }, []);
+  var refCallback = (0, _react.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]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      cleanUpEventListeners();
+    };
+  }, [cleanUpEventListeners]);
+  return Object.assign(refCallback, {
+    loadAndOpen: loadAndOpen
+  });
+}

package/dist/cjs/usePressableTriggerRef.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePressableTriggerRef = usePressableTriggerRef;
+var _react = require("react");
+var _bindEventListener = require("bind-event-listener");
+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 = (0, _react.useRef)(null);
+  var eventListeners = (0, _react.useRef)([]);
+  var handleOpen = (0, _react.useCallback)(function () {
+    if (isOpen) {
+      onClose === null || onClose === void 0 || onClose();
+    } else {
+      if (openedByRef) {
+        openedByRef.current = 'click';
+      }
+      onOpen();
+    }
+  }, [isOpen, onClose, openedByRef, onOpen]);
+  var keydownListener = (0, _react.useCallback)(function (event) {
+    if (event instanceof KeyboardEvent && (event.key === 'Enter' || event.key === ' ')) {
+      event.preventDefault();
+      handleOpen();
+    }
+  }, [handleOpen]);
+  var cleanUpEventListeners = (0, _react.useCallback)(function () {
+    eventListeners.current.forEach(function (unbind) {
+      unbind();
+    });
+    eventListeners.current = [];
+  }, []);
+  var addEventListener = (0, _react.useCallback)(function (element, type, callback) {
+    var unbind = (0, _bindEventListener.bind)(element, {
+      type: type,
+      listener: callback
+    });
+    eventListeners.current.push(unbind);
+  }, []);
+  var refCallback = (0, _react.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]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      cleanUpEventListeners();
+    };
+  }, [cleanUpEventListeners]);
+  return refCallback;
+}

package/dist/cjs/utils.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChildPortalFromParentPopup = getChildPortalFromParentPopup;
+exports.hasRelatedTarget = hasRelatedTarget;
+exports.isMovingToKudos = isMovingToKudos;
+/**
+ * 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;
+}