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

package/dist/react-tooltip.umd.js

@@ -257,7 +257,7 @@
     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;
@@ -551,38 +551,39 @@
      * 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 });
             }
         };
     }
@@ -702,10 +703,10 @@
         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))) {
@@ -788,8 +789,8 @@
         // time, so this effect is decoupled from show/hide state changes.
         React.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) => {
@@ -882,7 +883,9 @@
                     return;
                 }
                 if (clickEvents.includes(event)) {
-                    addDelegatedListener(event, handleClickOpenTooltipAnchor);
+                    addDelegatedListener(event, handleClickOpenTooltipAnchor, {
+                        capture: true,
+                    });
                 }
             });
             Object.entries(actualCloseEvents).forEach(([event, enabled]) => {
@@ -890,7 +893,9 @@
                     return;
                 }
                 if (clickEvents.includes(event)) {
-                    addDelegatedListener(event, handleClickCloseTooltipAnchor);
+                    addDelegatedListener(event, handleClickCloseTooltipAnchor, {
+                        capture: true,
+                    });
                 }
             });
             if (float) {