@octanejs/base-ui 0.1.30 → 0.1.32

package/dist/cjs/utils/floating/useFloatingRootContext.cjs

@@ -0,0 +1,75 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var useFloatingRootContext_exports = {};
+__export(useFloatingRootContext_exports, {
+  useFloatingRootContext: () => useFloatingRootContext
+});
+module.exports = __toCommonJS(useFloatingRootContext_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_dom = require("../dom.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_popups = require("../popups/index.cjs");
+var import_FloatingTree = require("./FloatingTree.cjs");
+var import_FloatingRootStore = require("./FloatingRootStore.cjs");
+function useFloatingRootContext(options, slot) {
+  const localSlot = slot ?? (0, import_internal.S)("useFloatingRootContext");
+  const { open = false, onOpenChange, elements = {} } = options;
+  const floatingId = (0, import_octane.useId)((0, import_internal.subSlot)(localSlot, "id"));
+  const nested = (0, import_FloatingTree.useFloatingParentNodeId)() != null;
+  const store = (0, import_useRefWithInit.useRefWithInit)(
+    () => new import_FloatingRootStore.FloatingRootStore({
+      open,
+      transitionStatus: void 0,
+      onOpenChange,
+      referenceElement: elements.reference ?? null,
+      floatingElement: elements.floating ?? null,
+      triggerElements: new import_popups.PopupTriggerMap(),
+      floatingId,
+      syncOnly: false,
+      nested
+    }),
+    (0, import_internal.subSlot)(localSlot, "store")
+  ).current;
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      const valuesToSync = {
+        open,
+        floatingId
+      };
+      if (elements.reference !== void 0) {
+        valuesToSync.referenceElement = elements.reference;
+        valuesToSync.domReferenceElement = (0, import_dom.isElement)(elements.reference) ? elements.reference : null;
+      }
+      if (elements.floating !== void 0) {
+        valuesToSync.floatingElement = elements.floating;
+      }
+      store.update(valuesToSync);
+    },
+    [open, floatingId, elements.reference, elements.floating, store],
+    (0, import_internal.subSlot)(localSlot, "eff")
+  );
+  store.context.onOpenChange = onOpenChange;
+  store.context.nested = nested;
+  return store;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFloatingRootContext
+});

package/dist/cjs/utils/floating/useFocus.cjs

