@allxsmith/bestax-bulma 5.27.7 → 5.28.0

package/dist/esm/helpers/useHoverOpen.js

@@ -0,0 +1,390 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { useRef, useCallback, useMemo } from 'react';
+import { useClientLayoutEffect } from './useClientLayoutEffect.js';
+import { isEventInside, getDeepestActiveElement } from './shadowDom.js';
+
+// INTERNAL: deliberately not exported from src/index.ts.
+/**
+ * Whether focus that just arrived on `el` is keyboard focus, as the browser
+ * decides it for `:focus-visible`: focus from a key or from the browser's
+ * own controls is, focus a press brings isn't, and focus a script moves
+ * follows whichever came last. A browser that can't match the selector
+ * throws, and then every focus counts, so keyboard users can still open it.
+ */
+function isKeyboardFocus(el) {
+    try {
+        return el.matches(':focus-visible');
+    }
+    catch {
+        return true;
+    }
+}
+/** Whether `node` is `container` or inside it, when there are both. */
+const within = (container, node) => Boolean(container && node && container.contains(node));
+/**
+ * Per document, the hooks that want Escape and the one listener they share
+ * while there are any, so a card inside another card doesn't add a second
+ * listener that closes both on one keypress.
+ */
+const escapeListeners = new Map();
+/** Counts openings across the page, so the most recent one is known. */
+let openings = 0;
+/**
+ * Adds `entry` to the hooks that want Escape on `doc`, starting the shared
+ * listener when it is the first.
+ *
+ * Escape takes back every open that is on its way, so nothing appears right
+ * after it, and closes one open floating element, chosen by these rules in
+ * turn:
+ *
+ * 1. One that focus is in, on its trigger or inside it, when there is one.
+ * 2. The innermost: one whose floating element holds no other's trigger.
+ *    That follows nesting whether either one is portaled, since an inner
+ *    trigger sits in the outer floating element either way.
+ * 3. The one that opened last.
+ *
+ * The keypress belongs to whatever has focus. When that is one of the open
+ * floating elements or their triggers, or nothing, the listener stops it in
+ * the capture phase, before anything around (a Popover, a Modal) sees it.
+ * When focus is anywhere else, such as a combobox or a dialog of its own,
+ * the floating element still closes, since hover put it there without
+ * focus, and the key goes on to that owner.
+ *
+ * @returns What to call when the hook stops wanting Escape.
+ */
+function wantEscape(doc, entry) {
+    let listener = escapeListeners.get(doc);
+    if (!listener) {
+        const entries = new Set();
+        const handleKeyDown = (event) => {
+            if (event.key !== 'Escape')
+                return;
+            const open = [];
+            // A copy, since taking an open back can take its hook out of the set.
+            for (const each of [...entries]) {
+                if (each.openedAt)
+                    open.push(each);
+                else
+                    each.cancel();
+            }
+            const focused = getDeepestActiveElement(doc);
+            const holding = open.filter(each => within(each.trigger(), focused) || within(each.floating(), focused));
+            const pool = holding.length > 0 ? holding : open;
+            let top;
+            for (const each of pool) {
+                const holdsAnother = pool.some(other => other !== each && within(each.floating(), other.trigger()));
+                if (!holdsAnother && (!top || each.openedAt > top.openedAt)) {
+                    top = each;
+                }
+            }
+            if (!top)
+                return;
+            if (holding.length > 0 || !focused || focused === doc.body) {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+            top.close();
+        };
+        doc.addEventListener('keydown', handleKeyDown, true);
+        listener = {
+            entries,
+            stop: () => {
+                doc.removeEventListener('keydown', handleKeyDown, true);
+                escapeListeners.delete(doc);
+            },
+        };
+        escapeListeners.set(doc, listener);
+    }
+    const shared = listener;
+    shared.entries.add(entry);
+    return () => {
+        shared.entries.delete(entry);
+        if (shared.entries.size === 0)
+            shared.stop();
+    };
+}
+/**
+ * Decides when a floating element that opens on hover or keyboard focus asks
+ * to open and to close. It renders nothing, and leaves roles, ARIA and
+ * placement to the component that calls it.
+ *
+ * - The pointer entering, or keyboard focus arriving on the trigger, asks to
+ *   open after `openDelay`. A touch pointer doesn't count. Neither does focus
+ *   that a press brings to the trigger: it counts when the browser shows it
+ *   as `:focus-visible`.
+ * - Focus in the floating element holds it open however it got there,
+ *   including focus in content it portals elsewhere, such as a nested card.
+ *   Whether a click focuses what it lands on is up to the browser: Safari
+ *   and Firefox on macOS don't focus a button on click, so there a clicked
+ *   button doesn't hold it once the pointer leaves.
+ * - Once the pointer and focus have both left, it asks to close after
+ *   `closeDelay`, and either coming back before then keeps it open. Nothing
+ *   else closes it on a timer.
+ * - Escape closes it at once, wherever focus is, and stops there when focus
+ *   is in it, on its trigger or nowhere, so a `Popover` or `Modal` around it
+ *   keeps its own. With focus somewhere else, the key goes on after closing
+ *   it. Inside another one, the inner one closes first. Escape before it
+ *   opens takes the opening back and goes on its way. One key listener per
+ *   document serves every hook on it, there only while one of them is open
+ *   or on its way to open.
+ * - With `openOnTap`, a tap on the trigger opens it at once and the next tap
+ *   on the trigger closes it. While a tap holds it open, a press outside the
+ *   trigger and the floating element closes it, from a listener on the
+ *   document that is there only then. Taps never count as hover, and mouse
+ *   and pen work the same with it or without.
+ * - Once it closes, for any reason, whatever was holding it open has to
+ *   leave and come back to open it again.
+ * - When the floating element closes with focus inside it, focus goes back
+ *   to the trigger, unless the same update put it somewhere else. Handing it
+ *   back doesn't count as focus arriving.
+ *
+ * Nothing it scheduled runs after the component unmounts.
+ *
+ * @function useHoverOpen
+ * @param options - The open state, how to ask for another, the delays, and the two elements.
+ * @returns Handlers for the element that holds the trigger.
+ */
+function useHoverOpen(options) {
+    const latestRef = useRef(options);
+    const stateRef = useRef({
+        pointerIn: false,
+        focusIn: false,
+        focusInFloating: false,
+        held: false,
+        opening: false,
+        asked: false,
+        restoring: false,
+    });
+    // In the hooks that want Escape from the moment an open is on its way until
+    // the floating element closes, and out otherwise. Stamped with the order it
+    // opened in.
+    const listenForEscape = useCallback(function listen() {
+        const s = stateRef.current;
+        const entry = entryRef.current;
+        const { open, triggerRef } = latestRef.current;
+        if (!open)
+            entry.openedAt = 0;
+        else if (!entry.openedAt) {
+            openings += 1;
+            entry.openedAt = openings;
+        }
+        const wanted = open || s.opening || s.asked;
+        if (wanted === Boolean(s.releaseEscape))
+            return;
+        if (s.releaseEscape) {
+            s.releaseEscape();
+            s.releaseEscape = undefined;
+            return;
+        }
+        const doc = triggerRef.current?.ownerDocument ?? document;
+        s.releaseEscape = wantEscape(doc, entry);
+    }, []);
+    const entryRef = useRef({
+        openedAt: 0,
+        trigger: () => latestRef.current.triggerRef.current,
+        floating: () => latestRef.current.floatingRef.current,
+        // Only ever called while an open is on its way, so it is one or the
+        // other: still waiting on its delay, or asked for already.
+        cancel: () => {
+            const s = stateRef.current;
+            clearTimeout(s.timer);
+            // An ask already made is taken back by asking the other way.
+            if (s.asked)
+                latestRef.current.onOpenChange(false);
+            s.opening = false;
+            s.asked = false;
+            listenForEscape();
+        },
+        close: () => {
+            clearTimeout(stateRef.current.timer);
+            latestRef.current.onOpenChange(false);
+        },
+    });
+    // Asks to open or to close. Escape can take an ask to open back until it is
+    // answered: by the commit that follows it, or, when the caller keeps it
+    // closed without rendering at all, once the event that asked is over, by
+    // which time React has rendered any answer the caller set.
+    const ask = useCallback((next) => {
+        const s = stateRef.current;
+        s.asked = next;
+        latestRef.current.onOpenChange(next);
+        listenForEscape();
+        if (!next)
+            return;
+        clearTimeout(s.askTimer);
+        s.askTimer = setTimeout(() => {
+            // Still closed: the caller turned it down.
+            if (latestRef.current.open)
+                return;
+            s.asked = false;
+            s.tappedIn = undefined;
+            listenForEscape();
+        });
+    }, [listenForEscape]);
+    // Asks for what the pointer and focus call for, after its delay, when that
+    // changed since the last time and isn't the state already.
+    const settle = useCallback(() => {
+        const s = stateRef.current;
+        const held = s.pointerIn || s.focusIn;
+        if (held !== s.held) {
+            s.held = held;
+            clearTimeout(s.timer);
+            const { open, openDelay, closeDelay } = latestRef.current;
+            s.opening = held && !open;
+            if (held !== open) {
+                s.timer = setTimeout(() => {
+                    s.opening = false;
+                    if (latestRef.current.open !== held)
+                        ask(held);
+                    else
+                        listenForEscape();
+                }, held ? openDelay : closeDelay);
+            }
+        }
+        listenForEscape();
+    }, [listenForEscape, ask]);
+    // While a tap holds the floating element open, a press outside the trigger
+    // and the floating element closes it. Set up again each time it opens or
+    // closes.
+    const listenForPress = useCallback(() => {
+        const s = stateRef.current;
+        s.stopPress?.();
+        s.stopPress = undefined;
+        const doc = latestRef.current.open ? s.tappedIn : undefined;
+        if (!doc)
+            return;
+        const handlePointerDown = (event) => {
+            // Inside is a press React brought to the holder, which covers content
+            // the floating element portals elsewhere, or one whose path runs
+            // through the trigger or the floating element, which covers a press
+            // that something inside stopped before React got it to the holder.
+            const { triggerRef, floatingRef } = latestRef.current;
+            if (event === s.pressedInside ||
+                isEventInside(event, triggerRef.current) ||
+                isEventInside(event, floatingRef.current)) {
+                return;
+            }
+            latestRef.current.onOpenChange(false);
+        };
+        doc.addEventListener('pointerdown', handlePointerDown);
+        s.stopPress = () => doc.removeEventListener('pointerdown', handlePointerDown);
+    }, []);
+    useClientLayoutEffect(() => {
+        latestRef.current = options;
+        // The commit after an ask to open answers it, open or still closed. A
+        // tap that asked and still finds it closed was turned down.
+        const s = stateRef.current;
+        if (s.asked) {
+            s.asked = false;
+            if (!options.open)
+                s.tappedIn = undefined;
+            listenForEscape();
+        }
+    });
+    useClientLayoutEffect(() => {
+        const s = stateRef.current;
+        return () => {
+            clearTimeout(s.timer);
+            clearTimeout(s.askTimer);
+            s.opening = false;
+            s.asked = false;
+            s.releaseEscape?.();
+            s.releaseEscape = undefined;
+            s.stopPress?.();
+            s.stopPress = undefined;
+        };
+    }, []);
+    const { open } = options;
+    // Before paint, so a pointer or a key arriving next finds this settled.
+    useClientLayoutEffect(() => {
+        const s = stateRef.current;
+        if (!open) {
+            // The floating element left from under the pointer, if it was there,
+            // and no leave event says so. Focus resting on the trigger has done
+            // its job too, so neither opens it again until it comes back.
+            s.pointerIn = false;
+            s.focusIn = false;
+            s.tappedIn = undefined;
+            if (s.focusInFloating) {
+                s.focusInFloating = false;
+                const trigger = latestRef.current.triggerRef.current;
+                // Focus that went down with the floating element sits on <body>.
+                // Focus somewhere else was put there by the same update, so it stays.
+                if (trigger &&
+                    trigger.ownerDocument.activeElement === trigger.ownerDocument.body) {
+                    s.restoring = true;
+                    trigger.focus();
+                    s.restoring = false;
+                }
+            }
+        }
+        settle();
+        listenForPress();
+    }, [open, settle, listenForPress]);
+    return useMemo(() => {
+        const inTrigger = (node) => within(latestRef.current.triggerRef.current, node);
+        return {
+            onPointerEnter: event => {
+                if (event.pointerType === 'touch')
+                    return;
+                stateRef.current.pointerIn = true;
+                settle();
+            },
+            onPointerLeave: event => {
+                // A touch pointer never set pointerIn, so its leave has nothing to
+                // clear, and on a device with a mouse too it would close a card the
+                // mouse is still holding open.
+                if (event.pointerType === 'touch')
+                    return;
+                stateRef.current.pointerIn = false;
+                settle();
+            },
+            onFocus: event => {
+                const s = stateRef.current;
+                // React brings focus here from the trigger and from the floating
+                // element's whole tree, portals included, so focus not in the
+                // trigger is in the floating element, wherever its DOM is.
+                s.focusInFloating = !inTrigger(event.target);
+                if (s.restoring)
+                    return;
+                // Any focus in the floating element holds it. On the trigger, only
+                // keyboard focus does, so a click there opens nothing.
+                s.focusIn = s.focusInFloating || isKeyboardFocus(event.target);
+                settle();
+            },
+            onBlur: event => {
+                const s = stateRef.current;
+                const next = event.relatedTarget;
+                // Where focus goes next, as far as the DOM can say. Focus going into
+                // content the floating element portals elsewhere reads as leaving,
+                // and the focus event that follows straight after brings it back.
+                s.focusInFloating = within(latestRef.current.floatingRef.current, next);
+                // Moving between the trigger and the floating element isn't leaving.
+                if (s.focusInFloating || within(event.currentTarget, next))
+                    return;
+                s.focusIn = false;
+                settle();
+            },
+            onPointerDown: event => {
+                stateRef.current.pressedInside = event.nativeEvent;
+            },
+            onPointerUp: event => {
+                const now = latestRef.current;
+                // With openOnTap, a tap on the trigger opens it at once, and the
+                // next one closes it. A tap anywhere else does nothing here.
+                if (!now.openOnTap ||
+                    event.pointerType !== 'touch' ||
+                    !inTrigger(event.target)) {
+                    return;
+                }
+                stateRef.current.tappedIn = now.open
+                    ? undefined
+                    : event.target.ownerDocument;
+                ask(!now.open);
+            },
+        };
+    }, [settle, ask]);
+}
+
+export { useHoverOpen };
+//# sourceMappingURL=useHoverOpen.js.map

package/dist/esm/helpers/useHoverOpen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHoverOpen.js","sources":["../../../src/helpers/useHoverOpen.ts"],"sourcesContent":["// INTERNAL: deliberately not exported from src/index.ts.\nimport { useCallback, useMemo, useRef } from 'react';\nimport type { FocusEvent, PointerEvent, RefObject } from 'react';\nimport { useClientLayoutEffect } from './useClientLayoutEffect';\nimport { getDeepestActiveElement, isEventInside } from './shadowDom';\n\n/**\n * Options for `useHoverOpen`.\n */\nexport interface UseHoverOpenOptions {\n  /** Whether the floating element is open now, controlled or not. */\n  open: boolean;\n  /**\n   * Asks for the floating element to open or close: when a delay runs out,\n   * and at once on Escape. It isn't asked for the state it is already in,\n   * except that an Escape between asking to open and the open showing takes\n   * the ask back by asking to close.\n   */\n  onOpenChange: (open: boolean) => void;\n  /** How long hover or keyboard focus waits before asking to open, in milliseconds. */\n  openDelay: number;\n  /**\n   * How long it waits once the pointer and focus have both left before\n   * asking to close, in milliseconds. Coming back in that time keeps it open,\n   * which is how the pointer crosses a gap to the floating element.\n   */\n  closeDelay: number;\n  /**\n   * The element that opens it, which has to take focus itself. The Escape\n   * listener goes on its document, an iframe's when it renders into one, and\n   * focus left in the floating element comes back here when the floating\n   * element closes.\n   */\n  triggerRef: RefObject<HTMLElement | null>;\n  /** The floating element, while it is open. */\n  floatingRef: RefObject<HTMLElement | null>;\n  /**\n   * Whether a tap on the trigger opens it at once, with the next tap closing\n   * it. Without it, a touch pointer never opens it. While a tap holds it\n   * open, no hover timer closes it, and a press outside the trigger and the\n   * floating element does, as Escape does. The trigger's own tap action\n   * still runs.\n   * @defaultValue false\n   */\n  openOnTap?: boolean;\n}\n\n/**\n * Pointer and focus handlers for the element that holds the trigger. The\n * floating element has to be inside it in React's tree, in place or through\n * a portal, since React's events reach it from there either way, and it\n * should hold nothing else: focus inside it that isn't on the trigger counts\n * as focus in the floating element.\n */\nexport interface HoverOpenHandlers {\n  onPointerEnter: (event: PointerEvent<HTMLElement>) => void;\n  onPointerLeave: (event: PointerEvent<HTMLElement>) => void;\n  onFocus: (event: FocusEvent<HTMLElement>) => void;\n  onBlur: (event: FocusEvent<HTMLElement>) => void;\n  onPointerDown: (event: PointerEvent<HTMLElement>) => void;\n  onPointerUp: (event: PointerEvent<HTMLElement>) => void;\n}\n\n/**\n * Whether focus that just arrived on `el` is keyboard focus, as the browser\n * decides it for `:focus-visible`: focus from a key or from the browser's\n * own controls is, focus a press brings isn't, and focus a script moves\n * follows whichever came last. A browser that can't match the selector\n * throws, and then every focus counts, so keyboard users can still open it.\n */\nfunction isKeyboardFocus(el: Element): boolean {\n  try {\n    return el.matches(':focus-visible');\n  } catch {\n    return true;\n  }\n}\n\n/** Whether `node` is `container` or inside it, when there are both. */\nconst within = (container: Node | null, node: Node | null): boolean =>\n  Boolean(container && node && container.contains(node));\n\n/** A hook that wants Escape: its floating element is open, or an open is on its way. */\ninterface EscapeEntry {\n  /** When its floating element opened, counted across the page, or 0 while it is closed. */\n  openedAt: number;\n  trigger: () => HTMLElement | null;\n  floating: () => HTMLElement | null;\n  /** Takes back an open that is on its way: waiting on its delay, or asked for and not showing yet. */\n  cancel: () => void;\n  /** Asks to close. */\n  close: () => void;\n}\n\n/**\n * Per document, the hooks that want Escape and the one listener they share\n * while there are any, so a card inside another card doesn't add a second\n * listener that closes both on one keypress.\n */\nconst escapeListeners = new Map<\n  Document,\n  { entries: Set<EscapeEntry>; stop: () => void }\n>();\n\n/** Counts openings across the page, so the most recent one is known. */\nlet openings = 0;\n\n/**\n * Adds `entry` to the hooks that want Escape on `doc`, starting the shared\n * listener when it is the first.\n *\n * Escape takes back every open that is on its way, so nothing appears right\n * after it, and closes one open floating element, chosen by these rules in\n * turn:\n *\n * 1. One that focus is in, on its trigger or inside it, when there is one.\n * 2. The innermost: one whose floating element holds no other's trigger.\n *    That follows nesting whether either one is portaled, since an inner\n *    trigger sits in the outer floating element either way.\n * 3. The one that opened last.\n *\n * The keypress belongs to whatever has focus. When that is one of the open\n * floating elements or their triggers, or nothing, the listener stops it in\n * the capture phase, before anything around (a Popover, a Modal) sees it.\n * When focus is anywhere else, such as a combobox or a dialog of its own,\n * the floating element still closes, since hover put it there without\n * focus, and the key goes on to that owner.\n *\n * @returns What to call when the hook stops wanting Escape.\n */\nfunction wantEscape(doc: Document, entry: EscapeEntry): () => void {\n  let listener = escapeListeners.get(doc);\n  if (!listener) {\n    const entries = new Set<EscapeEntry>();\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key !== 'Escape') return;\n      const open: EscapeEntry[] = [];\n      // A copy, since taking an open back can take its hook out of the set.\n      for (const each of [...entries]) {\n        if (each.openedAt) open.push(each);\n        else each.cancel();\n      }\n      const focused = getDeepestActiveElement(doc);\n      const holding = open.filter(\n        each =>\n          within(each.trigger(), focused) || within(each.floating(), focused)\n      );\n      const pool = holding.length > 0 ? holding : open;\n      let top: EscapeEntry | undefined;\n      for (const each of pool) {\n        const holdsAnother = pool.some(\n          other => other !== each && within(each.floating(), other.trigger())\n        );\n        if (!holdsAnother && (!top || each.openedAt > top.openedAt)) {\n          top = each;\n        }\n      }\n      if (!top) return;\n      if (holding.length > 0 || !focused || focused === doc.body) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n      top.close();\n    };\n    doc.addEventListener('keydown', handleKeyDown, true);\n    listener = {\n      entries,\n      stop: () => {\n        doc.removeEventListener('keydown', handleKeyDown, true);\n        escapeListeners.delete(doc);\n      },\n    };\n    escapeListeners.set(doc, listener);\n  }\n  const shared = listener;\n  shared.entries.add(entry);\n  return () => {\n    shared.entries.delete(entry);\n    if (shared.entries.size === 0) shared.stop();\n  };\n}\n\ninterface HoverOpenState {\n  /** The pointer, other than a touch, is over the trigger or the floating element. */\n  pointerIn: boolean;\n  /** Focus holds it open: any focus in the floating element, or keyboard focus on the trigger. */\n  focusIn: boolean;\n  /** Focus, however it got there, is in the floating element. */\n  focusInFloating: boolean;\n  /** Whether the pointer or focus was holding it open when last settled. */\n  held: boolean;\n  /** An open is waiting on its delay. */\n  opening: boolean;\n  /**\n   * An open was asked for and isn't showing yet: no commit has answered it,\n   * and the event that asked isn't over.\n   */\n  asked: boolean;\n  /** Focus is on its way back to the trigger, which isn't focus arriving. */\n  restoring: boolean;\n  timer?: ReturnType<typeof setTimeout>;\n  /** Ends an ask to open that no commit answered, once the event that made it is over. */\n  askTimer?: ReturnType<typeof setTimeout>;\n  /** Takes this hook out of the ones that want Escape, while it is in. */\n  releaseEscape?: () => void;\n  /**\n   * The document of the tap that opened it, or asked to: a press outside in\n   * that document closes it while it is open.\n   */\n  tappedIn?: Document;\n  /** The last press React brought to the holder: on the trigger or in the floating element's tree. */\n  pressedInside?: Event;\n  /** Takes the listener for a press outside off its document, while it is on. */\n  stopPress?: () => void;\n}\n\n/**\n * Decides when a floating element that opens on hover or keyboard focus asks\n * to open and to close. It renders nothing, and leaves roles, ARIA and\n * placement to the component that calls it.\n *\n * - The pointer entering, or keyboard focus arriving on the trigger, asks to\n *   open after `openDelay`. A touch pointer doesn't count. Neither does focus\n *   that a press brings to the trigger: it counts when the browser shows it\n *   as `:focus-visible`.\n * - Focus in the floating element holds it open however it got there,\n *   including focus in content it portals elsewhere, such as a nested card.\n *   Whether a click focuses what it lands on is up to the browser: Safari\n *   and Firefox on macOS don't focus a button on click, so there a clicked\n *   button doesn't hold it once the pointer leaves.\n * - Once the pointer and focus have both left, it asks to close after\n *   `closeDelay`, and either coming back before then keeps it open. Nothing\n *   else closes it on a timer.\n * - Escape closes it at once, wherever focus is, and stops there when focus\n *   is in it, on its trigger or nowhere, so a `Popover` or `Modal` around it\n *   keeps its own. With focus somewhere else, the key goes on after closing\n *   it. Inside another one, the inner one closes first. Escape before it\n *   opens takes the opening back and goes on its way. One key listener per\n *   document serves every hook on it, there only while one of them is open\n *   or on its way to open.\n * - With `openOnTap`, a tap on the trigger opens it at once and the next tap\n *   on the trigger closes it. While a tap holds it open, a press outside the\n *   trigger and the floating element closes it, from a listener on the\n *   document that is there only then. Taps never count as hover, and mouse\n *   and pen work the same with it or without.\n * - Once it closes, for any reason, whatever was holding it open has to\n *   leave and come back to open it again.\n * - When the floating element closes with focus inside it, focus goes back\n *   to the trigger, unless the same update put it somewhere else. Handing it\n *   back doesn't count as focus arriving.\n *\n * Nothing it scheduled runs after the component unmounts.\n *\n * @function useHoverOpen\n * @param options - The open state, how to ask for another, the delays, and the two elements.\n * @returns Handlers for the element that holds the trigger.\n */\nexport function useHoverOpen(options: UseHoverOpenOptions): HoverOpenHandlers {\n  const latestRef = useRef(options);\n  const stateRef = useRef<HoverOpenState>({\n    pointerIn: false,\n    focusIn: false,\n    focusInFloating: false,\n    held: false,\n    opening: false,\n    asked: false,\n    restoring: false,\n  });\n\n  // In the hooks that want Escape from the moment an open is on its way until\n  // the floating element closes, and out otherwise. Stamped with the order it\n  // opened in.\n  const listenForEscape = useCallback(function listen() {\n    const s = stateRef.current;\n    const entry = entryRef.current;\n    const { open, triggerRef } = latestRef.current;\n    if (!open) entry.openedAt = 0;\n    else if (!entry.openedAt) {\n      openings += 1;\n      entry.openedAt = openings;\n    }\n    const wanted = open || s.opening || s.asked;\n    if (wanted === Boolean(s.releaseEscape)) return;\n    if (s.releaseEscape) {\n      s.releaseEscape();\n      s.releaseEscape = undefined;\n      return;\n    }\n    const doc = triggerRef.current?.ownerDocument ?? document;\n    s.releaseEscape = wantEscape(doc, entry);\n  }, []);\n\n  const entryRef = useRef<EscapeEntry>({\n    openedAt: 0,\n    trigger: () => latestRef.current.triggerRef.current,\n    floating: () => latestRef.current.floatingRef.current,\n    // Only ever called while an open is on its way, so it is one or the\n    // other: still waiting on its delay, or asked for already.\n    cancel: () => {\n      const s = stateRef.current;\n      clearTimeout(s.timer);\n      // An ask already made is taken back by asking the other way.\n      if (s.asked) latestRef.current.onOpenChange(false);\n      s.opening = false;\n      s.asked = false;\n      listenForEscape();\n    },\n    close: () => {\n      clearTimeout(stateRef.current.timer);\n      latestRef.current.onOpenChange(false);\n    },\n  });\n\n  // Asks to open or to close. Escape can take an ask to open back until it is\n  // answered: by the commit that follows it, or, when the caller keeps it\n  // closed without rendering at all, once the event that asked is over, by\n  // which time React has rendered any answer the caller set.\n  const ask = useCallback(\n    (next: boolean) => {\n      const s = stateRef.current;\n      s.asked = next;\n      latestRef.current.onOpenChange(next);\n      listenForEscape();\n      if (!next) return;\n      clearTimeout(s.askTimer);\n      s.askTimer = setTimeout(() => {\n        // Still closed: the caller turned it down.\n        if (latestRef.current.open) return;\n        s.asked = false;\n        s.tappedIn = undefined;\n        listenForEscape();\n      });\n    },\n    [listenForEscape]\n  );\n\n  // Asks for what the pointer and focus call for, after its delay, when that\n  // changed since the last time and isn't the state already.\n  const settle = useCallback(() => {\n    const s = stateRef.current;\n    const held = s.pointerIn || s.focusIn;\n    if (held !== s.held) {\n      s.held = held;\n      clearTimeout(s.timer);\n      const { open, openDelay, closeDelay } = latestRef.current;\n      s.opening = held && !open;\n      if (held !== open) {\n        s.timer = setTimeout(\n          () => {\n            s.opening = false;\n            if (latestRef.current.open !== held) ask(held);\n            else listenForEscape();\n          },\n          held ? openDelay : closeDelay\n        );\n      }\n    }\n    listenForEscape();\n  }, [listenForEscape, ask]);\n\n  // While a tap holds the floating element open, a press outside the trigger\n  // and the floating element closes it. Set up again each time it opens or\n  // closes.\n  const listenForPress = useCallback(() => {\n    const s = stateRef.current;\n    s.stopPress?.();\n    s.stopPress = undefined;\n    const doc = latestRef.current.open ? s.tappedIn : undefined;\n    if (!doc) return;\n    const handlePointerDown = (event: Event) => {\n      // Inside is a press React brought to the holder, which covers content\n      // the floating element portals elsewhere, or one whose path runs\n      // through the trigger or the floating element, which covers a press\n      // that something inside stopped before React got it to the holder.\n      const { triggerRef, floatingRef } = latestRef.current;\n      if (\n        event === s.pressedInside ||\n        isEventInside(event, triggerRef.current) ||\n        isEventInside(event, floatingRef.current)\n      ) {\n        return;\n      }\n      latestRef.current.onOpenChange(false);\n    };\n    doc.addEventListener('pointerdown', handlePointerDown);\n    s.stopPress = () =>\n      doc.removeEventListener('pointerdown', handlePointerDown);\n  }, []);\n\n  useClientLayoutEffect(() => {\n    latestRef.current = options;\n    // The commit after an ask to open answers it, open or still closed. A\n    // tap that asked and still finds it closed was turned down.\n    const s = stateRef.current;\n    if (s.asked) {\n      s.asked = false;\n      if (!options.open) s.tappedIn = undefined;\n      listenForEscape();\n    }\n  });\n\n  useClientLayoutEffect(() => {\n    const s = stateRef.current;\n    return () => {\n      clearTimeout(s.timer);\n      clearTimeout(s.askTimer);\n      s.opening = false;\n      s.asked = false;\n      s.releaseEscape?.();\n      s.releaseEscape = undefined;\n      s.stopPress?.();\n      s.stopPress = undefined;\n    };\n  }, []);\n\n  const { open } = options;\n  // Before paint, so a pointer or a key arriving next finds this settled.\n  useClientLayoutEffect(() => {\n    const s = stateRef.current;\n    if (!open) {\n      // The floating element left from under the pointer, if it was there,\n      // and no leave event says so. Focus resting on the trigger has done\n      // its job too, so neither opens it again until it comes back.\n      s.pointerIn = false;\n      s.focusIn = false;\n      s.tappedIn = undefined;\n      if (s.focusInFloating) {\n        s.focusInFloating = false;\n        const trigger = latestRef.current.triggerRef.current;\n        // Focus that went down with the floating element sits on <body>.\n        // Focus somewhere else was put there by the same update, so it stays.\n        if (\n          trigger &&\n          trigger.ownerDocument.activeElement === trigger.ownerDocument.body\n        ) {\n          s.restoring = true;\n          trigger.focus();\n          s.restoring = false;\n        }\n      }\n    }\n    settle();\n    listenForPress();\n  }, [open, settle, listenForPress]);\n\n  return useMemo<HoverOpenHandlers>(() => {\n    const inTrigger = (node: EventTarget | null) =>\n      within(latestRef.current.triggerRef.current, node as Node | null);\n    return {\n      onPointerEnter: event => {\n        if (event.pointerType === 'touch') return;\n        stateRef.current.pointerIn = true;\n        settle();\n      },\n      onPointerLeave: event => {\n        // A touch pointer never set pointerIn, so its leave has nothing to\n        // clear, and on a device with a mouse too it would close a card the\n        // mouse is still holding open.\n        if (event.pointerType === 'touch') return;\n        stateRef.current.pointerIn = false;\n        settle();\n      },\n      onFocus: event => {\n        const s = stateRef.current;\n        // React brings focus here from the trigger and from the floating\n        // element's whole tree, portals included, so focus not in the\n        // trigger is in the floating element, wherever its DOM is.\n        s.focusInFloating = !inTrigger(event.target);\n        if (s.restoring) return;\n        // Any focus in the floating element holds it. On the trigger, only\n        // keyboard focus does, so a click there opens nothing.\n        s.focusIn = s.focusInFloating || isKeyboardFocus(event.target);\n        settle();\n      },\n      onBlur: event => {\n        const s = stateRef.current;\n        const next = event.relatedTarget as Node | null;\n        // Where focus goes next, as far as the DOM can say. Focus going into\n        // content the floating element portals elsewhere reads as leaving,\n        // and the focus event that follows straight after brings it back.\n        s.focusInFloating = within(latestRef.current.floatingRef.current, next);\n        // Moving between the trigger and the floating element isn't leaving.\n        if (s.focusInFloating || within(event.currentTarget, next)) return;\n        s.focusIn = false;\n        settle();\n      },\n      onPointerDown: event => {\n        stateRef.current.pressedInside = event.nativeEvent;\n      },\n      onPointerUp: event => {\n        const now = latestRef.current;\n        // With openOnTap, a tap on the trigger opens it at once, and the\n        // next one closes it. A tap anywhere else does nothing here.\n        if (\n          !now.openOnTap ||\n          event.pointerType !== 'touch' ||\n          !inTrigger(event.target)\n        ) {\n          return;\n        }\n        stateRef.current.tappedIn = now.open\n          ? undefined\n          : (event.target as Element).ownerDocument;\n        ask(!now.open);\n      },\n    };\n  }, [settle, ask]);\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/helpers/useOtherClasses.js

@@ -2,7 +2,7 @@
 import { useMemo } from 'react';
 import { classNames } from './classNames.js';
 import { useConfig } from './Config.js';
-import { validFloats, validAxisOverflows, validInteractions, validCursors, cursorClasses, validRadii, validShadows, validResponsives, validPositions, validAspectRatios, createBulmaClassHelpers } from './bulmaClassHelpers.js';
+import { validCursors, validPositions, createBulmaClassHelpers, validAxisOverflows, validFloats, validInteractions, cursorClasses, validRadii, validShadows, validResponsives, validAspectRatios } from './bulmaClassHelpers.js';
 
 /**
  * A hook that generates miscellaneous Bulma helper classes (float, overflow,

package/dist/esm/helpers/useSpacingClasses.js

@@ -2,7 +2,7 @@
 import { useMemo } from 'react';
 import { classNames } from './classNames.js';
 import { useConfig } from './Config.js';
-import { validSizes, validGaps, createBulmaClassHelpers } from './bulmaClassHelpers.js';
+import { createBulmaClassHelpers, validGaps, validSizes } from './bulmaClassHelpers.js';
 
 /**
  * A gap step as the class reads it. Numbers are accepted for the steps, so

package/dist/esm/helpers/useTypographyClasses.js

@@ -2,7 +2,7 @@
 import { useMemo } from 'react';
 import { classNames } from './classNames.js';
 import { useConfig } from './Config.js';
-import { validTextSizes, validAlignments, validTextTransforms, validTextWeights, validFontFamilies, createBulmaClassHelpers } from './bulmaClassHelpers.js';
+import { createBulmaClassHelpers, validTextSizes, validAlignments, validTextTransforms, validTextWeights, validFontFamilies } from './bulmaClassHelpers.js';
 
 /**
  * Viewports Bulma generates `is-size-*` classes for. Unlike text alignment,

package/dist/esm/helpers/useVisibilityClasses.js

@@ -2,7 +2,7 @@
 import { useMemo } from 'react';
 import { classNames } from './classNames.js';
 import { useConfig } from './Config.js';
-import { validViewports, validDisplays, validVisibilities, createBulmaClassHelpers } from './bulmaClassHelpers.js';
+import { validViewports, validVisibilities, validDisplays, createBulmaClassHelpers } from './bulmaClassHelpers.js';
 
 /**
  * A hook that generates Bulma visibility and display helper classes. This hook