@allxsmith/bestax-bulma 5.27.0 → 5.27.2

package/dist/esm/helpers/useFocusTrap.js

@@ -0,0 +1,470 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { useRef, useState, useEffect } from 'react';
+import { useIsHydrated } from './useIsHydrated.js';
+import { getDeepestActiveElement } from './shadowDom.js';
+
+/**
+ * Whether `el` is editable while its parent is not, which makes it an editing
+ * host: the one tab stop an editable region gets. `contenteditable="false"`
+ * turns editing off, and a missing or unknown value inherits the parent's.
+ */
+function isEditingHost(el) {
+    const editable = (node) => {
+        const value = node.getAttribute('contenteditable')?.toLowerCase();
+        if (value === undefined)
+            return null;
+        if (value === '' || value === 'true' || value === 'plaintext-only') {
+            return true;
+        }
+        return value === 'false' ? false : null;
+    };
+    if (editable(el) !== true)
+        return false;
+    for (let node = el.parentElement; node; node = node.parentElement) {
+        const state = editable(node);
+        if (state !== null)
+            return !state;
+    }
+    return true;
+}
+/** Whether `el` is the summary of its `<details>`: the first one, not a stray. */
+const isDetailsSummary = (el) => el.parentElement?.localName === 'details' &&
+    Array.from(el.parentElement.children).find(child => child.localName === 'summary') === el;
+/**
+ * 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.
+ */
+function isTabbableKind(el) {
+    const tabindex = el.getAttribute('tabindex');
+    if (tabindex !== null && /^\s*[+-]?\d/.test(tabindex)) {
+        return el.tabIndex >= 0;
+    }
+    switch (el.localName) {
+        case 'a':
+        case 'area':
+            return el.hasAttribute('href');
+        case 'input':
+            return el.type !== 'hidden';
+        case 'button':
+        case 'select':
+        case 'textarea':
+        case 'iframe':
+        case 'embed':
+        case 'object':
+            return true;
+        case 'audio':
+        case 'video':
+            return el.hasAttribute('controls');
+        case 'summary':
+            return isDetailsSummary(el);
+        default:
+            return isEditingHost(el);
+    }
+}
+/**
+ * The node's parent in the flattened tree, the one the browser renders and
+ * tabs through: the slot it is assigned to, else its parent, else the host of
+ * the shadow root it tops, and nothing above the document. A closed shadow
+ * root hides its slots (`assignedSlot` reads `null` under one), so a child of
+ * its host goes straight to the host, whether a slot takes it or not.
+ */
+const flatParent = (node) => node.assignedSlot ??
+    node.parentElement ??
+    node.parentNode?.host ??
+    null;
+/**
+ * The element's children in the flattened tree, in the order they render: a
+ * host's shadow root content, a slot's assigned elements (or its fallback
+ * content when nothing is assigned), anything else's own children. A host
+ * whose shadow root is closed has no root to read, so its own children stand
+ * in, including any that no slot takes and that aren't rendered.
+ */
+function flatChildren(el) {
+    if (el.shadowRoot)
+        return Array.from(el.shadowRoot.children);
+    if (el.localName === 'slot') {
+        const assigned = el.assignedNodes();
+        if (assigned.length > 0) {
+            return assigned.filter((node) => node.nodeType === Node.ELEMENT_NODE);
+        }
+    }
+    return Array.from(el.children);
+}
+const isShown = (el) => !el.hasAttribute('inert') && getComputedStyle(el).display !== 'none';
+const isVisible = (el) => {
+    const { visibility } = getComputedStyle(el);
+    return visibility !== 'hidden' && visibility !== 'collapse';
+};
+/**
+ * Whether nothing from `el` up to `top` hides it: `inert`, `display: none`
+ * (not inherited, so each element is checked) or a closed `<details>` it
+ * isn't the summary of. `top` itself isn't checked, and `null` walks to the
+ * top of the page.
+ */
+function isShownUpTo(el, top) {
+    let below = null;
+    for (let node = el; node && node !== top; node = flatParent(node)) {
+        if (!isShown(node))
+            return false;
+        if (below &&
+            node.localName === 'details' &&
+            !node.hasAttribute('open') &&
+            !isDetailsSummary(below)) {
+            return false;
+        }
+        below = node;
+    }
+    return true;
+}
+/**
+ * The images that use the image map `area` belongs to. An image names its
+ * map with `usemap="#…"`, matching the map's `name` or `id`.
+ */
+function imagesUsingMapOf(area) {
+    const map = area.closest('map');
+    if (!map)
+        return [];
+    const names = [map.getAttribute('name'), map.id].filter(name => name);
+    return Array.from(area.getRootNode().querySelectorAll('img[usemap]')).filter(img => {
+        const ref = img.getAttribute('usemap');
+        return ref.startsWith('#') && names.includes(ref.slice(1));
+    });
+}
+/**
+ * Whether an image map area is shown. An area has no box of its own: the
+ * HTML rendering rules give it `display: none`, though a browser may not
+ * report that. So it counts where an image using its map is shown, as long
+ * as nothing makes it inert.
+ */
+function isAreaShown(area, container) {
+    for (let node = area; node && node !== container; node = flatParent(node)) {
+        if (node.hasAttribute('inert'))
+            return false;
+    }
+    return imagesUsingMapOf(area).some(img => isShownUpTo(img, null) && isVisible(img));
+}
+/**
+ * Whether Tab can land on `el`, one of the kinds it visits. A disabled control
+ * (including one inside a disabled `<fieldset>`), an inert subtree and
+ * anything not rendered are skipped. `visibility` is inherited, so the
+ * element's own computed value covers its ancestors.
+ */
+function isRenderedAndEnabled(el, container) {
+    if (el.matches(':disabled'))
+        return false;
+    if (el.localName === 'area')
+        return isAreaShown(el, container);
+    return isShownUpTo(el, container) && isVisible(el);
+}
+/** A radio button with a name, which shares one tab stop with its group. */
+const isGroupedRadio = (el) => el.localName === 'input' &&
+    el.type === 'radio' &&
+    el.name !== '';
+/** Whether two radio buttons are in one group: same name, form owner and tree. */
+const sameGroup = (a, b) => isGroupedRadio(b) &&
+    b.name === a.name &&
+    b.form === a.form &&
+    b.getRootNode() === a.getRootNode();
+/**
+ * The checked button of `radio`'s group. The group isn't bounded by the trap,
+ * so this looks through the radio's whole tree.
+ */
+const checkedInGroup = (radio) => Array.from(radio.getRootNode().querySelectorAll('input:checked')).find(el => sameGroup(radio, el));
+/** The flattened-tree ancestors of `node` below the container, outermost first, then `node`. */
+function flatChain(node, container) {
+    const chain = [];
+    for (let n = node; n && n !== container; n = flatParent(n)) {
+        chain.unshift(n);
+    }
+    return chain;
+}
+/**
+ * Whether `node` is inside the container in the flattened tree: in it, in a
+ * shadow root it holds, or slotted into it. A child of a closed-root host
+ * counts as inside wherever the host is, as its slot can't be seen.
+ */
+function inside(container, node) {
+    for (let n = node; n; n = flatParent(n)) {
+        if (n === container)
+            return true;
+    }
+    return false;
+}
+/**
+ * `true` when Tab reaches `b` after `a`, which is their order in the
+ * flattened tree: a shadow host comes before its shadow root's content, and
+ * slotted content comes where its slot is. A closed root's slots can't be
+ * seen, so its host's children keep their place in the light DOM. Two
+ * flattened-tree siblings are always in one DOM tree, so their document
+ * position decides between them.
+ */
+function follows(container, a, b) {
+    const chainA = flatChain(a, container);
+    const chainB = flatChain(b, container);
+    for (let i = 0; i < Math.max(chainA.length, chainB.length); i++) {
+        const [x, y] = [chainA[i], chainB[i]];
+        if (x === y)
+            continue;
+        if (!x)
+            return true;
+        if (!y)
+            return false;
+        return Boolean(x.compareDocumentPosition(y) & Node.DOCUMENT_POSITION_FOLLOWING);
+    }
+    return false;
+}
+/**
+ * Every element of a tabbable kind under `el` in the flattened tree, depth
+ * first, which is the order Tab visits them. Under a host whose shadow root
+ * is closed, that takes in the host's own children instead, rendered or not.
+ */
+function collectCandidates(el, out = []) {
+    for (const child of flatChildren(el)) {
+        if (isTabbableKind(child))
+            out.push(child);
+        collectCandidates(child, out);
+    }
+    return out;
+}
+/**
+ * The first and last tab stops inside `container`, or `null` when there are
+ * none. Only the ends matter for wrapping, so the style checks run from each
+ * end until they find a stop rather than over every candidate.
+ *
+ * A radio group is one stop, the way the browser treats it: its checked
+ * button, or its first when none is checked. Counting every button would make
+ * the group's last one an end, and Tab from the checked one would leave. The
+ * group goes by name, form owner and tree, not by the trap, so a checked
+ * button outside the container that Tab can land on leaves the group no stop
+ * inside. One that Tab can't land on leaves the group as if none were checked.
+ */
+function findTabStops(container) {
+    const candidates = collectCandidates(container);
+    const checked = new Map();
+    const usable = (el) => {
+        let ok = checked.get(el);
+        if (ok === undefined) {
+            ok = isRenderedAndEnabled(el, container);
+            checked.set(el, ok);
+        }
+        return ok;
+    };
+    // Resolved once per group, filed under each of its buttons, since finding
+    // the checked one scans the radio's whole tree.
+    const groupStops = new Map();
+    const groupStop = (radio) => {
+        if (groupStops.has(radio))
+            return groupStops.get(radio);
+        const group = candidates.filter(el => sameGroup(radio, el));
+        const on = checkedInGroup(radio);
+        const stop = on && isTabbableKind(on) && usable(on)
+            ? group.find(el => el === on)
+            : group.find(usable);
+        for (const el of [radio, ...group])
+            groupStops.set(el, stop);
+        return stop;
+    };
+    const isStop = (el) => usable(el) && (!isGroupedRadio(el) || groupStop(el) === el);
+    const first = candidates.find(isStop);
+    if (!first)
+        return null;
+    let last = first;
+    for (let i = candidates.length - 1; candidates[i] !== first; i--) {
+        if (isStop(candidates[i])) {
+            last = candidates[i];
+            break;
+        }
+    }
+    return {
+        first,
+        last,
+        stopFor: node => (isGroupedRadio(node) && groupStop(node)) || node,
+    };
+}
+/**
+ * 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
+ * without trapping it there. `src/index.ts` names its exports from this
+ * module, so this one stays internal.
+ */
+function firstTabStop(container) {
+    return findTabStops(container)?.first ?? null;
+}
+/**
+ * The element that has focus in the container's own document (an iframe's,
+ * when it renders into one), inside open shadow roots too. Focus inside a
+ * closed one reads as its host, which the comparisons above place like any
+ * other element. Browsers fall back to <body> when nothing has
+ * focus. jsdom, where consumers run their tests, reports nothing once focus
+ * was inside a shadow root that was removed, so this falls back for it.
+ */
+const focusedElement = (doc) => getDeepestActiveElement(doc) ?? doc.body;
+/**
+ * Keeps keyboard focus inside a container while it is active: focus moves in
+ * when the trap turns on, Tab and Shift+Tab wrap between the first and last
+ * tab stops, and focus goes back where it came from when the trap turns off.
+ *
+ * Tab stops are what the browser's Tab visits, in document order: links,
+ * form controls, frames, media with controls, a `<details>` summary, editable
+ * regions, anything with `tabIndex={0}`, and the content of open shadow
+ * roots. Hidden, disabled, inert and `tabIndex={-1}` elements are skipped,
+ * and a radio group counts once. Give the container `tabIndex={-1}` so it can
+ * hold focus itself when nothing inside can. The trap listens on the
+ * container, so a trap nested inside another handles Tab first and the outer
+ * one stands aside.
+ *
+ * The trap is about Tab. If a Tab it let through still takes focus out (a
+ * browser can leave out a stop the page has, such as links when its settings
+ * say to), it sends focus back to the other end. A pointer or a script moving
+ * focus out is left alone, because pulling focus back from a click is modal
+ * behaviour, and a modal also has to block the page behind it, which `Modal`
+ * does. Content the container renders through a portal lives elsewhere in
+ * the DOM, so it is outside the trap: render nested overlays inside the
+ * container, or give them a trap of their own. To trap content a `Portal`
+ * renders, pass a ref to the element inside the `Portal` as `containerRef`.
+ *
+ * The trap looks at `containerRef` again each time the component calling it
+ * renders. A container that mounts after the trap turns on, such as a panel
+ * waiting for a `Portal` target held in state, has it attach once that
+ * component renders with the container in the DOM. When the container leaves
+ * or is replaced, the trap lets go of it as it would turning off, handing
+ * focus back, and attaches to the next one.
+ * A child that mounts the container in a render of its own (from its own
+ * state, or as a `Suspense` boundary resolves) goes unseen until the
+ * component calling the hook renders again. The trap waits for hydration, so
+ * that component renders again when the page hydrates, and portaled content,
+ * which first appears then, is found.
+ *
+ * @function useFocusTrap
+ * @param containerRef - Ref to the element focus stays inside.
+ * @param options - When the trap is on, and where focus starts and ends.
+ *
+ * @example
+ * const panelRef = useRef<HTMLDivElement>(null);
+ * useFocusTrap(panelRef, { active: isOpen });
+ * return isOpen ? (
+ *   <div ref={panelRef} role="dialog" aria-label="Filters" tabIndex={-1}>
+ *     …
+ *   </div>
+ * ) : null;
+ */
+function useFocusTrap(containerRef, options = {}) {
+    const { active = true, initialFocusRef, restoreFocus = true } = options;
+    // Portaled content has no server-rendered counterpart, so a portaled
+    // container only exists from the commit after hydration.
+    const hydrated = useIsHydrated();
+    // The container the trap is attached to, or `null` while it has none.
+    const heldRef = useRef(null);
+    // Bumped to run the trap again when the container in the ref changes.
+    const [refChanges, setRefChanges] = useState(0);
+    useEffect(() => {
+        heldRef.current = null;
+        if (!active || !hydrated)
+            return undefined;
+        const container = containerRef.current;
+        if (!container)
+            return undefined;
+        heldRef.current = container;
+        const doc = container.ownerDocument;
+        const opener = focusedElement(doc);
+        // `initialFocusRef` counts only when focusing it puts focus inside. Focus
+        // put outside would stay out, as Tab there never reaches the container's
+        // listener, and focusing something that can't take focus (a heading
+        // without `tabIndex`, a disabled control) leaves focus where it was.
+        const initial = initialFocusRef?.current;
+        const inTrap = initial && inside(container, initial) ? initial : null;
+        inTrap?.focus();
+        if (!inTrap || !inside(container, focusedElement(doc))) {
+            (findTabStops(container)?.first ?? container).focus();
+        }
+        // Where focus goes if a Tab the trap let the browser handle takes it out,
+        // held until that Tab has finished moving focus.
+        let wrapTo = null;
+        let wrapTimer;
+        const handleKeyDown = (e) => {
+            // A trap nested inside this one has already wrapped focus.
+            if (e.key !== 'Tab' || e.defaultPrevented)
+                return;
+            const stops = findTabStops(container);
+            if (!stops) {
+                e.preventDefault();
+                container.focus();
+                return;
+            }
+            const current = stops.stopFor(focusedElement(doc));
+            // Wrap whenever the browser has no stop left in that direction inside
+            // the container. Comparing positions rather than testing `=== first`
+            // also covers focus resting on the container or on an element outside
+            // the tab order, which the browser would otherwise walk straight out of.
+            if (e.shiftKey
+                ? !follows(container, stops.first, current)
+                : !follows(container, current, stops.last)) {
+                e.preventDefault();
+                (e.shiftKey ? stops.last : stops.first).focus();
+                return;
+            }
+            wrapTo = e.shiftKey ? stops.last : stops.first;
+            clearTimeout(wrapTimer);
+            wrapTimer = setTimeout(() => {
+                wrapTo = null;
+            });
+        };
+        // The browser moves focus as soon as the keydown is over, so focus that
+        // lands outside while `wrapTo` is set got there by that Tab.
+        const handleFocusIn = (e) => {
+            if (!wrapTo || inside(container, e.composedPath()[0]))
+                return;
+            const target = wrapTo;
+            wrapTo = null;
+            target.focus();
+        };
+        container.addEventListener('keydown', handleKeyDown);
+        doc.addEventListener('focusin', handleFocusIn, true);
+        return () => {
+            container.removeEventListener('keydown', handleKeyDown);
+            doc.removeEventListener('focusin', handleFocusIn, true);
+            clearTimeout(wrapTimer);
+            let target = restoreFocus ? opener : null;
+            // `null` is an object too, and a caller without types can pass it.
+            if (restoreFocus && typeof restoreFocus === 'object') {
+                // Read now rather than when the trap turned on: a trigger that
+                // re-mounted in between has a new node.
+                // eslint-disable-next-line react-hooks/exhaustive-deps
+                target = restoreFocus.current;
+            }
+            // Hand focus back only while the trap still holds it: inside the
+            // container, or dropped to <body> because the container left the page.
+            const now = focusedElement(doc);
+            if (target && (now === doc.body || inside(container, now))) {
+                target.focus();
+            }
+        };
+    }, [
+        active,
+        hydrated,
+        containerRef,
+        initialFocusRef,
+        restoreFocus,
+        refChanges,
+    ]);
+    // Nothing says when a ref is set, so after every render, a ref that no
+    // longer matches what the trap holds (a container that mounted, left or was
+    // replaced) runs it again. Effects run in order, so whenever the effect
+    // above ran in this commit, it read the ref just before this does, and a
+    // mismatch means the ref changed in a render it didn't run for. The render
+    // a bump asks for runs it, so the two match and the trap settles. An empty
+    // ref matches a trap holding nothing, so a container that never mounts
+    // costs no render.
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- after every render on purpose
+    useEffect(() => {
+        if (active && hydrated && containerRef.current !== heldRef.current) {
+            setRefChanges(n => n + 1);
+        }
+    });
+}
+
+export { firstTabStop, useFocusTrap };
+//# sourceMappingURL=useFocusTrap.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusTrap.js","sources":["../../../src/helpers/useFocusTrap.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\nimport type { RefObject } from 'react';\nimport { useIsHydrated } from './useIsHydrated';\nimport { getDeepestActiveElement } from './shadowDom';\n\n/**\n * Whether `el` is editable while its parent is not, which makes it an editing\n * host: the one tab stop an editable region gets. `contenteditable=\"false\"`\n * turns editing off, and a missing or unknown value inherits the parent's.\n */\nfunction isEditingHost(el: Element): boolean {\n  const editable = (node: Element): boolean | null => {\n    const value = node.getAttribute('contenteditable')?.toLowerCase();\n    if (value === undefined) return null;\n    if (value === '' || value === 'true' || value === 'plaintext-only') {\n      return true;\n    }\n    return value === 'false' ? false : null;\n  };\n  if (editable(el) !== true) return false;\n  for (let node = el.parentElement; node; node = node.parentElement) {\n    const state = editable(node);\n    if (state !== null) return !state;\n  }\n  return true;\n}\n\n/** Whether `el` is the summary of its `<details>`: the first one, not a stray. */\nconst isDetailsSummary = (el: Element): boolean =>\n  el.parentElement?.localName === 'details' &&\n  Array.from(el.parentElement.children).find(\n    child => child.localName === 'summary'\n  ) === el;\n\n/**\n * Whether the browser puts `el` in the tab order, before anything that hides\n * or disables it. The `tabIndex` property can't answer this on its own: it\n * can read `-1` for an editable region or an `<embed>` that Tab still visits,\n * and `0` for a `<video>` without controls that it doesn't. So a valid\n * `tabindex` attribute decides, and otherwise the element's kind does.\n */\nfunction isTabbableKind(el: Element): boolean {\n  const tabindex = el.getAttribute('tabindex');\n  if (tabindex !== null && /^\\s*[+-]?\\d/.test(tabindex)) {\n    return (el as HTMLElement).tabIndex >= 0;\n  }\n  switch (el.localName) {\n    case 'a':\n    case 'area':\n      return el.hasAttribute('href');\n    case 'input':\n      return (el as HTMLInputElement).type !== 'hidden';\n    case 'button':\n    case 'select':\n    case 'textarea':\n    case 'iframe':\n    case 'embed':\n    case 'object':\n      return true;\n    case 'audio':\n    case 'video':\n      return el.hasAttribute('controls');\n    case 'summary':\n      return isDetailsSummary(el);\n    default:\n      return isEditingHost(el);\n  }\n}\n\n/**\n * The node's parent in the flattened tree, the one the browser renders and\n * tabs through: the slot it is assigned to, else its parent, else the host of\n * the shadow root it tops, and nothing above the document. A closed shadow\n * root hides its slots (`assignedSlot` reads `null` under one), so a child of\n * its host goes straight to the host, whether a slot takes it or not.\n */\nconst flatParent = (node: Node): Node | null =>\n  (node as Element).assignedSlot ??\n  node.parentElement ??\n  (node.parentNode as ShadowRoot | null)?.host ??\n  null;\n\n/**\n * The element's children in the flattened tree, in the order they render: a\n * host's shadow root content, a slot's assigned elements (or its fallback\n * content when nothing is assigned), anything else's own children. A host\n * whose shadow root is closed has no root to read, so its own children stand\n * in, including any that no slot takes and that aren't rendered.\n */\nfunction flatChildren(el: Element): Element[] {\n  if (el.shadowRoot) return Array.from(el.shadowRoot.children);\n  if (el.localName === 'slot') {\n    const assigned = (el as HTMLSlotElement).assignedNodes();\n    if (assigned.length > 0) {\n      return assigned.filter(\n        (node): node is Element => node.nodeType === Node.ELEMENT_NODE\n      );\n    }\n  }\n  return Array.from(el.children);\n}\n\nconst isShown = (el: Element): boolean =>\n  !el.hasAttribute('inert') && getComputedStyle(el).display !== 'none';\n\nconst isVisible = (el: Element): boolean => {\n  const { visibility } = getComputedStyle(el);\n  return visibility !== 'hidden' && visibility !== 'collapse';\n};\n\n/**\n * Whether nothing from `el` up to `top` hides it: `inert`, `display: none`\n * (not inherited, so each element is checked) or a closed `<details>` it\n * isn't the summary of. `top` itself isn't checked, and `null` walks to the\n * top of the page.\n */\nfunction isShownUpTo(el: Element, top: Node | null): boolean {\n  let below: Element | null = null;\n  for (\n    let node: Element | null = el;\n    node && node !== top;\n    node = flatParent(node) as Element | null\n  ) {\n    if (!isShown(node)) return false;\n    if (\n      below &&\n      node.localName === 'details' &&\n      !node.hasAttribute('open') &&\n      !isDetailsSummary(below)\n    ) {\n      return false;\n    }\n    below = node;\n  }\n  return true;\n}\n\n/**\n * The images that use the image map `area` belongs to. An image names its\n * map with `usemap=\"#…\"`, matching the map's `name` or `id`.\n */\nfunction imagesUsingMapOf(area: Element): Element[] {\n  const map = area.closest('map');\n  if (!map) return [];\n  const names = [map.getAttribute('name'), map.id].filter(name => name);\n  return Array.from(\n    (area.getRootNode() as ParentNode).querySelectorAll('img[usemap]')\n  ).filter(img => {\n    const ref = img.getAttribute('usemap') as string;\n    return ref.startsWith('#') && names.includes(ref.slice(1));\n  });\n}\n\n/**\n * Whether an image map area is shown. An area has no box of its own: the\n * HTML rendering rules give it `display: none`, though a browser may not\n * report that. So it counts where an image using its map is shown, as long\n * as nothing makes it inert.\n */\nfunction isAreaShown(area: Element, container: Element): boolean {\n  for (\n    let node: Element | null = area;\n    node && node !== container;\n    node = flatParent(node) as Element | null\n  ) {\n    if (node.hasAttribute('inert')) return false;\n  }\n  return imagesUsingMapOf(area).some(\n    img => isShownUpTo(img, null) && isVisible(img)\n  );\n}\n\n/**\n * Whether Tab can land on `el`, one of the kinds it visits. A disabled control\n * (including one inside a disabled `<fieldset>`), an inert subtree and\n * anything not rendered are skipped. `visibility` is inherited, so the\n * element's own computed value covers its ancestors.\n */\nfunction isRenderedAndEnabled(el: Element, container: Element): boolean {\n  if (el.matches(':disabled')) return false;\n  if (el.localName === 'area') return isAreaShown(el, container);\n  return isShownUpTo(el, container) && isVisible(el);\n}\n\n/** A radio button with a name, which shares one tab stop with its group. */\nconst isGroupedRadio = (el: Element): el is HTMLInputElement =>\n  el.localName === 'input' &&\n  (el as HTMLInputElement).type === 'radio' &&\n  (el as HTMLInputElement).name !== '';\n\n/** Whether two radio buttons are in one group: same name, form owner and tree. */\nconst sameGroup = (a: HTMLInputElement, b: Element): b is HTMLInputElement =>\n  isGroupedRadio(b) &&\n  b.name === a.name &&\n  b.form === a.form &&\n  b.getRootNode() === a.getRootNode();\n\n/**\n * The checked button of `radio`'s group. The group isn't bounded by the trap,\n * so this looks through the radio's whole tree.\n */\nconst checkedInGroup = (radio: HTMLInputElement): Element | undefined =>\n  Array.from(\n    (radio.getRootNode() as ParentNode).querySelectorAll('input:checked')\n  ).find(el => sameGroup(radio, el));\n\n/** The flattened-tree ancestors of `node` below the container, outermost first, then `node`. */\nfunction flatChain(node: Node, container: Node): Node[] {\n  const chain: Node[] = [];\n  for (let n: Node | null = node; n && n !== container; n = flatParent(n)) {\n    chain.unshift(n);\n  }\n  return chain;\n}\n\n/**\n * Whether `node` is inside the container in the flattened tree: in it, in a\n * shadow root it holds, or slotted into it. A child of a closed-root host\n * counts as inside wherever the host is, as its slot can't be seen.\n */\nfunction inside(container: Node, node: Node): boolean {\n  for (let n: Node | null = node; n; n = flatParent(n)) {\n    if (n === container) return true;\n  }\n  return false;\n}\n\n/**\n * `true` when Tab reaches `b` after `a`, which is their order in the\n * flattened tree: a shadow host comes before its shadow root's content, and\n * slotted content comes where its slot is. A closed root's slots can't be\n * seen, so its host's children keep their place in the light DOM. Two\n * flattened-tree siblings are always in one DOM tree, so their document\n * position decides between them.\n */\nfunction follows(container: Element, a: Node, b: Node): boolean {\n  const chainA = flatChain(a, container);\n  const chainB = flatChain(b, container);\n  for (let i = 0; i < Math.max(chainA.length, chainB.length); i++) {\n    const [x, y] = [chainA[i], chainB[i]];\n    if (x === y) continue;\n    if (!x) return true;\n    if (!y) return false;\n    return Boolean(\n      x.compareDocumentPosition(y) & Node.DOCUMENT_POSITION_FOLLOWING\n    );\n  }\n  return false;\n}\n\n/**\n * Every element of a tabbable kind under `el` in the flattened tree, depth\n * first, which is the order Tab visits them. Under a host whose shadow root\n * is closed, that takes in the host's own children instead, rendered or not.\n */\nfunction collectCandidates(\n  el: Element,\n  out: HTMLElement[] = []\n): HTMLElement[] {\n  for (const child of flatChildren(el)) {\n    if (isTabbableKind(child)) out.push(child as HTMLElement);\n    collectCandidates(child, out);\n  }\n  return out;\n}\n\ninterface TabStops {\n  first: HTMLElement;\n  last: HTMLElement;\n  /** The stop that stands for `node`: its group's stop for a radio button. */\n  stopFor(node: Element): Element;\n}\n\n/**\n * The first and last tab stops inside `container`, or `null` when there are\n * none. Only the ends matter for wrapping, so the style checks run from each\n * end until they find a stop rather than over every candidate.\n *\n * A radio group is one stop, the way the browser treats it: its checked\n * button, or its first when none is checked. Counting every button would make\n * the group's last one an end, and Tab from the checked one would leave. The\n * group goes by name, form owner and tree, not by the trap, so a checked\n * button outside the container that Tab can land on leaves the group no stop\n * inside. One that Tab can't land on leaves the group as if none were checked.\n */\nfunction findTabStops(container: HTMLElement): TabStops | null {\n  const candidates = collectCandidates(container);\n  const checked = new Map<Element, boolean>();\n  const usable = (el: Element): boolean => {\n    let ok = checked.get(el);\n    if (ok === undefined) {\n      ok = isRenderedAndEnabled(el, container);\n      checked.set(el, ok);\n    }\n    return ok;\n  };\n  // Resolved once per group, filed under each of its buttons, since finding\n  // the checked one scans the radio's whole tree.\n  const groupStops = new Map<Element, HTMLElement | undefined>();\n  const groupStop = (radio: HTMLInputElement): HTMLElement | undefined => {\n    if (groupStops.has(radio)) return groupStops.get(radio);\n    const group = candidates.filter(el => sameGroup(radio, el));\n    const on = checkedInGroup(radio);\n    const stop =\n      on && isTabbableKind(on) && usable(on)\n        ? group.find(el => el === on)\n        : group.find(usable);\n    for (const el of [radio, ...group]) groupStops.set(el, stop);\n    return stop;\n  };\n  const isStop = (el: HTMLElement): boolean =>\n    usable(el) && (!isGroupedRadio(el) || groupStop(el) === el);\n\n  const first = candidates.find(isStop);\n  if (!first) return null;\n  let last = first;\n  for (let i = candidates.length - 1; candidates[i] !== first; i--) {\n    if (isStop(candidates[i])) {\n      last = candidates[i];\n      break;\n    }\n  }\n  return {\n    first,\n    last,\n    stopFor: node => (isGroupedRadio(node) && groupStop(node)) || node,\n  };\n}\n\n/**\n * The first tab stop inside `container`, found the way the trap finds it, or\n * `null` when there is none. For a component that moves focus into a panel\n * without trapping it there. `src/index.ts` names its exports from this\n * module, so this one stays internal.\n */\nexport function firstTabStop(container: HTMLElement): HTMLElement | null {\n  return findTabStops(container)?.first ?? null;\n}\n\n/**\n * The element that has focus in the container's own document (an iframe's,\n * when it renders into one), inside open shadow roots too. Focus inside a\n * closed one reads as its host, which the comparisons above place like any\n * other element. Browsers fall back to <body> when nothing has\n * focus. jsdom, where consumers run their tests, reports nothing once focus\n * was inside a shadow root that was removed, so this falls back for it.\n */\nconst focusedElement = (doc: Document): Element =>\n  getDeepestActiveElement(doc) ?? doc.body;\n\n/**\n * Options for `useFocusTrap`.\n */\nexport interface UseFocusTrapOptions {\n  /**\n   * Whether the trap is on. Turning it on moves focus into the container;\n   * turning it off (or unmounting) releases Tab and restores focus.\n   * @defaultValue true\n   */\n  active?: boolean;\n  /**\n   * The element inside the container to focus when the trap turns on. It has\n   * to be one that can take focus, so a heading needs `tabIndex={-1}`. When\n   * focusing it doesn't put focus inside the container (the ref is empty, or\n   * its element is outside, disabled, hidden or can't take focus), focus goes\n   * to the first tab stop inside the container, and to the container itself\n   * when there is none.\n   */\n  initialFocusRef?: RefObject<HTMLElement | null>;\n  /**\n   * Where focus goes when the trap turns off. `true` returns it to the element\n   * that had focus when the trap turned on; a ref sends it to that element\n   * instead; `false` leaves it alone. Focus is only moved while the trap still\n   * holds it, so a click that already put focus somewhere else outside the\n   * container keeps it there.\n   *\n   * `true` reads focus after the container's content has mounted, so content\n   * that focuses itself as it mounts (an `autoFocus` input) hides the element\n   * that opened it. And some browsers don't focus a button when it is\n   * clicked. For a panel opened from a button, pass the button's ref.\n   * @defaultValue true\n   */\n  restoreFocus?: boolean | RefObject<HTMLElement | null>;\n}\n\n/**\n * Keeps keyboard focus inside a container while it is active: focus moves in\n * when the trap turns on, Tab and Shift+Tab wrap between the first and last\n * tab stops, and focus goes back where it came from when the trap turns off.\n *\n * Tab stops are what the browser's Tab visits, in document order: links,\n * form controls, frames, media with controls, a `<details>` summary, editable\n * regions, anything with `tabIndex={0}`, and the content of open shadow\n * roots. Hidden, disabled, inert and `tabIndex={-1}` elements are skipped,\n * and a radio group counts once. Give the container `tabIndex={-1}` so it can\n * hold focus itself when nothing inside can. The trap listens on the\n * container, so a trap nested inside another handles Tab first and the outer\n * one stands aside.\n *\n * The trap is about Tab. If a Tab it let through still takes focus out (a\n * browser can leave out a stop the page has, such as links when its settings\n * say to), it sends focus back to the other end. A pointer or a script moving\n * focus out is left alone, because pulling focus back from a click is modal\n * behaviour, and a modal also has to block the page behind it, which `Modal`\n * does. Content the container renders through a portal lives elsewhere in\n * the DOM, so it is outside the trap: render nested overlays inside the\n * container, or give them a trap of their own. To trap content a `Portal`\n * renders, pass a ref to the element inside the `Portal` as `containerRef`.\n *\n * The trap looks at `containerRef` again each time the component calling it\n * renders. A container that mounts after the trap turns on, such as a panel\n * waiting for a `Portal` target held in state, has it attach once that\n * component renders with the container in the DOM. When the container leaves\n * or is replaced, the trap lets go of it as it would turning off, handing\n * focus back, and attaches to the next one.\n * A child that mounts the container in a render of its own (from its own\n * state, or as a `Suspense` boundary resolves) goes unseen until the\n * component calling the hook renders again. The trap waits for hydration, so\n * that component renders again when the page hydrates, and portaled content,\n * which first appears then, is found.\n *\n * @function useFocusTrap\n * @param containerRef - Ref to the element focus stays inside.\n * @param options - When the trap is on, and where focus starts and ends.\n *\n * @example\n * const panelRef = useRef<HTMLDivElement>(null);\n * useFocusTrap(panelRef, { active: isOpen });\n * return isOpen ? (\n *   <div ref={panelRef} role=\"dialog\" aria-label=\"Filters\" tabIndex={-1}>\n *     …\n *   </div>\n * ) : null;\n */\nexport function useFocusTrap(\n  containerRef: RefObject<HTMLElement | null>,\n  options: UseFocusTrapOptions = {}\n): void {\n  const { active = true, initialFocusRef, restoreFocus = true } = options;\n  // Portaled content has no server-rendered counterpart, so a portaled\n  // container only exists from the commit after hydration.\n  const hydrated = useIsHydrated();\n  // The container the trap is attached to, or `null` while it has none.\n  const heldRef = useRef<HTMLElement | null>(null);\n  // Bumped to run the trap again when the container in the ref changes.\n  const [refChanges, setRefChanges] = useState(0);\n\n  useEffect(() => {\n    heldRef.current = null;\n    if (!active || !hydrated) return undefined;\n    const container = containerRef.current;\n    if (!container) return undefined;\n    heldRef.current = container;\n    const doc = container.ownerDocument;\n\n    const opener = focusedElement(doc) as HTMLElement;\n\n    // `initialFocusRef` counts only when focusing it puts focus inside. Focus\n    // put outside would stay out, as Tab there never reaches the container's\n    // listener, and focusing something that can't take focus (a heading\n    // without `tabIndex`, a disabled control) leaves focus where it was.\n    const initial = initialFocusRef?.current;\n    const inTrap = initial && inside(container, initial) ? initial : null;\n    inTrap?.focus();\n    if (!inTrap || !inside(container, focusedElement(doc))) {\n      (findTabStops(container)?.first ?? container).focus();\n    }\n\n    // Where focus goes if a Tab the trap let the browser handle takes it out,\n    // held until that Tab has finished moving focus.\n    let wrapTo: HTMLElement | null = null;\n    let wrapTimer: ReturnType<typeof setTimeout> | undefined;\n\n    const handleKeyDown = (e: KeyboardEvent) => {\n      // A trap nested inside this one has already wrapped focus.\n      if (e.key !== 'Tab' || e.defaultPrevented) return;\n      const stops = findTabStops(container);\n      if (!stops) {\n        e.preventDefault();\n        container.focus();\n        return;\n      }\n      const current = stops.stopFor(focusedElement(doc));\n      // Wrap whenever the browser has no stop left in that direction inside\n      // the container. Comparing positions rather than testing `=== first`\n      // also covers focus resting on the container or on an element outside\n      // the tab order, which the browser would otherwise walk straight out of.\n      if (\n        e.shiftKey\n          ? !follows(container, stops.first, current)\n          : !follows(container, current, stops.last)\n      ) {\n        e.preventDefault();\n        (e.shiftKey ? stops.last : stops.first).focus();\n        return;\n      }\n      wrapTo = e.shiftKey ? stops.last : stops.first;\n      clearTimeout(wrapTimer);\n      wrapTimer = setTimeout(() => {\n        wrapTo = null;\n      });\n    };\n\n    // The browser moves focus as soon as the keydown is over, so focus that\n    // lands outside while `wrapTo` is set got there by that Tab.\n    const handleFocusIn = (e: FocusEvent) => {\n      if (!wrapTo || inside(container, e.composedPath()[0] as Node)) return;\n      const target = wrapTo;\n      wrapTo = null;\n      target.focus();\n    };\n\n    container.addEventListener('keydown', handleKeyDown);\n    doc.addEventListener('focusin', handleFocusIn, true);\n    return () => {\n      container.removeEventListener('keydown', handleKeyDown);\n      doc.removeEventListener('focusin', handleFocusIn, true);\n      clearTimeout(wrapTimer);\n      let target = restoreFocus ? opener : null;\n      // `null` is an object too, and a caller without types can pass it.\n      if (restoreFocus && typeof restoreFocus === 'object') {\n        // Read now rather than when the trap turned on: a trigger that\n        // re-mounted in between has a new node.\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        target = restoreFocus.current;\n      }\n      // Hand focus back only while the trap still holds it: inside the\n      // container, or dropped to <body> because the container left the page.\n      const now = focusedElement(doc);\n      if (target && (now === doc.body || inside(container, now))) {\n        target.focus();\n      }\n    };\n  }, [\n    active,\n    hydrated,\n    containerRef,\n    initialFocusRef,\n    restoreFocus,\n    refChanges,\n  ]);\n\n  // Nothing says when a ref is set, so after every render, a ref that no\n  // longer matches what the trap holds (a container that mounted, left or was\n  // replaced) runs it again. Effects run in order, so whenever the effect\n  // above ran in this commit, it read the ref just before this does, and a\n  // mismatch means the ref changed in a render it didn't run for. The render\n  // a bump asks for runs it, so the two match and the trap settles. An empty\n  // ref matches a trap holding nothing, so a container that never mounts\n  // costs no render.\n  // eslint-disable-next-line react-hooks/exhaustive-deps -- after every render on purpose\n  useEffect(() => {\n    if (active && hydrated && containerRef.current !== heldRef.current) {\n      setRefChanges(n => n + 1);\n    }\n  });\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/helpers/useIsHydrated.js