@@ -0,0 +1,184 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var useFocus_exports = {};
+__export(useFocus_exports, {
+  useFocus: () => useFocus
+});
+module.exports = __toCommonJS(useFocus_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_addEventListener = require("../addEventListener.cjs");
+var import_mergeCleanups = require("../mergeCleanups.cjs");
+var import_owner = require("../owner.cjs");
+var import_platform = require("../platform.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_dom = require("../dom.cjs");
+var import_matchesFocusVisible = require("../matchesFocusVisible.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+var import_createAttribute = require("./createAttribute.cjs");
+var import_element = require("./element.cjs");
+const isMacSafari = import_platform.platform.os.mac && import_platform.platform.engine.webkit;
+function useFocus(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useFocus");
+  const context = user[0];
+  const props = user[1] ?? {};
+  const { enabled = true, delay } = props;
+  const store = context != null && "rootStore" in context ? context.rootStore : context;
+  const { events, dataRef } = store.context;
+  const blockFocusRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "block"));
+  const blockedReferenceRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "blockedRef"));
+  const keyboardModalityRef = (0, import_octane.useRef)(true, (0, import_internal.subSlot)(slot, "kbd"));
+  const timeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "to"));
+  (0, import_octane.useEffect)(
+    () => {
+      const domReference = store.select("domReferenceElement");
+      if (!enabled) {
+        return void 0;
+      }
+      const win = (0, import_owner.ownerWindow)(domReference);
+      function onBlur() {
+        const currentDomReference = store.select("domReferenceElement");
+        if (!store.select("open") && (0, import_dom.isHTMLElement)(currentDomReference) && currentDomReference === (0, import_element.activeElement)((0, import_owner.ownerDocument)(currentDomReference))) {
+          blockFocusRef.current = true;
+        }
+      }
+      function onKeyDown() {
+        keyboardModalityRef.current = true;
+      }
+      function onPointerDown() {
+        keyboardModalityRef.current = false;
+      }
+      return (0, import_mergeCleanups.mergeCleanups)(
+        (0, import_addEventListener.addEventListener)(win, "blur", onBlur),
+        isMacSafari && (0, import_addEventListener.addEventListener)(win, "keydown", onKeyDown, true),
+        isMacSafari && (0, import_addEventListener.addEventListener)(win, "pointerdown", onPointerDown, true)
+      );
+    },
+    [store, enabled],
+    (0, import_internal.subSlot)(slot, "e:win")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (!enabled) {
+        return void 0;
+      }
+      function onOpenChangeLocal(details) {
+        if (details.reason === import_createChangeEventDetails.REASONS.triggerPress || details.reason === import_createChangeEventDetails.REASONS.escapeKey) {
+          const referenceElement = store.select("domReferenceElement");
+          if ((0, import_dom.isElement)(referenceElement)) {
+            blockedReferenceRef.current = referenceElement;
+            blockFocusRef.current = true;
+          }
+        }
+      }
+      events.on("openchange", onOpenChangeLocal);
+      return () => {
+        events.off("openchange", onOpenChangeLocal);
+      };
+    },
+    [events, enabled, store],
+    (0, import_internal.subSlot)(slot, "e:openchange")
+  );
+  const reference = (0, import_octane.useMemo)(
+    () => {
+      function resetBlockedFocus() {
+        blockFocusRef.current = false;
+        blockedReferenceRef.current = null;
+      }
+      return {
+        onMouseLeave() {
+          resetBlockedFocus();
+        },
+        onFocus(event) {
+          const focusTarget = event.currentTarget;
+          if (blockFocusRef.current) {
+            if (blockedReferenceRef.current === focusTarget) {
+              return;
+            }
+            resetBlockedFocus();
+          }
+          const target = (0, import_element.getTarget)(event);
+          if ((0, import_dom.isElement)(target)) {
+            if (isMacSafari && !event.relatedTarget) {
+              if (!keyboardModalityRef.current && !(0, import_element.isTypeableElement)(target)) {
+                return;
+              }
+            } else if (!(0, import_matchesFocusVisible.matchesFocusVisible)(target)) {
+              return;
+            }
+          }
+          const movedFromOtherEnabledTrigger = (0, import_element.isTargetInsideEnabledTrigger)(
+            event.relatedTarget,
+            store.context.triggerElements
+          );
+          const currentTarget = event.currentTarget;
+          const delayValue = typeof delay === "function" ? delay() : delay;
+          if (store.select("open") && movedFromOtherEnabledTrigger || delayValue === 0 || delayValue === void 0) {
+            store.setOpen(
+              true,
+              (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerFocus, event, currentTarget)
+            );
+            return;
+          }
+          timeout.start(delayValue, () => {
+            if (blockFocusRef.current) {
+              return;
+            }
+            store.setOpen(
+              true,
+              (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerFocus, event, currentTarget)
+            );
+          });
+        },
+        onBlur(event) {
+          resetBlockedFocus();
+          const relatedTarget = event.relatedTarget;
+          const movedToFocusGuard = (0, import_dom.isElement)(relatedTarget) && relatedTarget.hasAttribute((0, import_createAttribute.createAttribute)("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
+          timeout.start(0, () => {
+            const domReference = store.select("domReferenceElement");
+            const activeEl = (0, import_element.activeElement)((0, import_owner.ownerDocument)(domReference));
+            if (!relatedTarget && activeEl === domReference) {
+              return;
+            }
+            if ((0, import_element.contains)(dataRef.current.floatingContext?.refs.floating.current, activeEl) || (0, import_element.contains)(domReference, activeEl) || movedToFocusGuard) {
+              return;
+            }
+            const nextFocusedElement = relatedTarget ?? activeEl;
+            if ((0, import_element.isTargetInsideEnabledTrigger)(nextFocusedElement, store.context.triggerElements)) {
+              return;
+            }
+            store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerFocus, event));
+          });
+        }
+      };
+    },
+    [dataRef, delay, store, timeout],
+    (0, import_internal.subSlot)(slot, "ref")
+  );
+  return (0, import_octane.useMemo)(
+    () => enabled ? { reference, trigger: reference } : {},
+    [enabled, reference],
+    (0, import_internal.subSlot)(slot, "out")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFocus
+});

