@tamagui/floating 2.0.0-rc.3 → 2.0.0-rc.31

package/dist/cjs/interactions/useDelayGroup.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useDelayGroup_exports","__export","FloatingDelayGroup","useDelayGroup","useDelayGroupContext","module","exports","React","__toESM","require","DelayGroupContext","createContext","currentId","setCurrentId","delay","timeoutMs","initialDelay","useContext","param","children","setCurrentIdRaw","useState","timeoutRef","useRef","useCallback","id","clearTimeout","current","setTimeout","useEffect","useMemo","createElement","Provider","context","options","arguments","length","groupContext","open","onOpenChange"],"sources":["../../../src/interactions/useDelayGroup.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAA;EAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;IAAAC,KAAA;EAAA,IAAAH,GAAA;AAAA,IAAAI,qBAAA;AAAAC,QAAA,CAAAD,qBAAA;EAAAE,kBAAA,EAAAA,CAAA,KAAAA,kBAAA;EAAAC,aAAA,EAAAA,CAAA,KAAAA,aAAA;EAAAC,oBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAuB,GAAAX,YAAA,CAAAK,qBAAA;AAWvB,IAAAO,KAAM,GAAAC,OAAA,CAAAC,OAAoB,QAAM;EAAAC,iBAAsC,GAAAH,KAAA,CAAAI,aAAA;IACpEC,SAAA,EAAW;IACXC,YAAA,EAAc,SAAAA,CAAA,EAAM,CAAC;IACrBC,KAAA,EAAO;IACPC,SAAA,EAAW;IACXC,YAAA,EAAc;EAChB,CAAC;AAEM,SAASZ,qBAAA,EAAuB;EACrC,OAAOG,KAAA,CAAMU,UAAA,CAAWP,iBAAiB;AAC3C;AAKO,SAASR,mBAAmBgB,KAAA;EACjC;MAAAC,QAAA;MAAAL,KAAA;MAAAC,SAAA;IAAA,IAAAG,KAAA;IAAA,CAAAN,SAAA,EAAAQ,eAAA,IAAAb,KAAA,CAAAc,QAAA;IAAAC,UAAA,GAAAf,KAAA,CAAAgB,MAAA;IAAAV,YAAA,GAAAN,KAAA,CAAAiB,WAAA,WAAAC,EAAA;MACAC,YAAA,CAAAJ,UAAA,CAAAK,OAAA,GAAAF,EAAA,YAAAV,SAAA,OAAAO,UAAA,CAAAK,OAAA,GAAAC,UAAA;QACAR,eAAY;MAKX,GAAAL,SAAA,IAAAK,eAAA,CAAAK,EAAA;IACD,IAIEV,SAAmC,CACjC;EAIIR,KAAA,CAAAsB,SAAA,aAAoB;IAAA,OACnB,YAEH;MAEJ,OAAAH,YAAA,CAAAJ,UAAA,CAAAK,OAAA;IACA,CAAC;EACH;EAEA,IAAA5B,KAAM,GAAAQ,KAAU,CAAAuB,OACP,aAAM;IAGf,OAAM;MACJlB,SAAO;MACLC,YAAA;MACAC,KAAA;MACAC,SAAA;MACAC,YAAA,EAAAF;IAAA;EACc,GAChB,CACAF,SAAC,EACHC,YAAA,EAEAC,KAAO,EACTC,SAAA,CAIO;EAIL,OAAMR,KAAK,CAAAwB,aACL,CAAArB,iBAAe,CAAMsB,QAAA;IAmB3BjC;EAfE,GAAKoB,QAAQ;AACmB;AAOhC,SAAIhB,aAAaA,CAAA8B,OAAa;EAGhC,IAAIC,OAAA,GAAAC,SAAa,CAAAC,MAAW,GAAI,KAAAD,SAAa,CAIzC,aAAa,GAAAA,SAAA,CAAa,OACrB;IAAA;MAAAV;IAAA,IAAAS,OAAA;IAAAG,YAAA,GAAA9B,KAAA,CAAAU,UAAA,CAAAP,iBAAA;EAAA,OACLH,KAAS,CAAAsB,SAAS,aAAO;IACzB,CAAAI,OAAA,CAAAK,IAAW,IAAAD,YAAa,CAAAzB,SAAA,KAAAa,EAAA,IAAAY,YAAA,CAAAxB,YAAA;EAC1B,IAIAoB,OAAO,CAAAK,IAAA,EACPb,EAAA,CACF,GAAAlB,KAAA,CAAAsB,SAAA;IACFQ,YAAA,CAAAzB,SAAA,YAAAyB,YAAA,CAAAzB,SAAA,KAAAa,EAAA,IAAAQ,OAAA,CAAAK,IAAA,IAAAL,OAAA,CAAAM,YAAA;EAEA,IACEF,YAAW,CAAAzB,SAAU,EAEvBa,EAAA,E","ignoreList":[]}

