@allxsmith/bestax-bulma 5.27.7 → 5.28.0

package/dist/types-cjs/helpers/useFocusTrap.d.ts

@@ -1,4 +1,13 @@
 import type { RefObject } from 'react';
+/**
+ * Whether the browser puts `el` in the tab order, before anything that hides
+ * or disables it. The `tabIndex` property can't answer this on its own: it
+ * can read `-1` for an editable region or an `<embed>` that Tab still visits,
+ * and `0` for a `<video>` without controls that it doesn't. So a valid
+ * `tabindex` attribute decides, and otherwise the element's kind does.
+ * Internal like `firstTabStop`: `src/index.ts` names what it takes from here.
+ */
+export declare function isTabbableKind(el: Element): boolean;
 /**
  * The first tab stop inside `container`, found the way the trap finds it, or
  * `null` when there is none. For a component that moves focus into a panel

package/dist/types-cjs/helpers/useHoverOpen.d.ts

@@ -0,0 +1,98 @@
+import type { FocusEvent, PointerEvent, RefObject } from 'react';
+/**
+ * Options for `useHoverOpen`.
+ */
+export interface UseHoverOpenOptions {
+    /** Whether the floating element is open now, controlled or not. */
+    open: boolean;
+    /**
+     * Asks for the floating element to open or close: when a delay runs out,
+     * and at once on Escape. It isn't asked for the state it is already in,
+     * except that an Escape between asking to open and the open showing takes
+     * the ask back by asking to close.
+     */
+    onOpenChange: (open: boolean) => void;
+    /** How long hover or keyboard focus waits before asking to open, in milliseconds. */
+    openDelay: number;
+    /**
+     * How long it waits once the pointer and focus have both left before
+     * asking to close, in milliseconds. Coming back in that time keeps it open,
+     * which is how the pointer crosses a gap to the floating element.
+     */
+    closeDelay: number;
+    /**
+     * The element that opens it, which has to take focus itself. The Escape
+     * listener goes on its document, an iframe's when it renders into one, and
+     * focus left in the floating element comes back here when the floating
+     * element closes.
+     */
+    triggerRef: RefObject<HTMLElement | null>;
+    /** The floating element, while it is open. */
+    floatingRef: RefObject<HTMLElement | null>;
+    /**
+     * Whether a tap on the trigger opens it at once, with the next tap closing
+     * it. Without it, a touch pointer never opens it. While a tap holds it
+     * open, no hover timer closes it, and a press outside the trigger and the
+     * floating element does, as Escape does. The trigger's own tap action
+     * still runs.
+     * @defaultValue false
+     */
+    openOnTap?: boolean;
+}
+/**
+ * Pointer and focus handlers for the element that holds the trigger. The
+ * floating element has to be inside it in React's tree, in place or through
+ * a portal, since React's events reach it from there either way, and it
+ * should hold nothing else: focus inside it that isn't on the trigger counts
+ * as focus in the floating element.
+ */
+export interface HoverOpenHandlers {
+    onPointerEnter: (event: PointerEvent<HTMLElement>) => void;
+    onPointerLeave: (event: PointerEvent<HTMLElement>) => void;
+    onFocus: (event: FocusEvent<HTMLElement>) => void;
+    onBlur: (event: FocusEvent<HTMLElement>) => void;
+    onPointerDown: (event: PointerEvent<HTMLElement>) => void;
+    onPointerUp: (event: PointerEvent<HTMLElement>) => void;
+}
+/**
+ * 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.
+ */
+export declare function useHoverOpen(options: UseHoverOpenOptions): HoverOpenHandlers;

package/dist/types-cjs/index.d.ts

@@ -18,6 +18,7 @@ export * from './components/Collapse.js';
 export * from './components/Collapses.js';
 export * from './components/Tooltip.js';
 export * from './components/Popover.js';
+export * from './components/HoverCard.js';
 export * from './components/Steps.js';
 export * from './components/Sidebar.js';
 export * from './components/Toast.js';