package/dist/cjs/utils/floating/useHoverFloatingInteraction.cjs

@@ -0,0 +1,231 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var useHoverFloatingInteraction_exports = {};
+__export(useHoverFloatingInteraction_exports, {
+  useHoverFloatingInteraction: () => useHoverFloatingInteraction
+});
+module.exports = __toCommonJS(useHoverFloatingInteraction_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_addEventListener = require("../addEventListener.cjs");
+var import_mergeCleanups = require("../mergeCleanups.cjs");
+var import_owner = require("../owner.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_dom = require("../dom.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+var import_FloatingTree = require("./FloatingTree.cjs");
+var import_element = require("./element.cjs");
+var import_nodes = require("./nodes.cjs");
+var import_useHoverInteractionSharedState = require("./useHoverInteractionSharedState.cjs");
+var import_useHoverShared = require("./useHoverShared.cjs");
+function useHoverFloatingInteraction(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useHoverFloatingInteraction");
+  const context = user[0];
+  const parameters = user[1] ?? {};
+  const { enabled = true, closeDelay: closeDelayProp = 0, nodeId: nodeIdProp } = parameters;
+  const store = context != null && "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "s:open"));
+  const floatingElement = store.useState("floatingElement", (0, import_internal.subSlot)(slot, "s:floating"));
+  const domReferenceElement = store.useState("domReferenceElement", (0, import_internal.subSlot)(slot, "s:ref"));
+  const dataRef = store.context.dataRef;
+  const tree = (0, import_FloatingTree.useFloatingTree)();
+  const parentId = (0, import_FloatingTree.useFloatingParentNodeId)();
+  const instance = (0, import_useHoverInteractionSharedState.useHoverInteractionSharedState)(store, (0, import_internal.subSlot)(slot, "shared"));
+  const childClosedTimeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "cct"));
+  const isClickLikeOpenEvent = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      return (0, import_useHoverShared.isClickLikeOpenEvent)(dataRef.current.openEvent?.type, instance.interactedInside);
+    },
+    (0, import_internal.subSlot)(slot, "iclo")
+  );
+  const isHoverOpen = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      return (0, import_useHoverShared.isHoverOpenEvent)(dataRef.current.openEvent?.type);
+    },
+    (0, import_internal.subSlot)(slot, "iho")
+  );
+  const clearPointerEvents = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      (0, import_useHoverInteractionSharedState.clearSafePolygonPointerEventsMutation)(instance);
+    },
+    (0, import_internal.subSlot)(slot, "cpe")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open) {
+        instance.pointerType = void 0;
+        instance.restTimeoutPending = false;
+        instance.interactedInside = false;
+        clearPointerEvents();
+      }
+    },
+    [open, instance, clearPointerEvents],
+    (0, import_internal.subSlot)(slot, "l:reset")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      return clearPointerEvents;
+    },
+    [clearPointerEvents],
+    (0, import_internal.subSlot)(slot, "e:cpe")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!enabled) {
+        return void 0;
+      }
+      if (open && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && (0, import_dom.isElement)(domReferenceElement) && floatingElement) {
+        const ref = domReferenceElement;
+        const floatingEl = floatingElement;
+        const doc = (0, import_owner.ownerDocument)(floatingElement);
+        const parentFloating = tree?.nodesRef.current.find((node) => node.id === parentId)?.context?.elements.floating;
+        if (parentFloating) {
+          parentFloating.style.pointerEvents = "";
+        }
+        const cachedScopeElement = instance.pointerEventsScopeElement !== floatingEl ? instance.pointerEventsScopeElement : null;
+        const parentScopeElement = parentFloating !== floatingEl ? parentFloating : null;
+        const scopeElement = instance.handleCloseOptions?.getScope?.() ?? cachedScopeElement ?? parentScopeElement ?? ref.closest("[data-rootownerid]") ?? doc.body;
+        (0, import_useHoverInteractionSharedState.applySafePolygonPointerEventsMutation)(instance, {
+          scopeElement,
+          referenceElement: ref,
+          floatingElement: floatingEl
+        });
+        return () => {
+          clearPointerEvents();
+        };
+      }
+      return void 0;
+    },
+    [
+      enabled,
+      open,
+      domReferenceElement,
+      floatingElement,
+      instance,
+      isHoverOpen,
+      tree,
+      parentId,
+      clearPointerEvents
+    ],
+    (0, import_internal.subSlot)(slot, "l:blockPointer")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (!enabled) {
+        return void 0;
+      }
+      function hasParentChildren() {
+        return !!(tree && parentId && (0, import_nodes.getNodeChildren)(tree.nodesRef.current, parentId).length > 0);
+      }
+      function closeWithDelay(event) {
+        const closeDelay = (0, import_useHoverShared.getDelay)(closeDelayProp, "close", instance.pointerType);
+        const close = () => {
+          store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerHover, event));
+          tree?.events.emit("floating.closed", event);
+        };
+        if (closeDelay) {
+          instance.openChangeTimeout.start(closeDelay, close);
+        } else {
+          instance.openChangeTimeout.clear();
+          close();
+        }
+      }
+      function handleInteractInside(event) {
+        const target = (0, import_element.getTarget)(event);
+        if (!(0, import_useHoverInteractionSharedState.isInteractiveElement)(target)) {
+          instance.interactedInside = false;
+          return;
+        }
+        instance.interactedInside = target?.closest("[aria-haspopup]") != null;
+      }
+      function onFloatingMouseEnter() {
+        instance.openChangeTimeout.clear();
+        childClosedTimeout.clear();
+        tree?.events.off("floating.closed", onNodeClosed);
+        clearPointerEvents();
+      }
+      function onFloatingMouseLeave(event) {
+        if (hasParentChildren() && tree) {
+          tree.events.on("floating.closed", onNodeClosed);
+          return;
+        }
+        if ((0, import_useHoverShared.isInsideEnabledTrigger)(event.relatedTarget, store.context.triggerElements)) {
+          return;
+        }
+        const currentNodeId = dataRef.current.floatingContext?.nodeId ?? nodeIdProp;
+        const relatedTarget = event.relatedTarget;
+        const isMovingIntoDescendantFloating = tree && currentNodeId && (0, import_dom.isElement)(relatedTarget) && (0, import_nodes.getNodeChildren)(tree.nodesRef.current, currentNodeId, false).some(
+          (node) => (0, import_element.contains)(node.context?.elements.floating, relatedTarget)
+        );
+        if (isMovingIntoDescendantFloating) {
+          return;
+        }
+        if (instance.handler) {
+          instance.handler(event);
+          return;
+        }
+        clearPointerEvents();
+        if (isHoverOpen() && !isClickLikeOpenEvent()) {
+          closeWithDelay(event);
+        }
+      }
+      function onNodeClosed(event) {
+        if (!tree || !parentId || hasParentChildren()) {
+          return;
+        }
+        childClosedTimeout.start(0, () => {
+          tree.events.off("floating.closed", onNodeClosed);
+          store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerHover, event));
+          tree.events.emit("floating.closed", event);
+        });
+      }
+      const floating = floatingElement;
+      return (0, import_mergeCleanups.mergeCleanups)(
+        floating && (0, import_addEventListener.addEventListener)(floating, "mouseenter", onFloatingMouseEnter),
+        floating && (0, import_addEventListener.addEventListener)(floating, "mouseleave", onFloatingMouseLeave),
+        floating && (0, import_addEventListener.addEventListener)(floating, "pointerdown", handleInteractInside, true),
+        () => {
+          tree?.events.off("floating.closed", onNodeClosed);
+        }
+      );
+    },
+    [
+      enabled,
+      floatingElement,
+      store,
+      dataRef,
+      closeDelayProp,
+      nodeIdProp,
+      isHoverOpen,
+      isClickLikeOpenEvent,
+      clearPointerEvents,
+      instance,
+      tree,
+      parentId,
+      childClosedTimeout
+    ],
+    (0, import_internal.subSlot)(slot, "e:listeners")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHoverFloatingInteraction
+});