@@ -0,0 +1,31 @@
+/* @allxsmith/bestax-bulma — AI agents: see AGENTS.md in the package root, or https://bestax.io/llms.txt */
+import { useSyncExternalStore } from 'react';
+
+// "Are we past hydration?" as a store that never changes: React reads the
+// server snapshot both while server-rendering and while hydrating, and the
+// client snapshot from the first post-hydration render onward.
+const subscribeToNothing = () => () => { };
+const getClientSnapshot = () => true;
+const getServerSnapshot = () => false;
+/**
+ * Reports whether the component has passed hydration.
+ *
+ * Returns `false` during server rendering and during the hydrating client
+ * render, then `true` from the commit that follows. Use it to defer
+ * DOM-only behaviour (such as portalling) past hydration so the first client
+ * render matches the server markup instead of tripping hydration recovery.
+ *
+ * Only a component that hydrates ever sees `false` on the client. One that
+ * mounts later (after a route change, or in an app with no server rendering)
+ * gets `true` on its first render, so it pays for no extra render. It
+ * subscribes to nothing, so no later render flips it back.
+ *
+ * @function useIsHydrated
+ * @returns `true` once the hydrating render has completed, otherwise `false`.
+ */
+function useIsHydrated() {
+    return useSyncExternalStore(subscribeToNothing, getClientSnapshot, getServerSnapshot);
+}
+
+export { useIsHydrated };
+//# sourceMappingURL=useIsHydrated.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIsHydrated.js","sources":["../../../src/helpers/useIsHydrated.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\n\n// \"Are we past hydration?\" as a store that never changes: React reads the\n// server snapshot both while server-rendering and while hydrating, and the\n// client snapshot from the first post-hydration render onward.\nconst subscribeToNothing = () => () => {};\nconst getClientSnapshot = () => true;\nconst getServerSnapshot = () => false;\n\n/**\n * Reports whether the component has passed hydration.\n *\n * Returns `false` during server rendering and during the hydrating client\n * render, then `true` from the commit that follows. Use it to defer\n * DOM-only behaviour (such as portalling) past hydration so the first client\n * render matches the server markup instead of tripping hydration recovery.\n *\n * Only a component that hydrates ever sees `false` on the client. One that\n * mounts later (after a route change, or in an app with no server rendering)\n * gets `true` on its first render, so it pays for no extra render. It\n * subscribes to nothing, so no later render flips it back.\n *\n * @function useIsHydrated\n * @returns `true` once the hydrating render has completed, otherwise `false`.\n */\nexport function useIsHydrated(): boolean {\n  return useSyncExternalStore(\n    subscribeToNothing,\n    getClientSnapshot,\n    getServerSnapshot\n  );\n}\n"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA,MAAM,kBAAkB,GAAG,MAAM,MAAK,EAAE,CAAC;AACzC,MAAM,iBAAiB,GAAG,MAAM,IAAI;AACpC,MAAM,iBAAiB,GAAG,MAAM,KAAK;AAErC;;;;;;;;;;;;;;;AAeG;SACa,aAAa,GAAA;IAC3B,OAAO,oBAAoB,CACzB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,CAClB;AACH;;"}