package/dist/cjs/interactions/useFocus.cjs

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var useFocus_exports = {};
+__export(useFocus_exports, {
+  useFocus: () => useFocus
+});
+module.exports = __toCommonJS(useFocus_exports);
+var import_react = require("react"),
+  import_utils = require("./utils.cjs");
+function isMacSafari() {
+  return (0, import_utils.isMac)() && (0, import_utils.isSafari)();
+}
+function useFocus(context, props = {}) {
+  const {
+      open,
+      onOpenChange,
+      events,
+      dataRef,
+      elements
+    } = context,
+    {
+      enabled = !0,
+      visibleOnly = !0
+    } = props,
+    blockFocusRef = (0, import_react.useRef)(!1),
+    timeoutRef = (0, import_react.useRef)(-1),
+    keyboardModalityRef = (0, import_react.useRef)(!0);
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    const win = (0, import_utils.getDocument)(elements.domReference).defaultView || window;
+    function onBlur() {
+      !open && (0, import_utils.isHTMLElement)(elements.domReference) && elements.domReference === (0, import_utils.activeElement)((0, import_utils.getDocument)(elements.domReference)) && (blockFocusRef.current = !0);
+    }
+    function onKeyDown() {
+      keyboardModalityRef.current = !0;
+    }
+    function onPointerDown() {
+      keyboardModalityRef.current = !1;
+    }
+    return win.addEventListener("blur", onBlur), isMacSafari() && (win.addEventListener("keydown", onKeyDown, !0), win.addEventListener("pointerdown", onPointerDown, !0)), () => {
+      win.removeEventListener("blur", onBlur), isMacSafari() && (win.removeEventListener("keydown", onKeyDown, !0), win.removeEventListener("pointerdown", onPointerDown, !0));
+    };
+  }, [elements.domReference, open, enabled]), (0, import_react.useEffect)(() => {
+    if (!enabled || !events) return;
+    function handleOpenChange({
+      reason
+    }) {
+      (reason === "reference-press" || reason === "escape-key") && (blockFocusRef.current = !0);
+    }
+    return events.on("openchange", handleOpenChange), () => {
+      events.off("openchange", handleOpenChange);
+    };
+  }, [events, enabled]), (0, import_react.useEffect)(() => () => {
+    (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+  }, []);
+  const reference = (0, import_react.useMemo)(() => ({
+    onMouseLeave() {
+      blockFocusRef.current = !1;
+    },
+    onFocus(event) {
+      if (blockFocusRef.current) return;
+      const target = (0, import_utils.getTarget)(event.nativeEvent);
+      if (visibleOnly && (0, import_utils.isElement)(target)) {
+        if (isMacSafari() && !event.relatedTarget) {
+          if (!keyboardModalityRef.current && !(0, import_utils.isTypeableElement)(target)) return;
+        } else if (!(0, import_utils.matchesFocusVisible)(target)) return;
+      }
+      onOpenChange(!0, event.nativeEvent, "focus");
+    },
+    onBlur(event) {
+      blockFocusRef.current = !1;
+      const relatedTarget = event.relatedTarget,
+        nativeEvent = event.nativeEvent;
+      timeoutRef.current = window.setTimeout(() => {
+        const activeEl = (0, import_utils.activeElement)(elements.domReference ? elements.domReference.ownerDocument : document);
+        !relatedTarget && activeEl === elements.domReference || (0, import_utils.contains)(context.refs.floating.current, activeEl) || (0, import_utils.contains)(elements.domReference, activeEl) || onOpenChange(!1, nativeEvent, "focus");
+      });
+    }
+  }), [context.refs.floating, elements.domReference, onOpenChange, visibleOnly]);
+  return (0, import_react.useMemo)(() => enabled ? {
+    reference
+  } : {}, [enabled, reference]);
+}