package/dist/cjs/utils/floating/useHoverInteractionSharedState.cjs

@@ -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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var useHoverInteractionSharedState_exports = {};
+__export(useHoverInteractionSharedState_exports, {
+  HoverInteraction: () => HoverInteraction,
+  applySafePolygonPointerEventsMutation: () => applySafePolygonPointerEventsMutation,
+  clearSafePolygonPointerEventsMutation: () => clearSafePolygonPointerEventsMutation,
+  isInteractiveElement: () => import_element.isInteractiveElement,
+  useHoverInteractionSharedState: () => useHoverInteractionSharedState
+});
+module.exports = __toCommonJS(useHoverInteractionSharedState_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_element = require("./element.cjs");
+class HoverInteraction {
+  pointerType = void 0;
+  interactedInside = false;
+  handler = void 0;
+  blockMouseMove = true;
+  performedPointerEventsMutation = false;
+  pointerEventsScopeElement = null;
+  pointerEventsReferenceElement = null;
+  pointerEventsFloatingElement = null;
+  restTimeoutPending = false;
+  openChangeTimeout = new import_useTimeout.Timeout();
+  restTimeout = new import_useTimeout.Timeout();
+  handleCloseOptions = void 0;
+  static create() {
+    return new HoverInteraction();
+  }
+  dispose = () => {
+    this.openChangeTimeout.clear();
+    this.restTimeout.clear();
+  };
+  disposeEffect = () => {
+    return this.dispose;
+  };
+}
+const pointerEventsMutationOwnerByScopeElement = /* @__PURE__ */ new WeakMap();
+function clearSafePolygonPointerEventsMutation(instance) {
+  if (!instance.performedPointerEventsMutation) {
+    return;
+  }
+  const scopeElement = instance.pointerEventsScopeElement;
+  if (scopeElement && pointerEventsMutationOwnerByScopeElement.get(scopeElement) === instance) {
+    instance.pointerEventsScopeElement?.style.removeProperty("pointer-events");
+    instance.pointerEventsReferenceElement?.style.removeProperty("pointer-events");
+    instance.pointerEventsFloatingElement?.style.removeProperty("pointer-events");
+    pointerEventsMutationOwnerByScopeElement.delete(scopeElement);
+  }
+  instance.performedPointerEventsMutation = false;
+  instance.pointerEventsScopeElement = null;
+  instance.pointerEventsReferenceElement = null;
+  instance.pointerEventsFloatingElement = null;
+}
+function applySafePolygonPointerEventsMutation(instance, options) {
+  const { scopeElement, referenceElement, floatingElement } = options;
+  const existingOwner = pointerEventsMutationOwnerByScopeElement.get(scopeElement);
+  if (existingOwner && existingOwner !== instance) {
+    clearSafePolygonPointerEventsMutation(existingOwner);
+  }
+  clearSafePolygonPointerEventsMutation(instance);
+  instance.performedPointerEventsMutation = true;
+  instance.pointerEventsScopeElement = scopeElement;
+  instance.pointerEventsReferenceElement = referenceElement;
+  instance.pointerEventsFloatingElement = floatingElement;
+  pointerEventsMutationOwnerByScopeElement.set(scopeElement, instance);
+  scopeElement.style.pointerEvents = "none";
+  referenceElement.style.pointerEvents = "auto";
+  floatingElement.style.pointerEvents = "auto";
+}
+function useHoverInteractionSharedState(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useHoverInteractionSharedState");
+  const store = user[0];
+  const data = store.context.dataRef.current;
+  const instance = (0, import_useRefWithInit.useRefWithInit)(
+    () => data.hoverInteractionState ?? HoverInteraction.create(),
+    void 0,
+    (0, import_internal.subSlot)(slot, "inst")
+  ).current;
+  if (!data.hoverInteractionState) {
+    data.hoverInteractionState = instance;
+  }
+  (0, import_octane.useEffect)(data.hoverInteractionState.disposeEffect, [], (0, import_internal.subSlot)(slot, "e:mount"));
+  return data.hoverInteractionState;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HoverInteraction,
+  applySafePolygonPointerEventsMutation,
+  clearSafePolygonPointerEventsMutation,
+  isInteractiveElement,
+  useHoverInteractionSharedState
+});