react-tooltip 6.0.4 → 6.0.5-beta.1278.rc.0

package/dist/react-tooltip.mjs

@@ -256,7 +256,7 @@ function parseDataTooltipIdSelector(selector) {
 function resolveDataTooltipAnchor(targetElement, tooltipId) {
     let currentElement = targetElement;
     while (currentElement) {
-        if (currentElement.dataset.tooltipId === tooltipId) {
+        if (currentElement instanceof HTMLElement && currentElement.dataset.tooltipId === tooltipId) {
             return currentElement;
         }
         currentElement = currentElement.parentElement;
@@ -550,38 +550,39 @@ const useTooltipAnchors = ({ id, anchorSelect, imperativeAnchorSelect, activeAnc
  * This reduces document-level listeners from O(N × eventTypes) to O(eventTypes).
  */
 const handlersByType = new Map();
-function getOrCreateSet(eventType) {
-    let set = handlersByType.get(eventType);
-    if (!set) {
-        set = new Set();
-        handlersByType.set(eventType, set);
-        document.addEventListener(eventType, dispatch);
-    }
-    return set;
+function getListenerKey(eventType, capture) {
+    return `${eventType}:${capture ? 'capture' : 'bubble'}`;
 }
-function dispatch(event) {
-    const handlers = handlersByType.get(event.type);
-    if (handlers) {
-        // Safe to iterate directly — mutations (add/remove) only happen in
-        // setup/cleanup, not during dispatch. Set iteration is stable for
-        // entries that existed when iteration began.
-        handlers.forEach((handler) => {
-            handler(event);
-        });
+function getOrCreateListener(eventType, capture) {
+    const key = getListenerKey(eventType, capture);
+    let listener = handlersByType.get(key);
+    if (!listener) {
+        const handlers = new Set();
+        const dispatch = (event) => {
+            handlers.forEach((handler) => {
+                handler(event);
+            });
+        };
+        listener = { handlers, dispatch, eventType, capture };
+        handlersByType.set(key, listener);
+        document.addEventListener(eventType, dispatch, { capture });
     }
+    return listener;
 }
 /**
  * Register a handler for a document-level event type.
  * Returns an unsubscribe function.
  */
-function addDelegatedEventListener(eventType, handler) {
-    const set = getOrCreateSet(eventType);
-    set.add(handler);
+function addDelegatedEventListener(eventType, handler, options = {}) {
+    const capture = Boolean(options.capture);
+    const key = getListenerKey(eventType, capture);
+    const listener = getOrCreateListener(eventType, capture);
+    listener.handlers.add(handler);
     return () => {
-        set.delete(handler);
-        if (set.size === 0) {
-            handlersByType.delete(eventType);
-            document.removeEventListener(eventType, dispatch);
+        listener.handlers.delete(handler);
+        if (listener.handlers.size === 0) {
+            handlersByType.delete(key);
+            document.removeEventListener(eventType, listener.dispatch, { capture });
         }
     };
 }
@@ -701,10 +702,10 @@ const useTooltipEvents = ({ activeAnchor, anchorElements, anchorSelector, clicka
     const dataTooltipId = anchorSelector ? parseDataTooltipIdSelector(anchorSelector) : null;
     resolveAnchorElementRef.current = (target) => {
         var _a, _b;
-        const targetElement = target;
-        if (!(targetElement === null || targetElement === void 0 ? void 0 : targetElement.isConnected)) {
+        if (!(target instanceof Element) || !target.isConnected) {
             return null;
         }
+        const targetElement = target;
         if (dataTooltipId) {
             const matchedAnchor = resolveDataTooltipAnchor(targetElement, dataTooltipId);
             if (matchedAnchor && !(disableTooltip === null || disableTooltip === void 0 ? void 0 : disableTooltip(matchedAnchor))) {
@@ -787,8 +788,8 @@ const useTooltipEvents = ({ activeAnchor, anchorElements, anchorSelector, clicka
     // time, so this effect is decoupled from show/hide state changes.
     useEffect(() => {
         const cleanupFns = [];
-        const addDelegatedListener = (eventType, listener) => {
-            cleanupFns.push(addDelegatedEventListener(eventType, listener));
+        const addDelegatedListener = (eventType, listener, options) => {
+            cleanupFns.push(addDelegatedEventListener(eventType, listener, options));
         };
         const activeAnchorContainsTarget = (event) => { var _a; return Boolean((event === null || event === void 0 ? void 0 : event.target) && ((_a = activeAnchorRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target))); };
         const debouncedHandleShowTooltip = (anchor) => {
@@ -881,7 +882,9 @@ const useTooltipEvents = ({ activeAnchor, anchorElements, anchorSelector, clicka
                 return;
             }
             if (clickEvents.includes(event)) {
-                addDelegatedListener(event, handleClickOpenTooltipAnchor);
+                addDelegatedListener(event, handleClickOpenTooltipAnchor, {
+                    capture: true,
+                });
             }
         });
         Object.entries(actualCloseEvents).forEach(([event, enabled]) => {
@@ -889,7 +892,9 @@ const useTooltipEvents = ({ activeAnchor, anchorElements, anchorSelector, clicka
                 return;
             }
             if (clickEvents.includes(event)) {
-                addDelegatedListener(event, handleClickCloseTooltipAnchor);
+                addDelegatedListener(event, handleClickCloseTooltipAnchor, {
+                    capture: true,
+                });
             }
         });
         if (float) {