package/dist/cjs/interactions/useFocus.native.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var useFocus_exports = {};
+__export(useFocus_exports, {
+  useFocus: () => useFocus
+});
+module.exports = __toCommonJS(useFocus_exports);
+var import_react = require("react"),
+  import_utils = require("./utils.native.js");
+function isMacSafari() {
+  return (0, import_utils.isMac)() && (0, import_utils.isSafari)();
+}
+function useFocus(context) {
+  var props = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {},
+    {
+      open,
+      onOpenChange,
+      events,
+      dataRef,
+      elements
+    } = context,
+    {
+      enabled = !0,
+      visibleOnly = !0
+    } = props,
+    blockFocusRef = (0, import_react.useRef)(!1),
+    timeoutRef = (0, import_react.useRef)(-1),
+    keyboardModalityRef = (0, import_react.useRef)(!0);
+  (0, import_react.useEffect)(function () {
+    if (!enabled) return;
+    var win = (0, import_utils.getDocument)(elements.domReference).defaultView || window;
+    function onBlur() {
+      !open && (0, import_utils.isHTMLElement)(elements.domReference) && elements.domReference === (0, import_utils.activeElement)((0, import_utils.getDocument)(elements.domReference)) && (blockFocusRef.current = !0);
+    }
+    function onKeyDown() {
+      keyboardModalityRef.current = !0;
+    }
+    function onPointerDown() {
+      keyboardModalityRef.current = !1;
+    }
+    return win.addEventListener("blur", onBlur), isMacSafari() && (win.addEventListener("keydown", onKeyDown, !0), win.addEventListener("pointerdown", onPointerDown, !0)), function () {
+      win.removeEventListener("blur", onBlur), isMacSafari() && (win.removeEventListener("keydown", onKeyDown, !0), win.removeEventListener("pointerdown", onPointerDown, !0));
+    };
+  }, [elements.domReference, open, enabled]), (0, import_react.useEffect)(function () {
+    if (!enabled || !events) return;
+    function handleOpenChange(param) {
+      var {
+        reason
+      } = param;
+      (reason === "reference-press" || reason === "escape-key") && (blockFocusRef.current = !0);
+    }
+    return events.on("openchange", handleOpenChange), function () {
+      events.off("openchange", handleOpenChange);
+    };
+  }, [events, enabled]), (0, import_react.useEffect)(function () {
+    return function () {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+    };
+  }, []);
+  var reference = (0, import_react.useMemo)(function () {
+    return {
+      onMouseLeave() {
+        blockFocusRef.current = !1;
+      },
+      onFocus(event) {
+        if (!blockFocusRef.current) {
+          var target = (0, import_utils.getTarget)(event.nativeEvent);
+          if (visibleOnly && (0, import_utils.isElement)(target)) {
+            if (isMacSafari() && !event.relatedTarget) {
+              if (!keyboardModalityRef.current && !(0, import_utils.isTypeableElement)(target)) return;
+            } else if (!(0, import_utils.matchesFocusVisible)(target)) return;
+          }
+          onOpenChange(!0, event.nativeEvent, "focus");
+        }
+      },
+      onBlur(event) {
+        blockFocusRef.current = !1;
+        var relatedTarget = event.relatedTarget,
+          nativeEvent = event.nativeEvent;
+        timeoutRef.current = window.setTimeout(function () {
+          var activeEl = (0, import_utils.activeElement)(elements.domReference ? elements.domReference.ownerDocument : document);
+          !relatedTarget && activeEl === elements.domReference || (0, import_utils.contains)(context.refs.floating.current, activeEl) || (0, import_utils.contains)(elements.domReference, activeEl) || onOpenChange(!1, nativeEvent, "focus");
+        });
+      }
+    };
+  }, [context.refs.floating, elements.domReference, onOpenChange, visibleOnly]);
+  return (0, import_react.useMemo)(function () {
+    return enabled ? {
+      reference
+    } : {};
+  }, [enabled, reference]);
+}
+//# sourceMappingURL=useFocus.native.js.map

