dune-react 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useFocus.js

@@ -0,0 +1,146 @@
+import * as React from "react";
+import { getWindow, isElement, isHTMLElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { isMac, isSafari } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/detectBrowser.js";
+import { useTimeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { createAttribute } from "../utils/createAttribute.js";
+import { activeElement, contains, isTargetInsideEnabledTrigger, getTarget, isTypeableElement, matchesFocusVisible } from "../utils/element.js";
+import { triggerFocus, triggerPress, escapeKey } from "../../utils/reason-parts.js";
+const isMacSafari = isMac && isSafari;
+function useFocus(context, props = {}) {
+  const store = "rootStore" in context ? context.rootStore : context;
+  const {
+    events,
+    dataRef
+  } = store.context;
+  const {
+    enabled = true,
+    delay
+  } = props;
+  const blockFocusRef = React.useRef(false);
+  const blockedReferenceRef = React.useRef(null);
+  const timeout = useTimeout();
+  const keyboardModalityRef = React.useRef(true);
+  React.useEffect(() => {
+    const domReference = store.select("domReferenceElement");
+    if (!enabled) {
+      return void 0;
+    }
+    const win = getWindow(domReference);
+    function onBlur() {
+      const currentDomReference = store.select("domReferenceElement");
+      if (!store.select("open") && isHTMLElement(currentDomReference) && currentDomReference === activeElement(ownerDocument(currentDomReference))) {
+        blockFocusRef.current = true;
+      }
+    }
+    function onKeyDown() {
+      keyboardModalityRef.current = true;
+    }
+    function onPointerDown() {
+      keyboardModalityRef.current = false;
+    }
+    win.addEventListener("blur", onBlur);
+    if (isMacSafari) {
+      win.addEventListener("keydown", onKeyDown, true);
+      win.addEventListener("pointerdown", onPointerDown, true);
+    }
+    return () => {
+      win.removeEventListener("blur", onBlur);
+      if (isMacSafari) {
+        win.removeEventListener("keydown", onKeyDown, true);
+        win.removeEventListener("pointerdown", onPointerDown, true);
+      }
+    };
+  }, [store, enabled]);
+  React.useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    function onOpenChangeLocal(details) {
+      if (details.reason === triggerPress || details.reason === escapeKey) {
+        const referenceElement = store.select("domReferenceElement");
+        if (isElement(referenceElement)) {
+          blockedReferenceRef.current = referenceElement;
+          blockFocusRef.current = true;
+        }
+      }
+    }
+    events.on("openchange", onOpenChangeLocal);
+    return () => {
+      events.off("openchange", onOpenChangeLocal);
+    };
+  }, [events, enabled, store]);
+  const reference = React.useMemo(() => ({
+    onMouseLeave() {
+      blockFocusRef.current = false;
+      blockedReferenceRef.current = null;
+    },
+    onFocus(event) {
+      const focusTarget = event.currentTarget;
+      if (blockFocusRef.current) {
+        if (blockedReferenceRef.current === focusTarget) {
+          return;
+        }
+        blockFocusRef.current = false;
+        blockedReferenceRef.current = null;
+      }
+      const target = getTarget(event.nativeEvent);
+      if (isElement(target)) {
+        if (isMacSafari && !event.relatedTarget) {
+          if (!keyboardModalityRef.current && !isTypeableElement(target)) {
+            return;
+          }
+        } else if (!matchesFocusVisible(target)) {
+          return;
+        }
+      }
+      const movedFromOtherEnabledTrigger = isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements);
+      const {
+        nativeEvent,
+        currentTarget
+      } = event;
+      const delayValue = typeof delay === "function" ? delay() : delay;
+      if (store.select("open") && movedFromOtherEnabledTrigger || delayValue === 0 || delayValue === void 0) {
+        store.setOpen(true, createChangeEventDetails(triggerFocus, nativeEvent, currentTarget));
+        return;
+      }
+      timeout.start(delayValue, () => {
+        if (blockFocusRef.current) {
+          return;
+        }
+        store.setOpen(true, createChangeEventDetails(triggerFocus, nativeEvent, currentTarget));
+      });
+    },
+    onBlur(event) {
+      blockFocusRef.current = false;
+      blockedReferenceRef.current = null;
+      const relatedTarget = event.relatedTarget;
+      const nativeEvent = event.nativeEvent;
+      const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
+      timeout.start(0, () => {
+        var _a;
+        const domReference = store.select("domReferenceElement");
+        const activeEl = activeElement(domReference ? domReference.ownerDocument : document);
+        if (!relatedTarget && activeEl === domReference) {
+          return;
+        }
+        if (contains((_a = dataRef.current.floatingContext) == null ? void 0 : _a.refs.floating.current, activeEl) || contains(domReference, activeEl) || movedToFocusGuard) {
+          return;
+        }
+        const nextFocusedElement = relatedTarget ?? activeEl;
+        if (isTargetInsideEnabledTrigger(nextFocusedElement, store.context.triggerElements)) {
+          return;
+        }
+        store.setOpen(false, createChangeEventDetails(triggerFocus, nativeEvent));
+      });
+    }
+  }), [dataRef, store, timeout, delay]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    trigger: reference
+  } : {}, [enabled, reference]);
+}
+export {
+  useFocus
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverFloatingInteraction.js

@@ -0,0 +1,157 @@
+import * as React from "react";
+import { isElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useTimeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useFloatingTree, useFloatingParentNodeId } from "../components/FloatingTree.js";
+import { useHoverInteractionSharedState, clearSafePolygonPointerEventsMutation, isInteractiveElement, applySafePolygonPointerEventsMutation } from "./useHoverInteractionSharedState.js";
+import { isClickLikeOpenEvent, getDelay } from "./useHoverShared.js";
+import { isTargetInsideEnabledTrigger, getTarget } from "../utils/element.js";
+import { triggerHover } from "../../utils/reason-parts.js";
+import { getNodeChildren } from "../utils/nodes.js";
+function useHoverFloatingInteraction(context, parameters = {}) {
+  const store = "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open");
+  const floatingElement = store.useState("floatingElement");
+  const domReferenceElement = store.useState("domReferenceElement");
+  const {
+    dataRef
+  } = store.context;
+  const {
+    enabled = true,
+    closeDelay: closeDelayProp = 0
+  } = parameters;
+  const instance = useHoverInteractionSharedState(store);
+  const tree = useFloatingTree();
+  const parentId = useFloatingParentNodeId();
+  const isClickLikeOpenEvent$1 = useStableCallback(() => {
+    var _a;
+    return isClickLikeOpenEvent((_a = dataRef.current.openEvent) == null ? void 0 : _a.type, instance.interactedInside);
+  });
+  const isHoverOpen = useStableCallback(() => {
+    var _a;
+    const type = (_a = dataRef.current.openEvent) == null ? void 0 : _a.type;
+    return (type == null ? void 0 : type.includes("mouse")) && type !== "mousedown";
+  });
+  const isRelatedTargetInsideEnabledTrigger = useStableCallback((target) => {
+    return isTargetInsideEnabledTrigger(target, store.context.triggerElements);
+  });
+  const closeWithDelay = React.useCallback((event) => {
+    const closeDelay = getDelay(closeDelayProp, "close", instance.pointerType);
+    const close = () => {
+      store.setOpen(false, createChangeEventDetails(triggerHover, event));
+      tree == null ? void 0 : tree.events.emit("floating.closed", event);
+    };
+    if (closeDelay) {
+      instance.openChangeTimeout.start(closeDelay, close);
+    } else {
+      instance.openChangeTimeout.clear();
+      close();
+    }
+  }, [closeDelayProp, store, instance, tree]);
+  const clearPointerEvents = useStableCallback(() => {
+    clearSafePolygonPointerEventsMutation(instance);
+  });
+  const handleInteractInside = useStableCallback((event) => {
+    const target = getTarget(event);
+    if (!isInteractiveElement(target)) {
+      instance.interactedInside = false;
+      return;
+    }
+    instance.interactedInside = (target == null ? void 0 : target.closest("[aria-haspopup]")) != null;
+  });
+  useIsoLayoutEffect(() => {
+    if (!open) {
+      instance.pointerType = void 0;
+      instance.restTimeoutPending = false;
+      instance.interactedInside = false;
+      clearPointerEvents();
+    }
+  }, [open, instance, clearPointerEvents]);
+  React.useEffect(() => {
+    return clearPointerEvents;
+  }, [clearPointerEvents]);
+  useIsoLayoutEffect(() => {
+    var _a, _b, _c, _d, _e;
+    if (!enabled) {
+      return void 0;
+    }
+    if (open && ((_a = instance.handleCloseOptions) == null ? void 0 : _a.blockPointerEvents) && isHoverOpen() && isElement(domReferenceElement) && floatingElement) {
+      const ref = domReferenceElement;
+      const floatingEl = floatingElement;
+      const doc = ownerDocument(floatingElement);
+      const parentFloating = (_c = (_b = tree == null ? void 0 : tree.nodesRef.current.find((node) => node.id === parentId)) == null ? void 0 : _b.context) == null ? void 0 : _c.elements.floating;
+      if (parentFloating) {
+        parentFloating.style.pointerEvents = "";
+      }
+      const scopeElement = ((_e = (_d = instance.handleCloseOptions) == null ? void 0 : _d.getScope) == null ? void 0 : _e.call(_d)) ?? instance.pointerEventsScopeElement ?? parentFloating ?? ref.closest("[data-rootownerid]") ?? doc.body;
+      applySafePolygonPointerEventsMutation(instance, {
+        scopeElement,
+        referenceElement: ref,
+        floatingElement: floatingEl
+      });
+      return () => {
+        clearPointerEvents();
+      };
+    }
+    return void 0;
+  }, [enabled, open, domReferenceElement, floatingElement, instance, isHoverOpen, tree, parentId, clearPointerEvents]);
+  const childClosedTimeout = useTimeout();
+  React.useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    function onFloatingMouseEnter() {
+      instance.openChangeTimeout.clear();
+      childClosedTimeout.clear();
+      tree == null ? void 0 : tree.events.off("floating.closed", onNodeClosed);
+      clearPointerEvents();
+    }
+    function onFloatingMouseLeave(event) {
+      if (tree && parentId && getNodeChildren(tree.nodesRef.current, parentId).length > 0) {
+        tree.events.on("floating.closed", onNodeClosed);
+        return;
+      }
+      if (isRelatedTargetInsideEnabledTrigger(event.relatedTarget)) {
+        return;
+      }
+      if (instance.handler) {
+        instance.handler(event);
+        return;
+      }
+      clearPointerEvents();
+      if (!isClickLikeOpenEvent$1()) {
+        closeWithDelay(event);
+      }
+    }
+    function onNodeClosed(event) {
+      if (!tree || !parentId || getNodeChildren(tree.nodesRef.current, parentId).length > 0) {
+        return;
+      }
+      childClosedTimeout.start(0, () => {
+        tree.events.off("floating.closed", onNodeClosed);
+        store.setOpen(false, createChangeEventDetails(triggerHover, event));
+        tree.events.emit("floating.closed", event);
+      });
+    }
+    const floating = floatingElement;
+    if (floating) {
+      floating.addEventListener("mouseenter", onFloatingMouseEnter);
+      floating.addEventListener("mouseleave", onFloatingMouseLeave);
+      floating.addEventListener("pointerdown", handleInteractInside, true);
+    }
+    return () => {
+      if (floating) {
+        floating.removeEventListener("mouseenter", onFloatingMouseEnter);
+        floating.removeEventListener("mouseleave", onFloatingMouseLeave);
+        floating.removeEventListener("pointerdown", handleInteractInside, true);
+      }
+      tree == null ? void 0 : tree.events.off("floating.closed", onNodeClosed);
+    };
+  }, [enabled, floatingElement, store, dataRef, isClickLikeOpenEvent$1, isRelatedTargetInsideEnabledTrigger, closeWithDelay, clearPointerEvents, handleInteractInside, instance, tree, parentId, childClosedTimeout]);
+}
+export {
+  useHoverFloatingInteraction
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverInteractionSharedState.js

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { useOnMount } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useOnMount.js";
+import { useRefWithInit } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useRefWithInit.js";
+import { Timeout } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useTimeout.js";
+import { TYPEABLE_SELECTOR } from "../utils/constants.js";
+const interactiveSelector = `button,a,[role="button"],select,[tabindex]:not([tabindex="-1"]),${TYPEABLE_SELECTOR}`;
+function isInteractiveElement(element) {
+  return element ? Boolean(element.closest(interactiveSelector)) : false;
+}
+class HoverInteraction {
+  constructor() {
+    __publicField(this, "dispose", () => {
+      this.openChangeTimeout.clear();
+      this.restTimeout.clear();
+    });
+    __publicField(this, "disposeEffect", () => {
+      return this.dispose;
+    });
+    this.pointerType = void 0;
+    this.interactedInside = false;
+    this.handler = void 0;
+    this.blockMouseMove = true;
+    this.performedPointerEventsMutation = false;
+    this.pointerEventsScopeElement = null;
+    this.pointerEventsReferenceElement = null;
+    this.pointerEventsFloatingElement = null;
+    this.restTimeoutPending = false;
+    this.openChangeTimeout = new Timeout();
+    this.restTimeout = new Timeout();
+    this.handleCloseOptions = void 0;
+  }
+  static create() {
+    return new HoverInteraction();
+  }
+}
+function clearSafePolygonPointerEventsMutation(instance) {
+  var _a, _b, _c;
+  if (!instance.performedPointerEventsMutation) {
+    return;
+  }
+  (_a = instance.pointerEventsScopeElement) == null ? void 0 : _a.style.removeProperty("pointer-events");
+  (_b = instance.pointerEventsReferenceElement) == null ? void 0 : _b.style.removeProperty("pointer-events");
+  (_c = instance.pointerEventsFloatingElement) == null ? void 0 : _c.style.removeProperty("pointer-events");
+  instance.performedPointerEventsMutation = false;
+  instance.pointerEventsScopeElement = null;
+  instance.pointerEventsReferenceElement = null;
+  instance.pointerEventsFloatingElement = null;
+}
+function applySafePolygonPointerEventsMutation(instance, options) {
+  const {
+    scopeElement,
+    referenceElement,
+    floatingElement
+  } = options;
+  clearSafePolygonPointerEventsMutation(instance);
+  instance.performedPointerEventsMutation = true;
+  instance.pointerEventsScopeElement = scopeElement;
+  instance.pointerEventsReferenceElement = referenceElement;
+  instance.pointerEventsFloatingElement = floatingElement;
+  scopeElement.style.pointerEvents = "none";
+  referenceElement.style.pointerEvents = "auto";
+  floatingElement.style.pointerEvents = "auto";
+}
+function useHoverInteractionSharedState(store) {
+  const instance = useRefWithInit(HoverInteraction.create).current;
+  const data = store.context.dataRef.current;
+  if (!data.hoverInteractionState) {
+    data.hoverInteractionState = instance;
+  }
+  useOnMount(data.hoverInteractionState.disposeEffect);
+  return data.hoverInteractionState;
+}
+export {
+  HoverInteraction,
+  applySafePolygonPointerEventsMutation,
+  clearSafePolygonPointerEventsMutation,
+  isInteractiveElement,
+  useHoverInteractionSharedState
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverReferenceInteraction.js

@@ -0,0 +1,254 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { isElement } from "../../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useValueAsRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useValueAsRef.js";
+import { useStableCallback } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { ownerDocument } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { useFloatingTree } from "../components/FloatingTree.js";
+import { useHoverInteractionSharedState, clearSafePolygonPointerEventsMutation } from "./useHoverInteractionSharedState.js";
+import { isClickLikeOpenEvent, getDelay, getRestMs } from "./useHoverShared.js";
+import { isTargetInsideEnabledTrigger, contains } from "../utils/element.js";
+import { triggerHover } from "../../utils/reason-parts.js";
+import { isMouseLikePointerType } from "../utils/event.js";
+const EMPTY_REF = {
+  current: null
+};
+function useHoverReferenceInteraction(context, props = {}) {
+  var _a;
+  const store = "rootStore" in context ? context.rootStore : context;
+  const {
+    dataRef,
+    events
+  } = store.context;
+  const {
+    enabled = true,
+    delay = 0,
+    handleClose = null,
+    mouseOnly = false,
+    restMs = 0,
+    move = true,
+    triggerElementRef = EMPTY_REF,
+    externalTree,
+    isActiveTrigger = true,
+    getHandleCloseContext
+  } = props;
+  const tree = useFloatingTree(externalTree);
+  const instance = useHoverInteractionSharedState(store);
+  const handleCloseRef = useValueAsRef(handleClose);
+  const delayRef = useValueAsRef(delay);
+  const restMsRef = useValueAsRef(restMs);
+  const enabledRef = useValueAsRef(enabled);
+  if (isActiveTrigger) {
+    instance.handleCloseOptions = (_a = handleCloseRef.current) == null ? void 0 : _a.__options;
+  }
+  const isClickLikeOpenEvent$1 = useStableCallback(() => {
+    var _a2;
+    return isClickLikeOpenEvent((_a2 = dataRef.current.openEvent) == null ? void 0 : _a2.type, instance.interactedInside);
+  });
+  const isRelatedTargetInsideEnabledTrigger = useStableCallback((target) => {
+    return isTargetInsideEnabledTrigger(target, store.context.triggerElements);
+  });
+  const isOverInactiveTrigger = useStableCallback((currentDomReference, currentTarget, target) => {
+    const allTriggers = store.context.triggerElements;
+    if (allTriggers.hasElement(currentTarget)) {
+      return !currentDomReference || !contains(currentDomReference, currentTarget);
+    }
+    if (!isElement(target)) {
+      return false;
+    }
+    const targetElement = target;
+    return allTriggers.hasMatchingElement((trigger) => contains(trigger, targetElement)) && (!currentDomReference || !contains(currentDomReference, targetElement));
+  });
+  const closeWithDelay = React.useCallback((event, runElseBranch = true) => {
+    const closeDelay = getDelay(delayRef.current, "close", instance.pointerType);
+    if (closeDelay) {
+      instance.openChangeTimeout.start(closeDelay, () => {
+        store.setOpen(false, createChangeEventDetails(triggerHover, event));
+        tree == null ? void 0 : tree.events.emit("floating.closed", event);
+      });
+    } else if (runElseBranch) {
+      instance.openChangeTimeout.clear();
+      store.setOpen(false, createChangeEventDetails(triggerHover, event));
+      tree == null ? void 0 : tree.events.emit("floating.closed", event);
+    }
+  }, [delayRef, store, instance, tree]);
+  const cleanupMouseMoveHandler = useStableCallback(() => {
+    if (!instance.handler) {
+      return;
+    }
+    const doc = ownerDocument(store.select("domReferenceElement"));
+    doc.removeEventListener("mousemove", instance.handler);
+    instance.handler = void 0;
+  });
+  React.useEffect(() => cleanupMouseMoveHandler, [cleanupMouseMoveHandler]);
+  const clearPointerEvents = useStableCallback(() => {
+    clearSafePolygonPointerEventsMutation(instance);
+  });
+  React.useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    function onOpenChangeLocal(details) {
+      if (!details.open) {
+        cleanupMouseMoveHandler();
+        instance.openChangeTimeout.clear();
+        instance.restTimeout.clear();
+        instance.blockMouseMove = true;
+        instance.restTimeoutPending = false;
+      }
+    }
+    events.on("openchange", onOpenChangeLocal);
+    return () => {
+      events.off("openchange", onOpenChangeLocal);
+    };
+  }, [enabled, events, instance, cleanupMouseMoveHandler]);
+  React.useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    const trigger = triggerElementRef.current ?? (isActiveTrigger ? store.select("domReferenceElement") : null);
+    if (!isElement(trigger)) {
+      return void 0;
+    }
+    function onMouseEnter(event) {
+      instance.openChangeTimeout.clear();
+      instance.blockMouseMove = false;
+      if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
+        return;
+      }
+      const restMsValue = getRestMs(restMsRef.current);
+      if (restMsValue > 0 && !getDelay(delayRef.current, "open")) {
+        return;
+      }
+      const openDelay = getDelay(delayRef.current, "open", instance.pointerType);
+      const triggerNode = event.currentTarget ?? null;
+      const currentDomReference = store.select("domReferenceElement");
+      const isOverInactive = triggerNode == null ? false : isOverInactiveTrigger(currentDomReference, triggerNode, event.target);
+      const isOpen = store.select("open");
+      const shouldOpen = !isOpen || isOverInactive;
+      if (isOverInactive && isOpen) {
+        store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+      } else if (openDelay) {
+        instance.openChangeTimeout.start(openDelay, () => {
+          if (shouldOpen) {
+            store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+          }
+        });
+      } else if (shouldOpen) {
+        store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerNode));
+      }
+    }
+    function onMouseLeave(event) {
+      if (isClickLikeOpenEvent$1()) {
+        clearPointerEvents();
+        return;
+      }
+      cleanupMouseMoveHandler();
+      const domReferenceElement = store.select("domReferenceElement");
+      const doc = ownerDocument(domReferenceElement);
+      instance.restTimeout.clear();
+      instance.restTimeoutPending = false;
+      const handleCloseContextBase = dataRef.current.floatingContext ?? (getHandleCloseContext == null ? void 0 : getHandleCloseContext());
+      const ignoreRelatedTargetTrigger = isRelatedTargetInsideEnabledTrigger(event.relatedTarget);
+      if (ignoreRelatedTargetTrigger) {
+        return;
+      }
+      if (handleCloseRef.current && handleCloseContextBase) {
+        if (!store.select("open")) {
+          instance.openChangeTimeout.clear();
+        }
+        const currentTrigger = triggerElementRef.current;
+        instance.handler = handleCloseRef.current({
+          ...handleCloseContextBase,
+          tree,
+          x: event.clientX,
+          y: event.clientY,
+          onClose() {
+            clearPointerEvents();
+            cleanupMouseMoveHandler();
+            if (enabledRef.current && !isClickLikeOpenEvent$1() && currentTrigger === store.select("domReferenceElement")) {
+              closeWithDelay(event, true);
+            }
+          }
+        });
+        doc.addEventListener("mousemove", instance.handler);
+        instance.handler(event);
+        return;
+      }
+      const shouldClose = instance.pointerType === "touch" ? !contains(store.select("floatingElement"), event.relatedTarget) : true;
+      if (shouldClose) {
+        closeWithDelay(event);
+      }
+    }
+    if (move) {
+      trigger.addEventListener("mousemove", onMouseEnter, {
+        once: true
+      });
+    }
+    trigger.addEventListener("mouseenter", onMouseEnter);
+    trigger.addEventListener("mouseleave", onMouseLeave);
+    return () => {
+      if (move) {
+        trigger.removeEventListener("mousemove", onMouseEnter);
+      }
+      trigger.removeEventListener("mouseenter", onMouseEnter);
+      trigger.removeEventListener("mouseleave", onMouseLeave);
+    };
+  }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, closeWithDelay, store, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent$1, isRelatedTargetInsideEnabledTrigger, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext]);
+  return React.useMemo(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    function setPointerRef(event) {
+      instance.pointerType = event.pointerType;
+    }
+    return {
+      onPointerDown: setPointerRef,
+      onPointerEnter: setPointerRef,
+      onMouseMove(event) {
+        const {
+          nativeEvent
+        } = event;
+        const trigger = event.currentTarget;
+        const currentDomReference = store.select("domReferenceElement");
+        const currentOpen = store.select("open");
+        const isOverInactive = isOverInactiveTrigger(currentDomReference, trigger, event.target);
+        if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
+          return;
+        }
+        const restMsValue = getRestMs(restMsRef.current);
+        if (currentOpen && !isOverInactive || restMsValue === 0) {
+          return;
+        }
+        if (!isOverInactive && instance.restTimeoutPending && event.movementX ** 2 + event.movementY ** 2 < 2) {
+          return;
+        }
+        instance.restTimeout.clear();
+        function handleMouseMove() {
+          instance.restTimeoutPending = false;
+          if (isClickLikeOpenEvent$1()) {
+            return;
+          }
+          const latestOpen = store.select("open");
+          if (!instance.blockMouseMove && (!latestOpen || isOverInactive)) {
+            store.setOpen(true, createChangeEventDetails(triggerHover, nativeEvent, trigger));
+          }
+        }
+        if (instance.pointerType === "touch") {
+          ReactDOM.flushSync(() => {
+            handleMouseMove();
+          });
+        } else if (isOverInactive && currentOpen) {
+          handleMouseMove();
+        } else {
+          instance.restTimeoutPending = true;
+          instance.restTimeout.start(restMsValue, handleMouseMove);
+        }
+      }
+    };
+  }, [enabled, instance, isClickLikeOpenEvent$1, isOverInactiveTrigger, mouseOnly, store, restMsRef]);
+}
+export {
+  useHoverReferenceInteraction
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useHoverShared.js

@@ -0,0 +1,31 @@
+import { isMouseLikePointerType } from "../utils/event.js";
+function resolveValue(value, pointerType) {
+  if (pointerType != null && !isMouseLikePointerType(pointerType)) {
+    return 0;
+  }
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+function getDelay(value, prop, pointerType) {
+  const result = resolveValue(value, pointerType);
+  if (typeof result === "number") {
+    return result;
+  }
+  return result == null ? void 0 : result[prop];
+}
+function getRestMs(value) {
+  if (typeof value === "function") {
+    return value();
+  }
+  return value;
+}
+function isClickLikeOpenEvent(openEventType, interactedInside) {
+  return interactedInside || openEventType === "click" || openEventType === "mousedown";
+}
+export {
+  getDelay,
+  getRestMs,
+  isClickLikeOpenEvent
+};