package/dist/cjs/interactions/useFocus.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useFocus_exports","__export","useFocus","module","exports","import_react","require","import_utils","isMacSafari","isMac","isSafari","context","props","arguments","length","open","onOpenChange","events","dataRef","elements","enabled","visibleOnly","blockFocusRef","useRef","timeoutRef","keyboardModalityRef","useEffect","win","getDocument","domReference","defaultView","window","onBlur","isHTMLElement","activeElement","current","onKeyDown","onPointerDown","addEventListener","removeEventListener","handleOpenChange","param","reason","on","off","clearTimeoutIfSet","reference","useMemo","onMouseLeave","onFocus","event","target","getTarget","nativeEvent","isElement","relatedTarget","isTypeableElement","matchesFocusVisible"],"sources":["../../../src/interactions/useFocus.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/interactions/useHover.cjs

@@ -0,0 +1,224 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var useHover_exports = {};
+__export(useHover_exports, {
+  getDelay: () => getDelay,
+  useHover: () => useHover
+});
+module.exports = __toCommonJS(useHover_exports);
+var React = __toESM(require("react"), 1),
+  import_use_event = require("@tamagui/use-event"),
+  import_utils = require("./utils.cjs");
+const safePolygonIdentifier = "data-floating-ui-safe-polygon";
+function getDelay(value, prop, pointerType) {
+  return pointerType && !(0, import_utils.isMouseLikePointerType)(pointerType) ? 0 : typeof value == "number" ? value : value?.[prop];
+}
+function useHover(context, props = {}) {
+  const {
+      open,
+      onOpenChange,
+      dataRef,
+      events,
+      elements
+    } = context,
+    {
+      enabled = !0,
+      delay = 0,
+      handleClose = null,
+      mouseOnly = !1,
+      restMs = 0,
+      move = !0
+    } = props,
+    handleCloseRef = React.useRef(handleClose);
+  handleCloseRef.current = handleClose;
+  const delayRef = React.useRef(delay);
+  delayRef.current = delay;
+  const openRef = React.useRef(open);
+  openRef.current = open;
+  const restMsRef = React.useRef(restMs);
+  restMsRef.current = restMs;
+  const stableOnOpenChange = (0, import_use_event.useEvent)(onOpenChange),
+    pointerTypeRef = React.useRef(void 0),
+    timeoutRef = React.useRef(-1),
+    handlerRef = React.useRef(void 0),
+    restTimeoutRef = React.useRef(-1),
+    blockMouseMoveRef = React.useRef(!0),
+    performedPointerEventsMutationRef = React.useRef(!1),
+    unbindMouseMoveRef = React.useRef(() => {}),
+    restTimeoutPendingRef = React.useRef(!1),
+    isHoverOpen = (0, import_use_event.useEvent)(() => {
+      const type = dataRef.current.openEvent?.type;
+      return type?.includes("mouse") && type !== "mousedown";
+    });
+  React.useEffect(() => {
+    if (!enabled || !events) return;
+    function onOpenChange2({
+      open: open2
+    }) {
+      open2 || ((0, import_utils.clearTimeoutIfSet)(timeoutRef), (0, import_utils.clearTimeoutIfSet)(restTimeoutRef), blockMouseMoveRef.current = !0, restTimeoutPendingRef.current = !1);
+    }
+    return events.on("openchange", onOpenChange2), () => {
+      events.off("openchange", onOpenChange2);
+    };
+  }, [enabled, events]);
+  const closeWithDelay = (0, import_use_event.useEvent)((event, runElseBranch = !0, reason = "hover") => {
+      const closeDelay = getDelay(delayRef.current, "close", pointerTypeRef.current);
+      closeDelay && !handlerRef.current ? ((0, import_utils.clearTimeoutIfSet)(timeoutRef), timeoutRef.current = window.setTimeout(() => stableOnOpenChange(!1, event, reason), closeDelay)) : runElseBranch && ((0, import_utils.clearTimeoutIfSet)(timeoutRef), stableOnOpenChange(!1, event, reason));
+    }),
+    cleanupMouseMoveHandler = (0, import_use_event.useEvent)(() => {
+      unbindMouseMoveRef.current(), handlerRef.current = void 0, context.handleCloseActiveRef && (context.handleCloseActiveRef.current = !1);
+    }),
+    clearPointerEvents = (0, import_use_event.useEvent)(() => {
+      if (performedPointerEventsMutationRef.current) {
+        const body = (0, import_utils.getDocument)(elements.floating).body;
+        body.style.pointerEvents = "", body.removeAttribute(safePolygonIdentifier), performedPointerEventsMutationRef.current = !1;
+      }
+    }),
+    isClickLikeOpenEvent = (0, import_use_event.useEvent)(() => dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : !1);
+  React.useEffect(() => {
+    if (!enabled) return;
+    function onReferenceMouseEnter(event) {
+      if ((0, import_utils.clearTimeoutIfSet)(timeoutRef), blockMouseMoveRef.current = !1, mouseOnly && !(0, import_utils.isMouseLikePointerType)(pointerTypeRef.current) || restMsRef.current > 0 && !getDelay(delayRef.current, "open")) return;
+      const openDelay = getDelay(delayRef.current, "open", pointerTypeRef.current);
+      openDelay ? timeoutRef.current = window.setTimeout(() => {
+        openRef.current || stableOnOpenChange(!0, event, "hover");
+      }, openDelay) : open || stableOnOpenChange(!0, event, "hover");
+    }
+    function onReferenceMouseLeave(event) {
+      if (isClickLikeOpenEvent()) {
+        clearPointerEvents();
+        return;
+      }
+      if (context.triggerElements?.hasElement(event.relatedTarget)) return;
+      unbindMouseMoveRef.current();
+      const doc = (0, import_utils.getDocument)(elements.floating);
+      if ((0, import_utils.clearTimeoutIfSet)(restTimeoutRef), restTimeoutPendingRef.current = !1, handleCloseRef.current) {
+        open || (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+        const placement = dataRef.current.placement || "bottom",
+          reference2 = elements.domReference,
+          floating = elements.floating;
+        if (!reference2 || !floating) return;
+        handlerRef.current = handleCloseRef.current({
+          x: event.clientX,
+          y: event.clientY,
+          placement,
+          elements: {
+            reference: reference2,
+            floating,
+            domReference: reference2
+          },
+          onClose() {
+            context.handleCloseActiveRef && (context.handleCloseActiveRef.current = !1), clearPointerEvents(), cleanupMouseMoveHandler(), isClickLikeOpenEvent() || closeWithDelay(event, !0, "safe-polygon");
+          }
+        }), context.handleCloseActiveRef && (context.handleCloseActiveRef.current = !0);
+        const handler = handlerRef.current;
+        doc.addEventListener("mousemove", handler), unbindMouseMoveRef.current = () => {
+          doc.removeEventListener("mousemove", handler);
+        };
+        return;
+      }
+      (pointerTypeRef.current !== "touch" || !(0, import_utils.contains)(elements.floating, event.relatedTarget)) && closeWithDelay(event);
+    }
+    function onScrollMouseLeave(event) {
+      if (isClickLikeOpenEvent() || context.triggerElements?.hasElement(event.relatedTarget)) return;
+      const placement = dataRef.current.placement || "bottom",
+        reference2 = elements.domReference,
+        floating = elements.floating;
+      !reference2 || !floating || handleCloseRef.current?.({
+        x: event.clientX,
+        y: event.clientY,
+        placement,
+        elements: {
+          reference: reference2,
+          floating,
+          domReference: reference2
+        },
+        onClose() {
+          clearPointerEvents(), cleanupMouseMoveHandler(), isClickLikeOpenEvent() || closeWithDelay(event);
+        }
+      })(event);
+    }
+    function onFloatingMouseEnter() {
+      (0, import_utils.clearTimeoutIfSet)(timeoutRef);
+    }
+    function onFloatingMouseLeave(event) {
+      isClickLikeOpenEvent() || context.triggerElements?.hasElement(event.relatedTarget) || closeWithDelay(event, !1);
+    }
+    if ((0, import_utils.isElement)(elements.domReference)) {
+      const reference2 = elements.domReference,
+        floating = elements.floating;
+      return open && reference2.addEventListener("mouseleave", onScrollMouseLeave), move && reference2.addEventListener("mousemove", onReferenceMouseEnter, {
+        once: !0
+      }), reference2.addEventListener("mouseenter", onReferenceMouseEnter), reference2.addEventListener("mouseleave", onReferenceMouseLeave), floating && (floating.addEventListener("mouseleave", onScrollMouseLeave), floating.addEventListener("mouseenter", onFloatingMouseEnter), floating.addEventListener("mouseleave", onFloatingMouseLeave)), () => {
+        open && reference2.removeEventListener("mouseleave", onScrollMouseLeave), move && reference2.removeEventListener("mousemove", onReferenceMouseEnter), reference2.removeEventListener("mouseenter", onReferenceMouseEnter), reference2.removeEventListener("mouseleave", onReferenceMouseLeave), floating && (floating.removeEventListener("mouseleave", onScrollMouseLeave), floating.removeEventListener("mouseenter", onFloatingMouseEnter), floating.removeEventListener("mouseleave", onFloatingMouseLeave)), cleanupMouseMoveHandler();
+      };
+    }
+  }, [elements, enabled, context, mouseOnly, move, open, dataRef]), React.useLayoutEffect(() => {
+    if (enabled && open && handleCloseRef.current?.__options?.blockPointerEvents && isHoverOpen()) {
+      performedPointerEventsMutationRef.current = !0;
+      const floatingEl = elements.floating;
+      if ((0, import_utils.isElement)(elements.domReference) && floatingEl) {
+        const body = (0, import_utils.getDocument)(elements.floating).body;
+        body.setAttribute(safePolygonIdentifier, "");
+        const ref = elements.domReference;
+        return body.style.pointerEvents = "none", ref.style.pointerEvents = "auto", floatingEl.style.pointerEvents = "auto", () => {
+          body.style.pointerEvents = "", ref.style.pointerEvents = "", floatingEl.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [enabled, open, elements, isHoverOpen]), React.useLayoutEffect(() => {
+    open || (pointerTypeRef.current = void 0, restTimeoutPendingRef.current = !1, cleanupMouseMoveHandler(), clearPointerEvents());
+  }, [open]), React.useEffect(() => () => {
+    cleanupMouseMoveHandler(), (0, import_utils.clearTimeoutIfSet)(timeoutRef), (0, import_utils.clearTimeoutIfSet)(restTimeoutRef), clearPointerEvents();
+  }, [enabled, elements.domReference]);
+  const reference = React.useMemo(() => {
+    function setPointerRef(event) {
+      pointerTypeRef.current = event.pointerType;
+    }
+    return {
+      onPointerDown: setPointerRef,
+      onPointerEnter: setPointerRef,
+      onMouseMove(event) {
+        const {
+          nativeEvent
+        } = event;
+        function handleMouseMove() {
+          !blockMouseMoveRef.current && !openRef.current && stableOnOpenChange(!0, nativeEvent, "hover");
+        }
+        mouseOnly && !(0, import_utils.isMouseLikePointerType)(pointerTypeRef.current) || open || restMsRef.current === 0 || restTimeoutPendingRef.current && event.movementX ** 2 + event.movementY ** 2 < 2 || ((0, import_utils.clearTimeoutIfSet)(restTimeoutRef), pointerTypeRef.current === "touch" ? handleMouseMove() : (restTimeoutPendingRef.current = !0, restTimeoutRef.current = window.setTimeout(handleMouseMove, restMsRef.current)));
+      }
+    };
+  }, [mouseOnly, open]);
+  return React.useMemo(() => enabled ? {
+    reference
+  } : {}, [enabled, reference]);
+}