npm - stimeo-ui - Versions diffs - 0.13.0 → 0.14.0 - Mend

stimeo-ui 0.13.0 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (103) hide show

package/dist/controllers/roving_controller.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../../src/utils/logical_scroll.ts","../../src/utils/arrow_step.ts","../../src/utils/focus_candidate.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/roving_tabindex.ts","../../src/controllers/roving_controller.ts"],"names":[],"mappings":"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","file":"roving_controller.js","sourcesContent":["/** Normalized scroll position and maximum distance on one logical axis. /\nexport interface LogicalScrollMetrics {\n position: number;\n max: number;\n}\n\n/\n Whether horizontal scrolling on `element` follows right-to-left inline flow.\n \n Resolved from the computed `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n \n Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n /\nexport function isRtl(element: Element): boolean {\n return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/\n Returns scroll distance from the logical start edge.\n \n CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n /\nexport function logicalScrollMetrics(\n element: HTMLElement,\n horizontal: boolean,\n): LogicalScrollMetrics {\n const max = Math.max(\n 0,\n horizontal\n ? element.scrollWidth - element.clientWidth\n : element.scrollHeight - element.clientHeight,\n );\n const raw = horizontal ? element.scrollLeft : element.scrollTop;\n const position = horizontal && isRtl(element) ? -raw : raw;\n return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/\n Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n /\nexport function physicalScrollDelta(\n element: HTMLElement,\n horizontal: boolean,\n logicalDelta: number,\n): number {\n return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\n}\n","import { isRtl } from \"./logical_scroll\";\n\n/\n Turns an arrow key into a logical step: `+1` for \"next\", `-1` for\n * \"previous\", `0` when the key names neither.\n \n APG defines the horizontal pair as next / previous and says a vertical\n * arrangement swaps in Down/Up for the same meaning — so the pair is one axis's\n * spelling of an order, and the order reverses with the writing direction. Only\n * the horizontal pair reverses. Down/Up name an axis the writing direction does\n * not mirror, and returning them unchanged is the point: many controllers fold\n * both pairs into one branch, where swapping the branches under RTL would flip\n * the vertical axis too — a bug that reads as \"the arrows work\" until someone\n * presses Down.\n \n *Direction is read from the element the caller passes, which should be the\n container that lays the items out** — not the focused child. A child may carry\n * its own `dir` (an LTR input inside an RTL form is ordinary authoring), and\n * probing per handler makes two handlers disagree at the boundary between them.\n \n This decides direction only. Whether the axis is even active (an\n * `orientation=\"horizontal\"` widget ignoring Down/Up), how far the step lands,\n * and what wrapping does all stay with the caller.\n \n *It encodes the list-order convention: `ArrowDown` is next.* Widgets that\n * pair the arrows by value instead — `ArrowUp` meaning \"more\", as a rating or a\n * slider does — must not use this, or their vertical axis inverts. Reverse the\n * horizontal pair on its own there.\n \n @example\n * ```ts\n * const step = logicalArrowStep(event.key, this.element);\n * if (step === 0) return;\n * this.#roving.setActive(rovingMove(current, length, step, \"wrap\"), { focus: true });\n * ```\n /\nexport function logicalArrowStep(key: string, element: Element): 1 \| -1 \| 0 {\n if (key === \"ArrowDown\") return 1;\n if (key === \"ArrowUp\") return -1;\n if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return 0;\n const forward = isRtl(element) ? \"ArrowLeft\" : \"ArrowRight\";\n return key === forward ? 1 : -1;\n}\n\n/\n Rewrites `key` so an existing LTR-shaped branch keeps working under RTL:\n * `ArrowRight` and `ArrowLeft` trade places, everything else passes through.\n \n The alternative — negating a delta — silently breaks handlers whose two\n * horizontal branches are not mirror images. A grid that clamps one edge but\n * not the other, or a segmented field guarding `index > 0` on one side and\n * `index < length - 1` on the other, ends up applying the wrong guard to the\n * wrong direction. Swapping the key leaves each branch, guards and all, exactly\n * where its author put it.\n \n Same rule as {@link logicalArrowStep} about which element to read: pass the\n * container that lays the items out, not the focused child.\n \n @example\n * ```ts\n * switch (logicalArrowKey(event.key, this.element)) {\n * case \"ArrowLeft\": // \"previous\" — whatever direction that is on screen\n * ```\n /\nexport function logicalArrowKey(key: string, element: Element): string {\n if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return key;\n if (!isRtl(element)) return key;\n return key === \"ArrowRight\" ? \"ArrowLeft\" : \"ArrowRight\";\n}\n\n/* Modifiers a widget may claim on an arrow key, named for the `allow` list. /\nexport type ArrowModifier = \"alt\" \| \"ctrl\" \| \"meta\" \| \"shift\";\n\n/\n True when an arrow key arrived carrying a modifier the widget must leave to\n * the browser: return without calling `preventDefault()` and without moving any\n * state.\n \n A bare arrow belongs to the widget; a chorded one usually does not.\n * `Alt`/`Meta` plus a horizontal arrow is history back/forward on every desktop\n * browser, and a widget that swallows it makes the shortcut work or not\n * depending on where focus happens to sit — a coin-flip the user cannot see.\n \n `allow` is for the combinations APG assigns to a pattern *and the widget\n actually implements** — today only Combobox's optional `Alt+Down`/`Alt+Up`.\n * Listing one the widget does not implement defeats the point: the chord then\n * runs the plain-arrow branch, which is exactly what this guard exists to stop.\n * Non-arrow keys return `false`, so chorded letters and\n * `Control+Home`/`Control+End` are untouched.\n \n @example\n * ```ts\n * if (isReservedArrowChord(event)) return;\n * ```\n /\nexport function isReservedArrowChord(\n event: KeyboardEvent,\n allow: readonly ArrowModifier[] = [],\n): boolean {\n if (!event.key.startsWith(\"Arrow\")) return false;\n return (\n (event.altKey && !allow.includes(\"alt\")) \|\|\n (event.ctrlKey && !allow.includes(\"ctrl\")) \|\|\n (event.metaKey && !allow.includes(\"meta\")) \|\|\n (event.shiftKey && !allow.includes(\"shift\"))\n );\n}\n\n/\n True when a press arrived carrying any modifier, for the keys the browser and\n * the OS own outright: return without calling `preventDefault()` and without\n * moving any state.\n \n `Control+Home` and `Control+End` jump the document to its ends, and a widget\n * that swallows them makes the shortcut work or not depending on where focus\n * happens to sit. {@link isReservedArrowChord} answers the same question for the\n * arrows, but returns `false` for every other key so that this one can decide.\n \n There is no `allow` list here on purpose. APG assigns no modifier chord to\n * `Home`/`End`, so a widget that wanted one would be claiming a combination the\n * pattern never gave it.\n \n @example\n * ```ts\n * case \"Home\":\n * case \"End\":\n * if (hasModifierChord(event)) return;\n * ```\n /\nexport function hasModifierChord(event: KeyboardEvent): boolean {\n return event.altKey \|\| event.ctrlKey \|\| event.metaKey \|\| event.shiftKey;\n}\n","/\n Whether a disabled `<fieldset>` ancestor actually reaches `control`.\n \n HTML exempts the contents of a fieldset's first direct-child `<legend>`, and\n * the exemption is per fieldset — a control legal in one legend can still be\n * disabled by a second, outer fieldset, so the walk continues upward.\n \n Exported on its own for callers that need the disabled-inheritance rule without\n * the rest of {@link canTakeFocus} — a control's availability check, or a `hidden`\n * walk bounded at a widget root, which is a different rule to compose with.\n /\nexport function inheritsFieldsetDisabled(control: HTMLElement): boolean {\n let fieldset: Element \| null = control.closest(\"fieldset[disabled]\");\n while (fieldset) {\n const legend = Array.from(fieldset.children).find((child) => child.tagName === \"LEGEND\");\n if (!legend?.contains(control)) return true;\n fieldset = fieldset.parentElement?.closest(\"fieldset[disabled]\") ?? null;\n }\n return false;\n}\n\n/\n Whether an element can actually take focus, checked before `focus()` runs.\n \n A controller that must move focus off a control it is about to disable or hide\n * picks a destination and calls `focus()` on it. If that destination cannot take\n * focus, the call fails silently: `hidden` and natively `disabled` elements\n * swallow it, so the caret stays in the subtree that is disappearing and lands on\n * `<body>` a frame later — the exact outcome the rescue exists to prevent, minus\n * any signal that it happened.\n \n Testing after the fact is the obvious alternative and is deliberately not the\n * rule. Reading `document.activeElement` back only works in a real browser, and\n * looping over candidates that way performs a real focus move per failure —\n * observable to assistive technology. Checking first costs nothing and catches\n * the cases that actually occur.\n \n `aria-disabled` is not disqualifying. It is the attribute an author uses\n * for a control that must stay discoverable, and the roving contract keeps\n * such items reachable. Only the four conditions that make the platform refuse\n * focus are checked: `hidden` / `inert` (an ancestor's counts),\n * `input[type=\"hidden\"]`, the native `disabled` property, and `disabled`\n * inherited from an ancestor `fieldset`. CSS-only invisibility is handled by\n * {@link isRenderedForFocus} when a consumer needs sequential-focus semantics.\n \n Reading `:disabled` instead of walking the fieldset chain would be shorter, but\n * that pseudo-class is not evaluated consistently outside real browsers and this\n * has to be right headlessly too. happy-dom in particular focuses a `<button>`\n * inside a disabled fieldset where a real engine refuses, so the inheritance is\n * spelled out rather than delegated.\n \n What a consumer does when nothing survives is its own call: some fall back to\n * their landmark, while a widget whose caret already sits somewhere legitimate\n * refuses the move outright rather than relocating it.\n \n @example\n * ```ts\n * const target = candidates.find(canTakeFocus);\n * if (target) target.focus();\n * else {\n * this.#tabindex.lend(this.element); // nothing left: fall back to the landmark\n * this.element.focus();\n * }\n * ```\n \n @param element - the candidate destination\n /\nexport function canTakeFocus(element: HTMLElement): boolean {\n if (element.closest(\"[hidden], [inert]\")) return false;\n if (element instanceof HTMLInputElement && element.type === \"hidden\") return false;\n if (!(\"disabled\" in element)) return true;\n if ((element as HTMLElement & { disabled: boolean }).disabled) return false;\n return !inheritsFieldsetDisabled(element);\n}\n\n/* Elements whose semantics or authored attributes can place them in sequential focus order. /\nexport const TAB_STOP_CANDIDATE_SELECTOR = [\n \"a[href]\",\n \"area[href]\",\n \"button\",\n \"input\",\n \"select\",\n \"textarea\",\n \"summary\",\n \"iframe\",\n \"audio[controls]\",\n \"video[controls]\",\n \"[tabindex]\",\n \"[contenteditable]\",\n].join(\",\");\n\n/* Optional browser visibility API used to exclude CSS-hidden candidates. /\ninterface VisibilityCheckable {\n checkVisibility?: (options?: { visibilityProperty?: boolean }) => boolean;\n}\n\n/* Whether CSS visibility allows an otherwise eligible element to participate in focus order. /\nexport function isRenderedForFocus(element: HTMLElement): boolean {\n const check = (element as HTMLElement & VisibilityCheckable).checkVisibility;\n return typeof check === \"function\" ? check.call(element, { visibilityProperty: true }) : true;\n}\n\n/* Parses an authored `tabindex`; invalid syntax has no explicit focus-order meaning. /\nfunction authoredTabindex(element: HTMLElement): number \| null {\n const value = element.getAttribute(\"tabindex\");\n if (value === null \|\| !/^[+-]?\\d+$/.test(value.trim())) return null;\n return Number(value);\n}\n\n/* Whether the element's native semantics place it in sequential focus order. /\nfunction hasNativeTabStop(element: HTMLElement): boolean {\n if (element instanceof HTMLAnchorElement \|\| element instanceof HTMLAreaElement) {\n return element.hasAttribute(\"href\");\n }\n if (\n element instanceof HTMLButtonElement \|\|\n element instanceof HTMLSelectElement \|\|\n element instanceof HTMLTextAreaElement\n ) {\n return true;\n }\n if (element instanceof HTMLInputElement) return element.type !== \"hidden\";\n if (element instanceof HTMLIFrameElement) return true;\n if (element.tagName === \"AUDIO\" \|\| element.tagName === \"VIDEO\") {\n return element.hasAttribute(\"controls\");\n }\n if (element instanceof HTMLElement && element.tagName === \"SUMMARY\") {\n const details = element.parentElement;\n return (\n details instanceof HTMLDetailsElement &&\n Array.from(details.children).find((child) => child.tagName === \"SUMMARY\") === element\n );\n }\n return false;\n}\n\n/* Whether an explicit `contenteditable` value creates an editable tab stop. /\nfunction hasEditableTabStop(element: HTMLElement): boolean {\n const value = element.getAttribute(\"contenteditable\")?.toLowerCase();\n return value === \"\" \|\| value === \"true\" \|\| value === \"plaintext-only\";\n}\n\n/\n Whether an element is a usable sequential Tab stop right now.\n \n Native semantics, authored `tabindex`, editable hosts, inherited disabled state,\n * HTML `hidden`/`inert`, and CSS visibility are evaluated together. `aria-disabled`\n * remains focusable because it communicates unavailability without removing the\n * control from discovery order.\n /\nexport function isTabStop(element: HTMLElement): boolean {\n if (!canTakeFocus(element) \|\| !isRenderedForFocus(element)) return false;\n\n const tabindex = authoredTabindex(element);\n if (tabindex !== null) return tabindex >= 0;\n return hasNativeTabStop(element) \|\| hasEditableTabStop(element);\n}\n\n/* Returns every usable sequential Tab stop below `root` in document order. /\nexport function tabStopsWithin(root: ParentNode): HTMLElement[] {\n return Array.from(root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)).filter(\n isTabStop,\n );\n}\n\n/* Returns the first usable sequential Tab stop below `root`, if one exists. /\nexport function firstTabStop(root: ParentNode): HTMLElement \| null {\n for (const candidate of root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)) {\n if (isTabStop(candidate)) return candidate;\n }\n return null;\n}\n\n/* Whether `root` contains at least one usable sequential Tab stop. /\nexport function hasTabStop(root: ParentNode): boolean {\n return firstTabStop(root) !== null;\n}\n","/\n Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n \n Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n \n A microtask is the right horizon, and the reason is specific. Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n \n The two guards are not the same guard. Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n \n - Before `connect()` — Stimulus delivers initial target and Value callbacks\n * ahead of `connect()`. Reconciling there would compute output against a\n * controller whose own state has not been initialised, and `connect()` is\n * about to do a full pass anyway.\n * - After `disconnect()` — Stimulus fires a callback for every target\n * during teardown, and a microtask queued just before it would otherwise run\n * against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n * teardown path to drop the pending pass outright.\n \n Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n \n Scope is the scheduling only. What to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n \n @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n \n connect() { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n \n optionTargetConnected() { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n /\nexport class MicrotaskCoalescer {\n readonly #run: () => void;\n #queued = false;\n #active = false;\n #generation = 0;\n\n /* @param run - the single reconciliation pass, invoked at most once per batch. /\n constructor(run: () => void) {\n this.#run = run;\n }\n\n /* Opens the window in which {@link schedule} is honoured; call from `connect()`. /\n activate(): void {\n this.#active = true;\n }\n\n /* Closes the window and drops any pending pass; call from `disconnect()`. /\n cancel(): void {\n this.#active = false;\n this.#queued = false;\n this.#generation += 1;\n }\n\n /* Requests one pass after the batch settles. Idempotent; inert outside the window. /\n schedule(): void {\n if (!this.#active \|\| this.#queued) return;\n this.#queued = true;\n const generation = this.#generation;\n queueMicrotask(() => {\n // A cancelled callback must not consume a pass queued after reconnect.\n if (generation !== this.#generation \|\| !this.#queued \|\| !this.#active) return;\n this.#queued = false;\n this.#run();\n });\n }\n}\n","/\n Low-level roving-tabindex primitive shared by composite-widget controllers.\n \n The APG roving-tabindex pattern keeps a composite widget a single Tab stop:\n * exactly one item is in the Tab sequence (`tabindex=\"0\"`) while the rest are\n * removed from it (`tabindex=\"-1\"`), and the arrow keys move both DOM focus and\n * that single tabbable position together. {@link RovingTabindex} owns only that\n * mechanical bookkeeping — \"which one item is tabbable, and move focus there\".\n \n It is intentionally policy-free. Orientation, wrapping vs. clamping,\n * selection-follows-focus, typeahead, and `Home`/`End` semantics differ per APG\n * pattern (Radio Group, Toolbar, Rating, …); folding them into one helper would\n * flatten those widgets to a lowest common denominator and lose each pattern's\n * correctness. Those decisions therefore stay in each controller, which calls\n * {@link RovingTabindex.setActive} with an index it computed itself (optionally\n * via the pure {@link rovingMove} helper).\n \n @remarks\n * Items are read lazily through a getter so a controller can add or remove\n * targets (Stimulus re-scans the DOM) without re-wiring this helper. A caller\n * that already captured one event-scoped snapshot may pass it to\n * {@link RovingTabindex.setActive}, avoiding a second live-target scan while\n * preserving one coherent collection for the whole operation.\n /\nexport class RovingTabindex {\n /* Returns the current ordered item elements; called on every operation. /\n readonly #getItems: () => HTMLElement[];\n\n /\n @param getItems - Returns the current ordered item elements. Called on every\n * operation so the live target list is always used.\n /\n constructor(getItems: () => HTMLElement[]) {\n this.#getItems = getItems;\n }\n\n /* Index of the currently tabbable item (`tabindex=\"0\"`), or `-1` if none. /\n get activeIndex(): number {\n return this.#getItems().findIndex((item) => item.tabIndex === 0);\n }\n\n /\n Makes exactly the item at `index` tabbable (`tabindex=\"0\"`) and removes every\n * other item from the Tab sequence (`tabindex=\"-1\"`). An out-of-range `index`\n * (e.g. `-1`) leaves all items at `-1`, which a controller can use to express\n * \"nothing is currently tabbable\".\n \n @param index - Position of the item to make tabbable.\n * @param options - Pass `{ focus: true }` to also move DOM focus to that item,\n * and `items` to reuse an event-scoped collection snapshot.\n /\n setActive(\n index: number,\n options: { focus?: boolean; items?: readonly HTMLElement[] } = {},\n ): void {\n const { focus = false } = options;\n const items = options.items ?? this.#getItems();\n items.forEach((item, i) => {\n item.tabIndex = i === index ? 0 : -1;\n });\n if (focus) items[index]?.focus();\n }\n}\n\n/* Edge behavior for {@link rovingMove}: cycle past the ends, or stop at them. /\nexport type RovingWrap = \"wrap\" \| \"clamp\";\n\n/\n Pure helper that resolves the target index for a one-step directional move.\n \n Keyboard/orientation mapping stays in the caller: it decides that a key means\n * `delta` `+1` (next) or `-1` (previous) and whether the widget should `\"wrap\"`\n * (Radio Group, Toolbar) or `\"clamp\"` at the ends.\n \n @param current - The index focus is moving from.\n * @param length - Number of items in the set.\n * @param delta - `+1` to move to the next item, `-1` for the previous.\n * @param wrap - `\"wrap\"` cycles around the ends; `\"clamp\"` stops at them.\n * @returns The resolved index, or `-1` when there are no items.\n /\nexport function rovingMove(\n current: number,\n length: number,\n delta: number,\n wrap: RovingWrap,\n): number {\n if (length === 0) return -1;\n const next = current + delta;\n if (wrap === \"wrap\") return (next + length) % length;\n return Math.min(length - 1, Math.max(0, next));\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { hasModifierChord, isReservedArrowChord } from \"../utils/arrow_step\";\nimport { inheritsFieldsetDisabled } from \"../utils/focus_candidate\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport { MicrotaskCoalescer } from \"../utils/microtask_coalescer\";\nimport { RovingTabindex, type RovingWrap, rovingMove } from \"../utils/roving_tabindex\";\n\n/* Attributes that change whether an item can hold the Tab stop. /\nconst STATE_ATTRIBUTES = [\"disabled\", \"hidden\"];\n\n/\n Headless roving tabindex: makes a set of `item`s a single Tab stop and\n * moves focus between them with the arrow keys — the APG roving-tabindex\n * technique, surfaced as a standalone controller. It is the policy layer over the\n * shared `RovingTabindex` util (the same split `stimeo--focus` makes over its trap),\n * giving the orientation / wrap / Home-End the util deliberately leaves out. No\n * dedicated APG pattern; it is the keyboard primitive Toolbar / Menu / Radio Group\n * and friends build on. Core (zero dependencies).\n \n Markup contract (identifier: `stimeo--roving`):\n * <div data-controller=\"stimeo--roving\"\n * data-stimeo--roving-orientation-value=\"horizontal\">\n * <button data-stimeo--roving-target=\"item\">A</button>\n * <button data-stimeo--roving-target=\"item\">B</button>\n * <button data-stimeo--roving-target=\"item\">C</button>\n * </div>\n \n Exactly one item is tabbable (`tabindex=\"0\"`); the arrow keys (per\n * `orientation`) move focus and that tab stop together, `Home`/`End` jump to the\n * ends (`homeEnd`), and `wrap` cycles past the ends or clamps at them. Listeners\n * are delegated on the container — `keydown` for movement and `focusin` to\n * sync the tab stop when focus arrives by click or programmatically — so\n * dynamically added/removed items need no per-item `data-action`. It emits\n * `change` when a key press or an incoming focus moves the tabbable item; connect\n * and target reconciliation re-establish the tab stop silently.\n \n Items that cannot take focus — `hidden` (their own attribute or a wrapper's up\n * to the container) and natively `disabled`, including through a disabled\n * `fieldset` — are neither move targets nor tab-stop candidates: the lone\n * `tabindex=\"0\"` sitting on one would take the whole set out of the Tab sequence\n * while focus stayed behind. `aria-disabled` items stay reachable; suppressing\n * their activation belongs to the consuming pattern. A key that resolves to no\n * reachable item is left to the page (unlike Toolbar, which consumes it).\n \n `change` dispatches `{ index, item }`.\n \n @remarks\n * Behavior only: it owns `tabindex` and focus movement, nothing else. It does\n * not assign roles (`role=\"toolbar\"`/`\"radiogroup\"` is the author's), manage\n * selection / selection-follows-focus, typeahead, or activation (`Enter`/`Space`)\n * — those stay with the consuming pattern. `connect()` is idempotent: it keeps an\n * existing tab stop (reads it back from the DOM) and only defaults to the first\n * reachable item when none is set, so a Turbo cache restore / morph never resets\n * the user's position. Re-establishing the stop after a batch of item changes\n * follows DOM focus first, so an item added and focused in the same task keeps it;\n * `connect()` deliberately does not, because the authored DOM is what it reads\n * back. The delegated listeners and the state observer are torn down on\n * `disconnect()`.\n /\nexport class RovingController extends Controller<HTMLElement> {\n static override targets = [\"item\"];\n static override values = {\n orientation: { type: String, default: \"horizontal\" },\n wrap: { type: Boolean, default: true },\n homeEnd: { type: Boolean, default: true },\n };\n static events = [\"change\"] as const;\n\n declare readonly itemTargets: HTMLElement[];\n declare orientationValue: string;\n declare wrapValue: boolean;\n declare homeEndValue: boolean;\n\n readonly #roving = new RovingTabindex(() => this.itemTargets);\n readonly #reconcile = new MicrotaskCoalescer(() => this.#ensureTabStop(true));\n #connected = false;\n #observer: MutationObserver \| null = null;\n\n override connect(): void {\n // Establish the single tab stop from the DOM (source of truth): keep an\n // existing tabbable item, else default to the first. Silent — no change event\n // for the initial mount.\n this.#ensureTabStop(false);\n this.element.addEventListener(\"keydown\", this.#onKeydown);\n this.element.addEventListener(\"focusin\", this.#onFocusin);\n this.#watchState();\n this.#connected = true;\n this.#reconcile.activate();\n }\n\n override disconnect(): void {\n this.#connected = false;\n this.#reconcile.cancel();\n this.element.removeEventListener(\"keydown\", this.#onKeydown);\n this.element.removeEventListener(\"focusin\", this.#onFocusin);\n this.#observer?.disconnect();\n this.#observer = null;\n }\n\n /* Drops a runtime-added item from the Tab sequence before batch reconciliation. /\n itemTargetConnected(item: HTMLElement): void {\n if (!this.#connected) return;\n item.tabIndex = -1;\n this.#reconcile.schedule();\n }\n\n /* Re-establishes the single Tab stop after an item leaves the target set. /\n itemTargetDisconnected(): void {\n this.#reconcile.schedule();\n }\n\n /* Arrow keys move focus + the tab stop; Home/End jump to the ends. /\n readonly #onKeydown = (event: KeyboardEvent): void => {\n // A descendant widget that already claimed the key (e.g. a grabbed\n // `stimeo--pointer-drag` handle consuming arrows to move an item) must not\n // ALSO move the roving focus — composition depends on this yield.\n if (event.defaultPrevented) return;\n if (isReservedArrowChord(event)) return;\n // A key pressed to steer an IME candidate list belongs to the composition.\n if (event.isComposing) return;\n const current = this.#indexOf(event.target);\n if (current === -1) return;\n\n const wrap: RovingWrap = this.wrapValue ? \"wrap\" : \"clamp\";\n const orientation = this.orientationValue;\n const horizontal = orientation === \"horizontal\" \|\| orientation === \"both\";\n const vertical = orientation === \"vertical\" \|\| orientation === \"both\";\n\n // Logical, not physical. APG defines these as \"next / previous\n // control\", and says a vertical arrangement swaps in Down/Up for the same\n // meaning — so the pair is one axis's spelling of an order, and the order\n // reverses with the writing direction. Read from the controller element: the\n // container is what lays the items out, and a child may carry its own `dir`\n // (an LTR input inside an RTL form is ordinary authoring).\n // Only the horizontal pair reverses; `orientation=\"both\"` keeps Down/Up as-is.\n const rtl = horizontal && isRtl(this.element);\n const forwardKey = rtl ? \"ArrowLeft\" : \"ArrowRight\";\n const backwardKey = rtl ? \"ArrowRight\" : \"ArrowLeft\";\n\n let next: number;\n if ((horizontal && event.key === forwardKey) \|\| (vertical && event.key === \"ArrowDown\")) {\n next = this.#step(current, 1, wrap);\n } else if ((horizontal && event.key === backwardKey) \|\| (vertical && event.key === \"ArrowUp\")) {\n next = this.#step(current, -1, wrap);\n } else if (this.homeEndValue && (event.key === \"Home\" \|\| event.key === \"End\")) {\n // Chorded Home/End are the browser's document jumps; APG gives the widget\n // no modifier combination for them.\n if (hasModifierChord(event)) return;\n next = event.key === \"Home\" ? this.#firstReachable() : this.#lastReachable();\n } else {\n return;\n }\n\n if (next === -1) return;\n event.preventDefault();\n this.#activate(next, true);\n };\n\n /\n Syncs the single tab stop to an item that received focus by other means\n * (click, programmatic `focus()`), so returning via Tab lands on it. The\n * keyboard path's own `focus()` re-enters here but is a no-op (index unchanged).\n /\n readonly #onFocusin = (event: FocusEvent): void => {\n const index = this.#indexOf(event.target);\n if (index === -1 \|\| !this.#reachable(index)) return;\n this.#activate(index, false);\n };\n\n /* Resolves the item index owning an event target (the item or a descendant). /\n #indexOf(target: EventTarget \| null): number {\n const node = target as Node \| null;\n if (!node) return -1;\n return this.itemTargets.findIndex((item) => item === node \|\| item.contains(node));\n }\n\n /* Makes `index` the tab stop (optionally focusing it), emitting `change` once. /\n #activate(index: number, focus: boolean): void {\n const previous = this.#roving.activeIndex;\n this.#roving.setActive(index, { focus });\n if (index !== previous) {\n this.dispatch(\"change\", { detail: { index, item: this.itemTargets[index] } });\n }\n }\n\n /\n Keeps the Tab stop on a reachable item.\n \n `followFocus` is on for re-establishment only: an item added and focused in\n * the same task has already claimed the stop through `focusin`, and the batch\n * that follows must not hand it back to the first item. `connect()` passes it\n * off so the authored DOM decides the initial stop. With nothing reachable the\n * DOM is left as it is — a group inside a collapsed region gets its stop back\n * when the region opens, instead of losing it for good.\n /\n #ensureTabStop(followFocus: boolean): void {\n const items = this.itemTargets;\n const focused = followFocus\n ? items.findIndex((item, i) => item === document.activeElement && this.#reachable(i))\n : -1;\n const active = this.#roving.activeIndex;\n const kept = active !== -1 && this.#reachable(active) ? active : -1;\n const index = focused !== -1 ? focused : kept !== -1 ? kept : this.#firstReachable();\n if (index === -1) return;\n this.#roving.setActive(index);\n }\n\n /\n Resolves the next reachable index in `delta`'s direction, honouring `wrap`.\n \n An arrow on the widget's own axis is the widget's to consume even when the\n * position does not change, so a clamped end resolves to the current item\n * rather than to nothing. An unreachable origin escapes to the first reachable\n * item instead of sitting in a dead end, and `-1` is left for the one case that\n * really is not ours: no reachable item anywhere.\n /\n #step(current: number, delta: number, wrap: RovingWrap): number {\n const length = this.itemTargets.length;\n let index = current;\n for (let taken = 0; taken < length; taken += 1) {\n const candidate = rovingMove(index, length, delta, wrap);\n if (candidate === index) break; // clamped at an end\n index = candidate;\n if (this.#reachable(index)) return index;\n }\n return this.#reachable(current) ? current : this.#firstReachable();\n }\n\n /* Index of the first reachable item, or `-1`. /\n #firstReachable(): number {\n return this.itemTargets.findIndex((_item, i) => this.#reachable(i));\n }\n\n /* Index of the last reachable item, or `-1`. /\n #lastReachable(): number {\n for (let i = this.itemTargets.length - 1; i >= 0; i -= 1) {\n if (this.#reachable(i)) return i;\n }\n return -1;\n }\n\n /\n Whether the item at `index` can hold the Tab stop and take focus.\n \n `aria-disabled` is deliberately not consulted: it keeps an item reachable and\n * only suppresses activation, which this part does not own.\n /\n #reachable(index: number): boolean {\n const item = this.itemTargets[index];\n if (!item) return false;\n if (this.#hidden(item)) return false;\n if (!(\"disabled\" in item)) return true;\n if ((item as HTMLElement & { disabled: boolean }).disabled) return false;\n return !inheritsFieldsetDisabled(item);\n }\n\n /\n Whether `item`, or anything between it and the container, is `hidden`.\n \n The walk stops at the container on purpose: a group inside a hidden region is\n * already out of the page's Tab order, and calling every item unreachable there\n * would drop the stop with nothing left to restore it — the ancestor lies\n * outside the subtree whose state attributes are watched.\n /\n #hidden(item: HTMLElement): boolean {\n let node: HTMLElement \| null = item;\n while (node && node !== this.element) {\n if (node.hasAttribute(\"hidden\")) return true;\n node = node.parentElement;\n }\n return false;\n }\n\n /\n Watches the attributes that decide reachability, so disabling the item that\n * holds the Tab stop hands it to another one instead of taking the whole set\n * out of the Tab sequence. An enclosing `fieldset` disables items from outside\n * the observed subtree, so each one's own `disabled` is watched too.\n */\n #watchState(): void {\n if (typeof MutationObserver === \"undefined\") return;\n const observer = new MutationObserver(() => this.#reconcile.schedule());\n observer.observe(this.element, {\n subtree: true,\n attributes: true,\n attributeFilter: STATE_ATTRIBUTES,\n });\n for (\n let fieldset = this.element.parentElement?.closest(\"fieldset\") ?? null;\n fieldset;\n fieldset = fieldset.parentElement?.closest(\"fieldset\") ?? null\n ) {\n observer.observe(fieldset, { attributes: true, attributeFilter: [\"disabled\"] });\n }\n this.#observer = observer;\n }\n}\n"]}
1	+ {"version":3,"sources":["../../src/utils/logical_scroll.ts","../../src/utils/arrow_step.ts","../../src/utils/event_owner.ts","../../src/utils/focus_candidate.ts","../../src/utils/microtask_coalescer.ts","../../src/utils/roving_tabindex.ts","../../src/controllers/roving_controller.ts"],"names":[],"mappings":"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","file":"roving_controller.js","sourcesContent":["/** Normalized scroll position and maximum distance on one logical axis. /\nexport interface LogicalScrollMetrics {\n position: number;\n max: number;\n}\n\n/\n Whether horizontal scrolling on `element` follows right-to-left inline flow.\n \n Resolved from the computed `direction`, so the authoring contract is the\n * usual `dir=\"rtl\"` (or a stylesheet) on the element or any ancestor.\n \n Scope: horizontal writing modes. A vertical writing mode (`writing-mode:\n * vertical-rl`) also inverts the horizontal axis, which this check does not\n * model — vertical writing modes are out of scope for the scroll utilities\n * (their consumers describe axes as horizontal/vertical, not inline/block).\n /\nexport function isRtl(element: Element): boolean {\n return window.getComputedStyle(element).direction === \"rtl\";\n}\n\n/\n Returns scroll distance from the logical start edge.\n \n CSSOM View exposes standards-mode RTL horizontal offsets as `0` at the inline\n * start (right) and increasingly negative values toward the inline end (left).\n * The normalized position is always clamped to `[0, max]`, which also absorbs\n * Safari's elastic overscroll values.\n /\nexport function logicalScrollMetrics(\n element: HTMLElement,\n horizontal: boolean,\n): LogicalScrollMetrics {\n const max = Math.max(\n 0,\n horizontal\n ? element.scrollWidth - element.clientWidth\n : element.scrollHeight - element.clientHeight,\n );\n const raw = horizontal ? element.scrollLeft : element.scrollTop;\n const position = horizontal && isRtl(element) ? -raw : raw;\n return { position: Math.min(max, Math.max(0, position)), max };\n}\n\n/\n Converts a logical start/end delta to the physical value accepted by\n * `Element.scrollBy`.\n /\nexport function physicalScrollDelta(\n element: HTMLElement,\n horizontal: boolean,\n logicalDelta: number,\n): number {\n return horizontal && isRtl(element) ? -logicalDelta : logicalDelta;\n}\n","import { isRtl } from \"./logical_scroll\";\n\n/\n Turns an arrow key into a logical step: `+1` for \"next\", `-1` for\n * \"previous\", `0` when the key names neither.\n \n APG defines the horizontal pair as next / previous and says a vertical\n * arrangement swaps in Down/Up for the same meaning — so the pair is one axis's\n * spelling of an order, and the order reverses with the writing direction. Only\n * the horizontal pair reverses. Down/Up name an axis the writing direction does\n * not mirror, and returning them unchanged is the point: many controllers fold\n * both pairs into one branch, where swapping the branches under RTL would flip\n * the vertical axis too — a bug that reads as \"the arrows work\" until someone\n * presses Down.\n \n *Direction is read from the element the caller passes, which should be the\n container that lays the items out** — not the focused child. A child may carry\n * its own `dir` (an LTR input inside an RTL form is ordinary authoring), and\n * probing per handler makes two handlers disagree at the boundary between them.\n \n This decides direction only. Whether the axis is even active (an\n * `orientation=\"horizontal\"` widget ignoring Down/Up), how far the step lands,\n * and what wrapping does all stay with the caller.\n \n *It encodes the list-order convention: `ArrowDown` is next.* Widgets that\n * pair the arrows by value instead — `ArrowUp` meaning \"more\", as a rating or a\n * slider does — must not use this, or their vertical axis inverts. Reverse the\n * horizontal pair on its own there.\n \n @example\n * ```ts\n * const step = logicalArrowStep(event.key, this.element);\n * if (step === 0) return;\n * this.#roving.setActive(rovingMove(current, length, step, \"wrap\"), { focus: true });\n * ```\n /\nexport function logicalArrowStep(key: string, element: Element): 1 \| -1 \| 0 {\n if (key === \"ArrowDown\") return 1;\n if (key === \"ArrowUp\") return -1;\n if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return 0;\n const forward = isRtl(element) ? \"ArrowLeft\" : \"ArrowRight\";\n return key === forward ? 1 : -1;\n}\n\n/\n Rewrites `key` so an existing LTR-shaped branch keeps working under RTL:\n * `ArrowRight` and `ArrowLeft` trade places, everything else passes through.\n \n The alternative — negating a delta — silently breaks handlers whose two\n * horizontal branches are not mirror images. A grid that clamps one edge but\n * not the other, or a segmented field guarding `index > 0` on one side and\n * `index < length - 1` on the other, ends up applying the wrong guard to the\n * wrong direction. Swapping the key leaves each branch, guards and all, exactly\n * where its author put it.\n \n Same rule as {@link logicalArrowStep} about which element to read: pass the\n * container that lays the items out, not the focused child.\n \n @example\n * ```ts\n * switch (logicalArrowKey(event.key, this.element)) {\n * case \"ArrowLeft\": // \"previous\" — whatever direction that is on screen\n * ```\n /\nexport function logicalArrowKey(key: string, element: Element): string {\n if (key !== \"ArrowRight\" && key !== \"ArrowLeft\") return key;\n if (!isRtl(element)) return key;\n return key === \"ArrowRight\" ? \"ArrowLeft\" : \"ArrowRight\";\n}\n\n/* Modifiers a widget may claim on an arrow key, named for the `allow` list. /\nexport type ArrowModifier = \"alt\" \| \"ctrl\" \| \"meta\" \| \"shift\";\n\n/\n True when an arrow key arrived carrying a modifier the widget must leave to\n * the browser: return without calling `preventDefault()` and without moving any\n * state.\n \n A bare arrow belongs to the widget; a chorded one usually does not.\n * `Alt`/`Meta` plus a horizontal arrow is history back/forward on every desktop\n * browser, and a widget that swallows it makes the shortcut work or not\n * depending on where focus happens to sit — a coin-flip the user cannot see.\n \n `allow` is for the combinations APG assigns to a pattern *and the widget\n actually implements** — today only Combobox's optional `Alt+Down`/`Alt+Up`.\n * Listing one the widget does not implement defeats the point: the chord then\n * runs the plain-arrow branch, which is exactly what this guard exists to stop.\n * Non-arrow keys return `false`, so chorded letters and\n * `Control+Home`/`Control+End` are untouched.\n \n @example\n * ```ts\n * if (isReservedArrowChord(event)) return;\n * ```\n /\nexport function isReservedArrowChord(\n event: KeyboardEvent,\n allow: readonly ArrowModifier[] = [],\n): boolean {\n if (!event.key.startsWith(\"Arrow\")) return false;\n return (\n (event.altKey && !allow.includes(\"alt\")) \|\|\n (event.ctrlKey && !allow.includes(\"ctrl\")) \|\|\n (event.metaKey && !allow.includes(\"meta\")) \|\|\n (event.shiftKey && !allow.includes(\"shift\"))\n );\n}\n\n/\n True when a press arrived carrying any modifier, for the keys the browser and\n * the OS own outright: return without calling `preventDefault()` and without\n * moving any state.\n \n `Control+Home` and `Control+End` jump the document to its ends, and a widget\n * that swallows them makes the shortcut work or not depending on where focus\n * happens to sit. {@link isReservedArrowChord} answers the same question for the\n * arrows, but returns `false` for every other key so that this one can decide.\n \n There is no `allow` list here on purpose. APG assigns no modifier chord to\n * `Home`/`End`, so a widget that wanted one would be claiming a combination the\n * pattern never gave it.\n \n @example\n * ```ts\n * case \"Home\":\n * case \"End\":\n * if (hasModifierChord(event)) return;\n * ```\n /\nexport function hasModifierChord(event: KeyboardEvent): boolean {\n return event.altKey \|\| event.ctrlKey \|\| event.metaKey \|\| event.shiftKey;\n}\n","/\n Resolves which of a controller's elements owns a node.\n \n A delegated listener hears events from a whole subtree, so the handler's first\n * job is almost always the same question: which item, handle, or control does\n * this `event.target` belong to? The same question comes up for a\n * `MutationRecord.target`, for `document.activeElement`, and for a\n * `relatedTarget` on the way out of a hover region.\n \n The answer is `Node.contains()`, which is inclusive — an element contains\n * itself — so testing the candidate for identity as well would be redundant.\n \n The guard is what makes this safe to call with a raw event target.\n * `event.target` is typed `EventTarget \| null`, and `contains()` takes a `Node?`:\n * browsers throw `TypeError` for anything else, and `window` — the everyday\n * `EventTarget` that is not a `Node` — is what an event dispatched at it carries.\n * Narrowing here means a caller never has to cast, and the rule cannot drift\n * between the places that ask the question.\n \n Scope stays with the caller. These helpers say which candidate owns the node,\n * not whether the node belongs to this controller at all — a component with\n * nested instances of itself decides that first (by comparing the closest\n * annotated ancestor) and passes the candidates it owns.\n /\n\n/\n Index in `candidates` of the first one that is, or contains, `node`.\n \n `-1` when none does, when `node` is absent, and when it is an `EventTarget`\n * that is not a `Node`. Candidates are tested in array order, so a nested pair\n * resolves to whichever the caller listed first.\n /\nexport function ownerIndex<T extends Element>(\n candidates: readonly T[],\n node: EventTarget \| null \| undefined,\n): number {\n if (!(node instanceof Node)) return -1;\n return candidates.findIndex((candidate) => candidate.contains(node));\n}\n\n/\n The first candidate that is, or contains, `node`; `null` when none does.\n \n A miss indexes the array at `-1`, which reads as `undefined` and lands on the\n * same `null` the absent cases produce.\n /\nexport function ownerOf<T extends Element>(\n candidates: readonly T[],\n node: EventTarget \| null \| undefined,\n): T \| null {\n return candidates[ownerIndex(candidates, node)] ?? null;\n}\n","/\n Whether a disabled `<fieldset>` ancestor actually reaches `control`.\n \n HTML exempts the contents of a fieldset's first direct-child `<legend>`, and\n * the exemption is per fieldset — a control legal in one legend can still be\n * disabled by a second, outer fieldset, so the walk continues upward.\n \n Exported on its own for callers that need the disabled-inheritance rule without\n * the rest of {@link canTakeFocus} — a control's availability check, or a `hidden`\n * walk bounded at a widget root, which is a different rule to compose with.\n /\nexport function inheritsFieldsetDisabled(control: HTMLElement): boolean {\n let fieldset: Element \| null = control.closest(\"fieldset[disabled]\");\n while (fieldset) {\n const legend = Array.from(fieldset.children).find((child) => child.tagName === \"LEGEND\");\n if (!legend?.contains(control)) return true;\n fieldset = fieldset.parentElement?.closest(\"fieldset[disabled]\") ?? null;\n }\n return false;\n}\n\n/\n Whether an element can actually take focus, checked before `focus()` runs.\n \n A controller that must move focus off a control it is about to disable or hide\n * picks a destination and calls `focus()` on it. If that destination cannot take\n * focus, the call fails silently: `hidden` and natively `disabled` elements\n * swallow it, so the caret stays in the subtree that is disappearing and lands on\n * `<body>` a frame later — the exact outcome the rescue exists to prevent, minus\n * any signal that it happened.\n \n Testing after the fact is the obvious alternative and is deliberately not the\n * rule. Reading `document.activeElement` back only works in a real browser, and\n * looping over candidates that way performs a real focus move per failure —\n * observable to assistive technology. Checking first costs nothing and catches\n * the cases that actually occur.\n \n `aria-disabled` is not disqualifying. It is the attribute an author uses\n * for a control that must stay discoverable, and the roving contract keeps\n * such items reachable. Only the four conditions that make the platform refuse\n * focus are checked: `hidden` / `inert` (an ancestor's counts),\n * `input[type=\"hidden\"]`, the native `disabled` property, and `disabled`\n * inherited from an ancestor `fieldset`. CSS-only invisibility is handled by\n * {@link isRenderedForFocus} when a consumer needs sequential-focus semantics.\n \n Reading `:disabled` instead of walking the fieldset chain would be shorter, but\n * that pseudo-class is not evaluated consistently outside real browsers and this\n * has to be right headlessly too. happy-dom in particular focuses a `<button>`\n * inside a disabled fieldset where a real engine refuses, so the inheritance is\n * spelled out rather than delegated.\n \n What a consumer does when nothing survives is its own call: some fall back to\n * their landmark, while a widget whose caret already sits somewhere legitimate\n * refuses the move outright rather than relocating it.\n \n @example\n * ```ts\n * const target = candidates.find(canTakeFocus);\n * if (target) target.focus();\n * else {\n * this.#tabindex.lend(this.element); // nothing left: fall back to the landmark\n * this.element.focus();\n * }\n * ```\n \n @param element - the candidate destination\n /\nexport function canTakeFocus(element: HTMLElement): boolean {\n if (element.closest(\"[hidden], [inert]\")) return false;\n if (element instanceof HTMLInputElement && element.type === \"hidden\") return false;\n if (!(\"disabled\" in element)) return true;\n if ((element as HTMLElement & { disabled: boolean }).disabled) return false;\n return !inheritsFieldsetDisabled(element);\n}\n\n/* Elements whose semantics or authored attributes can place them in sequential focus order. /\nexport const TAB_STOP_CANDIDATE_SELECTOR = [\n \"a[href]\",\n \"area[href]\",\n \"button\",\n \"input\",\n \"select\",\n \"textarea\",\n \"summary\",\n \"iframe\",\n \"audio[controls]\",\n \"video[controls]\",\n \"[tabindex]\",\n \"[contenteditable]\",\n].join(\",\");\n\n/* Optional browser visibility API used to exclude CSS-hidden candidates. /\ninterface VisibilityCheckable {\n checkVisibility?: (options?: { visibilityProperty?: boolean }) => boolean;\n}\n\n/* Whether CSS visibility allows an otherwise eligible element to participate in focus order. /\nexport function isRenderedForFocus(element: HTMLElement): boolean {\n const check = (element as HTMLElement & VisibilityCheckable).checkVisibility;\n return typeof check === \"function\" ? check.call(element, { visibilityProperty: true }) : true;\n}\n\n/* Parses an authored `tabindex`; invalid syntax has no explicit focus-order meaning. /\nfunction authoredTabindex(element: HTMLElement): number \| null {\n const value = element.getAttribute(\"tabindex\");\n if (value === null \|\| !/^[+-]?\\d+$/.test(value.trim())) return null;\n return Number(value);\n}\n\n/* Whether the element's native semantics place it in sequential focus order. /\nfunction hasNativeTabStop(element: HTMLElement): boolean {\n if (element instanceof HTMLAnchorElement \|\| element instanceof HTMLAreaElement) {\n return element.hasAttribute(\"href\");\n }\n if (\n element instanceof HTMLButtonElement \|\|\n element instanceof HTMLSelectElement \|\|\n element instanceof HTMLTextAreaElement\n ) {\n return true;\n }\n if (element instanceof HTMLInputElement) return element.type !== \"hidden\";\n if (element instanceof HTMLIFrameElement) return true;\n if (element.tagName === \"AUDIO\" \|\| element.tagName === \"VIDEO\") {\n return element.hasAttribute(\"controls\");\n }\n if (element instanceof HTMLElement && element.tagName === \"SUMMARY\") {\n const details = element.parentElement;\n return (\n details instanceof HTMLDetailsElement &&\n Array.from(details.children).find((child) => child.tagName === \"SUMMARY\") === element\n );\n }\n return false;\n}\n\n/* Whether an explicit `contenteditable` value creates an editable tab stop. /\nfunction hasEditableTabStop(element: HTMLElement): boolean {\n const value = element.getAttribute(\"contenteditable\")?.toLowerCase();\n return value === \"\" \|\| value === \"true\" \|\| value === \"plaintext-only\";\n}\n\n/\n Whether an element is a usable sequential Tab stop right now.\n \n Native semantics, authored `tabindex`, editable hosts, inherited disabled state,\n * HTML `hidden`/`inert`, and CSS visibility are evaluated together. `aria-disabled`\n * remains focusable because it communicates unavailability without removing the\n * control from discovery order.\n /\nexport function isTabStop(element: HTMLElement): boolean {\n if (!canTakeFocus(element) \|\| !isRenderedForFocus(element)) return false;\n\n const tabindex = authoredTabindex(element);\n if (tabindex !== null) return tabindex >= 0;\n return hasNativeTabStop(element) \|\| hasEditableTabStop(element);\n}\n\n/* Returns every usable sequential Tab stop below `root` in document order. /\nexport function tabStopsWithin(root: ParentNode): HTMLElement[] {\n return Array.from(root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)).filter(\n isTabStop,\n );\n}\n\n/* Returns the first usable sequential Tab stop below `root`, if one exists. /\nexport function firstTabStop(root: ParentNode): HTMLElement \| null {\n for (const candidate of root.querySelectorAll<HTMLElement>(TAB_STOP_CANDIDATE_SELECTOR)) {\n if (isTabStop(candidate)) return candidate;\n }\n return null;\n}\n\n/* Whether `root` contains at least one usable sequential Tab stop. /\nexport function hasTabStop(root: ParentNode): boolean {\n return firstTabStop(root) !== null;\n}\n","/\n Collapses many Stimulus lifecycle callbacks from one DOM mutation into a\n * single pass.\n \n Stimulus fires `<name>TargetConnected` / `Disconnected` once per element and\n * `<name>ValueChanged` once per changed attribute. Replacing a list of N options\n * or morphing several render Values therefore delivers N callbacks — but the\n * useful unit of work is \"reconcile against the resulting declarative input\",\n * once, after the batch has settled. Every controller with reconcilable targets\n * or render Values needs the same shape: a `queued` flag plus `queueMicrotask`.\n \n A microtask is the right horizon, and the reason is specific. Stimulus\n * drives these callbacks from a `MutationObserver`, whose own callback already\n * runs as a microtask with the whole batch in hand; scheduling one more lands\n * after the last sibling callback of that batch and still before paint or any\n * event handler. A timer would be later than it needs to be, and reconciling\n * synchronously would run once per element against a half-applied DOM.\n \n The two guards are not the same guard. Scheduling is refused before the\n * controller connects, and running is refused after it disconnects:\n \n - Before `connect()` — Stimulus delivers initial target and Value callbacks\n * ahead of `connect()`. Reconciling there would compute output against a\n * controller whose own state has not been initialised, and `connect()` is\n * about to do a full pass anyway.\n * - After `disconnect()` — Stimulus fires a callback for every target\n * during teardown, and a microtask queued just before it would otherwise run\n * against a detached tree. {@link MicrotaskCoalescer.cancel} exists for the\n * teardown path to drop the pending pass outright.\n \n Both guards are part of one contract here rather than something each consumer\n * has to remember separately.\n \n Scope is the scheduling only. What to reconcile — keep the surviving active\n * option, fall back to the next / previous / first visible one, rebuild derived\n * chips or hidden fields — stays in the controller, because no two consumers\n * answer it the same way.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n \n @example\n * ```ts\n * readonly #reconcile = new MicrotaskCoalescer(() => this.#reconcileOptions());\n \n connect() { this.#reconcile.activate(); }\n * disconnect() { this.#reconcile.cancel(); }\n \n optionTargetConnected() { this.#reconcile.schedule(); }\n * optionTargetDisconnected() { this.#reconcile.schedule(); }\n * ```\n /\nexport class MicrotaskCoalescer {\n readonly #run: () => void;\n #queued = false;\n #active = false;\n #generation = 0;\n\n /* @param run - the single reconciliation pass, invoked at most once per batch. /\n constructor(run: () => void) {\n this.#run = run;\n }\n\n /* Opens the window in which {@link schedule} is honoured; call from `connect()`. /\n activate(): void {\n this.#active = true;\n }\n\n /* Closes the window and drops any pending pass; call from `disconnect()`. /\n cancel(): void {\n this.#active = false;\n this.#queued = false;\n this.#generation += 1;\n }\n\n /* Requests one pass after the batch settles. Idempotent; inert outside the window. /\n schedule(): void {\n if (!this.#active \|\| this.#queued) return;\n this.#queued = true;\n const generation = this.#generation;\n queueMicrotask(() => {\n // A cancelled callback must not consume a pass queued after reconnect.\n if (generation !== this.#generation \|\| !this.#queued \|\| !this.#active) return;\n this.#queued = false;\n this.#run();\n });\n }\n}\n","/\n Low-level roving-tabindex primitive shared by composite-widget controllers.\n \n The APG roving-tabindex pattern keeps a composite widget a single Tab stop:\n * exactly one item is in the Tab sequence (`tabindex=\"0\"`) while the rest are\n * removed from it (`tabindex=\"-1\"`), and the arrow keys move both DOM focus and\n * that single tabbable position together. {@link RovingTabindex} owns only that\n * mechanical bookkeeping — \"which one item is tabbable, and move focus there\".\n \n It is intentionally policy-free. Orientation, wrapping vs. clamping,\n * selection-follows-focus, typeahead, and `Home`/`End` semantics differ per APG\n * pattern (Radio Group, Toolbar, Rating, …); folding them into one helper would\n * flatten those widgets to a lowest common denominator and lose each pattern's\n * correctness. Those decisions therefore stay in each controller, which calls\n * {@link RovingTabindex.setActive} with an index it computed itself (optionally\n * via the pure {@link rovingMove} helper).\n \n @remarks\n * Items are read lazily through a getter so a controller can add or remove\n * targets (Stimulus re-scans the DOM) without re-wiring this helper. A caller\n * that already captured one event-scoped snapshot may pass it to\n * {@link RovingTabindex.setActive}, avoiding a second live-target scan while\n * preserving one coherent collection for the whole operation.\n /\nexport class RovingTabindex {\n /* Returns the current ordered item elements; called on every operation. /\n readonly #getItems: () => HTMLElement[];\n\n /\n @param getItems - Returns the current ordered item elements. Called on every\n * operation so the live target list is always used.\n /\n constructor(getItems: () => HTMLElement[]) {\n this.#getItems = getItems;\n }\n\n /* Index of the currently tabbable item (`tabindex=\"0\"`), or `-1` if none. /\n get activeIndex(): number {\n return this.#getItems().findIndex((item) => item.tabIndex === 0);\n }\n\n /\n Makes exactly the item at `index` tabbable (`tabindex=\"0\"`) and removes every\n * other item from the Tab sequence (`tabindex=\"-1\"`). An out-of-range `index`\n * (e.g. `-1`) leaves all items at `-1`, which a controller can use to express\n * \"nothing is currently tabbable\".\n \n @param index - Position of the item to make tabbable.\n * @param options - Pass `{ focus: true }` to also move DOM focus to that item,\n * and `items` to reuse an event-scoped collection snapshot.\n /\n setActive(\n index: number,\n options: { focus?: boolean; items?: readonly HTMLElement[] } = {},\n ): void {\n const { focus = false } = options;\n const items = options.items ?? this.#getItems();\n items.forEach((item, i) => {\n item.tabIndex = i === index ? 0 : -1;\n });\n if (focus) items[index]?.focus();\n }\n}\n\n/* Edge behavior for {@link rovingMove}: cycle past the ends, or stop at them. /\nexport type RovingWrap = \"wrap\" \| \"clamp\";\n\n/\n Pure helper that resolves the target index for a one-step directional move.\n \n Keyboard/orientation mapping stays in the caller: it decides that a key means\n * `delta` `+1` (next) or `-1` (previous) and whether the widget should `\"wrap\"`\n * (Radio Group, Toolbar) or `\"clamp\"` at the ends.\n \n @param current - The index focus is moving from.\n * @param length - Number of items in the set.\n * @param delta - `+1` to move to the next item, `-1` for the previous.\n * @param wrap - `\"wrap\"` cycles around the ends; `\"clamp\"` stops at them.\n * @returns The resolved index, or `-1` when there are no items.\n /\nexport function rovingMove(\n current: number,\n length: number,\n delta: number,\n wrap: RovingWrap,\n): number {\n if (length === 0) return -1;\n const next = current + delta;\n if (wrap === \"wrap\") return (next + length) % length;\n return Math.min(length - 1, Math.max(0, next));\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { hasModifierChord, isReservedArrowChord } from \"../utils/arrow_step\";\nimport { ownerIndex } from \"../utils/event_owner\";\nimport { inheritsFieldsetDisabled } from \"../utils/focus_candidate\";\nimport { isRtl } from \"../utils/logical_scroll\";\nimport { MicrotaskCoalescer } from \"../utils/microtask_coalescer\";\nimport { RovingTabindex, type RovingWrap, rovingMove } from \"../utils/roving_tabindex\";\n\n/* Attributes that change whether an item can hold the Tab stop. /\nconst STATE_ATTRIBUTES = [\"disabled\", \"hidden\"];\n\n/\n Headless roving tabindex: makes a set of `item`s a single Tab stop and\n * moves focus between them with the arrow keys — the APG roving-tabindex\n * technique, surfaced as a standalone controller. It is the policy layer over the\n * shared `RovingTabindex` util (the same split `stimeo--focus` makes over its trap),\n * giving the orientation / wrap / Home-End the util deliberately leaves out. No\n * dedicated APG pattern; it is the keyboard primitive Toolbar / Menu / Radio Group\n * and friends build on. Core (zero dependencies).\n \n Markup contract (identifier: `stimeo--roving`):\n * <div data-controller=\"stimeo--roving\"\n * data-stimeo--roving-orientation-value=\"horizontal\">\n * <button data-stimeo--roving-target=\"item\">A</button>\n * <button data-stimeo--roving-target=\"item\">B</button>\n * <button data-stimeo--roving-target=\"item\">C</button>\n * </div>\n \n Exactly one item is tabbable (`tabindex=\"0\"`); the arrow keys (per\n * `orientation`) move focus and that tab stop together, `Home`/`End` jump to the\n * ends (`homeEnd`), and `wrap` cycles past the ends or clamps at them. Listeners\n * are delegated on the container — `keydown` for movement and `focusin` to\n * sync the tab stop when focus arrives by click or programmatically — so\n * dynamically added/removed items need no per-item `data-action`. It emits\n * `change` when a key press or an incoming focus moves the tabbable item; connect\n * and target reconciliation re-establish the tab stop silently.\n \n Items that cannot take focus — `hidden` (their own attribute or a wrapper's up\n * to the container) and natively `disabled`, including through a disabled\n * `fieldset` — are neither move targets nor tab-stop candidates: the lone\n * `tabindex=\"0\"` sitting on one would take the whole set out of the Tab sequence\n * while focus stayed behind. `aria-disabled` items stay reachable; suppressing\n * their activation belongs to the consuming pattern. A key that resolves to no\n * reachable item is left to the page (unlike Toolbar, which consumes it).\n \n `change` dispatches `{ index, item }`.\n \n @remarks\n * Behavior only: it owns `tabindex` and focus movement, nothing else. It does\n * not assign roles (`role=\"toolbar\"`/`\"radiogroup\"` is the author's), manage\n * selection / selection-follows-focus, typeahead, or activation (`Enter`/`Space`)\n * — those stay with the consuming pattern. `connect()` is idempotent: it keeps an\n * existing tab stop (reads it back from the DOM) and only defaults to the first\n * reachable item when none is set, so a Turbo cache restore / morph never resets\n * the user's position. Re-establishing the stop after a batch of item changes\n * follows DOM focus first, so an item added and focused in the same task keeps it;\n * `connect()` deliberately does not, because the authored DOM is what it reads\n * back. The delegated listeners and the state observer are torn down on\n * `disconnect()`.\n /\nexport class RovingController extends Controller<HTMLElement> {\n static override targets = [\"item\"];\n static override values = {\n orientation: { type: String, default: \"horizontal\" },\n wrap: { type: Boolean, default: true },\n homeEnd: { type: Boolean, default: true },\n };\n static events = [\"change\"] as const;\n\n declare readonly itemTargets: HTMLElement[];\n declare orientationValue: string;\n declare wrapValue: boolean;\n declare homeEndValue: boolean;\n\n readonly #roving = new RovingTabindex(() => this.itemTargets);\n readonly #reconcile = new MicrotaskCoalescer(() => this.#ensureTabStop(true));\n #connected = false;\n #observer: MutationObserver \| null = null;\n\n override connect(): void {\n // Establish the single tab stop from the DOM (source of truth): keep an\n // existing tabbable item, else default to the first. Silent — no change event\n // for the initial mount.\n this.#ensureTabStop(false);\n this.element.addEventListener(\"keydown\", this.#onKeydown);\n this.element.addEventListener(\"focusin\", this.#onFocusin);\n this.#watchState();\n this.#connected = true;\n this.#reconcile.activate();\n }\n\n override disconnect(): void {\n this.#connected = false;\n this.#reconcile.cancel();\n this.element.removeEventListener(\"keydown\", this.#onKeydown);\n this.element.removeEventListener(\"focusin\", this.#onFocusin);\n this.#observer?.disconnect();\n this.#observer = null;\n }\n\n /* Drops a runtime-added item from the Tab sequence before batch reconciliation. /\n itemTargetConnected(item: HTMLElement): void {\n if (!this.#connected) return;\n item.tabIndex = -1;\n this.#reconcile.schedule();\n }\n\n /* Re-establishes the single Tab stop after an item leaves the target set. /\n itemTargetDisconnected(): void {\n this.#reconcile.schedule();\n }\n\n /* Arrow keys move focus + the tab stop; Home/End jump to the ends. /\n readonly #onKeydown = (event: KeyboardEvent): void => {\n // A descendant widget that already claimed the key (e.g. a grabbed\n // `stimeo--pointer-drag` handle consuming arrows to move an item) must not\n // ALSO move the roving focus — composition depends on this yield.\n if (event.defaultPrevented) return;\n if (isReservedArrowChord(event)) return;\n // A key pressed to steer an IME candidate list belongs to the composition.\n if (event.isComposing) return;\n const current = this.#indexOf(event.target);\n if (current === -1) return;\n\n const wrap: RovingWrap = this.wrapValue ? \"wrap\" : \"clamp\";\n const orientation = this.orientationValue;\n const horizontal = orientation === \"horizontal\" \|\| orientation === \"both\";\n const vertical = orientation === \"vertical\" \|\| orientation === \"both\";\n\n // Logical, not physical. APG defines these as \"next / previous\n // control\", and says a vertical arrangement swaps in Down/Up for the same\n // meaning — so the pair is one axis's spelling of an order, and the order\n // reverses with the writing direction. Read from the controller element: the\n // container is what lays the items out, and a child may carry its own `dir`\n // (an LTR input inside an RTL form is ordinary authoring).\n // Only the horizontal pair reverses; `orientation=\"both\"` keeps Down/Up as-is.\n const rtl = horizontal && isRtl(this.element);\n const forwardKey = rtl ? \"ArrowLeft\" : \"ArrowRight\";\n const backwardKey = rtl ? \"ArrowRight\" : \"ArrowLeft\";\n\n let next: number;\n if ((horizontal && event.key === forwardKey) \|\| (vertical && event.key === \"ArrowDown\")) {\n next = this.#step(current, 1, wrap);\n } else if ((horizontal && event.key === backwardKey) \|\| (vertical && event.key === \"ArrowUp\")) {\n next = this.#step(current, -1, wrap);\n } else if (this.homeEndValue && (event.key === \"Home\" \|\| event.key === \"End\")) {\n // Chorded Home/End are the browser's document jumps; APG gives the widget\n // no modifier combination for them.\n if (hasModifierChord(event)) return;\n next = event.key === \"Home\" ? this.#firstReachable() : this.#lastReachable();\n } else {\n return;\n }\n\n if (next === -1) return;\n event.preventDefault();\n this.#activate(next, true);\n };\n\n /\n Syncs the single tab stop to an item that received focus by other means\n * (click, programmatic `focus()`), so returning via Tab lands on it. The\n * keyboard path's own `focus()` re-enters here but is a no-op (index unchanged).\n /\n readonly #onFocusin = (event: FocusEvent): void => {\n const index = this.#indexOf(event.target);\n if (index === -1 \|\| !this.#reachable(index)) return;\n this.#activate(index, false);\n };\n\n /* Resolves the item index owning an event target (the item or a descendant). /\n #indexOf(target: EventTarget \| null): number {\n return ownerIndex(this.itemTargets, target);\n }\n\n /* Makes `index` the tab stop (optionally focusing it), emitting `change` once. /\n #activate(index: number, focus: boolean): void {\n const previous = this.#roving.activeIndex;\n this.#roving.setActive(index, { focus });\n if (index !== previous) {\n this.dispatch(\"change\", { detail: { index, item: this.itemTargets[index] } });\n }\n }\n\n /\n Keeps the Tab stop on a reachable item.\n \n `followFocus` is on for re-establishment only: an item added and focused in\n * the same task has already claimed the stop through `focusin`, and the batch\n * that follows must not hand it back to the first item. `connect()` passes it\n * off so the authored DOM decides the initial stop. With nothing reachable the\n * DOM is left as it is — a group inside a collapsed region gets its stop back\n * when the region opens, instead of losing it for good.\n /\n #ensureTabStop(followFocus: boolean): void {\n const items = this.itemTargets;\n const focused = followFocus\n ? items.findIndex((item, i) => item === document.activeElement && this.#reachable(i))\n : -1;\n const active = this.#roving.activeIndex;\n const kept = active !== -1 && this.#reachable(active) ? active : -1;\n const index = focused !== -1 ? focused : kept !== -1 ? kept : this.#firstReachable();\n if (index === -1) return;\n this.#roving.setActive(index);\n }\n\n /\n Resolves the next reachable index in `delta`'s direction, honouring `wrap`.\n \n An arrow on the widget's own axis is the widget's to consume even when the\n * position does not change, so a clamped end resolves to the current item\n * rather than to nothing. An unreachable origin escapes to the first reachable\n * item instead of sitting in a dead end, and `-1` is left for the one case that\n * really is not ours: no reachable item anywhere.\n /\n #step(current: number, delta: number, wrap: RovingWrap): number {\n const length = this.itemTargets.length;\n let index = current;\n for (let taken = 0; taken < length; taken += 1) {\n const candidate = rovingMove(index, length, delta, wrap);\n if (candidate === index) break; // clamped at an end\n index = candidate;\n if (this.#reachable(index)) return index;\n }\n return this.#reachable(current) ? current : this.#firstReachable();\n }\n\n /* Index of the first reachable item, or `-1`. /\n #firstReachable(): number {\n return this.itemTargets.findIndex((_item, i) => this.#reachable(i));\n }\n\n /* Index of the last reachable item, or `-1`. /\n #lastReachable(): number {\n for (let i = this.itemTargets.length - 1; i >= 0; i -= 1) {\n if (this.#reachable(i)) return i;\n }\n return -1;\n }\n\n /\n Whether the item at `index` can hold the Tab stop and take focus.\n \n `aria-disabled` is deliberately not consulted: it keeps an item reachable and\n * only suppresses activation, which this part does not own.\n /\n #reachable(index: number): boolean {\n const item = this.itemTargets[index];\n if (!item) return false;\n if (this.#hidden(item)) return false;\n if (!(\"disabled\" in item)) return true;\n if ((item as HTMLElement & { disabled: boolean }).disabled) return false;\n return !inheritsFieldsetDisabled(item);\n }\n\n /\n Whether `item`, or anything between it and the container, is `hidden`.\n \n The walk stops at the container on purpose: a group inside a hidden region is\n * already out of the page's Tab order, and calling every item unreachable there\n * would drop the stop with nothing left to restore it — the ancestor lies\n * outside the subtree whose state attributes are watched.\n /\n #hidden(item: HTMLElement): boolean {\n let node: HTMLElement \| null = item;\n while (node && node !== this.element) {\n if (node.hasAttribute(\"hidden\")) return true;\n node = node.parentElement;\n }\n return false;\n }\n\n /\n Watches the attributes that decide reachability, so disabling the item that\n * holds the Tab stop hands it to another one instead of taking the whole set\n * out of the Tab sequence. An enclosing `fieldset` disables items from outside\n * the observed subtree, so each one's own `disabled` is watched too.\n */\n #watchState(): void {\n if (typeof MutationObserver === \"undefined\") return;\n const observer = new MutationObserver(() => this.#reconcile.schedule());\n observer.observe(this.element, {\n subtree: true,\n attributes: true,\n attributeFilter: STATE_ATTRIBUTES,\n });\n for (\n let fieldset = this.element.parentElement?.closest(\"fieldset\") ?? null;\n fieldset;\n fieldset = fieldset.parentElement?.closest(\"fieldset\") ?? null\n ) {\n observer.observe(fieldset, { attributes: true, attributeFilter: [\"disabled\"] });\n }\n this.#observer = observer;\n }\n}\n"]}

package/dist/controllers/scroll_visibility_controller.d.ts CHANGED Viewed

@@ -12,7 +12,7 @@ import { Controller } from '@hotwired/stimulus';
  *        data-stimeo--scroll-visibility-mode-value="offset">
  *     <button type="button" hidden
  *             data-stimeo--scroll-visibility-target="element"
- *             data-action="stimeo--scroll-visibility#toTop">Back to top</button>
+ *             data-action="click->stimeo--scroll-visibility#toTop">Back to top</button>
  *   </div>
  *
  * In `offset` mode the element is shown once the scroll source is scrolled past

package/dist/controllers/scroll_visibility_controller.js CHANGED Viewed

@@ -57,6 +57,26 @@ var BlurDeferral = class {
   }
 };
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function validSelector(element, raw, fallback) {
+  if (raw.length === 0) return fallback;
+  return parseDeclared(
+    raw,
+    (selector) => {
+      element.matches(selector);
+      return selector;
+    },
+    fallback
+  );
+}
 // src/utils/reduced_motion.ts
 function prefersReducedMotion() {
   return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
@@ -223,11 +243,11 @@ var ScrollVisibilityController = class extends Controller {
   }
   /** Validates `root` once so connect never parses a selector that throws. */
   rootValueChanged() {
-    this.#rootSelector = this.#validSelector(this.rootValue);
+    this.#rootSelector = validSelector(this.element, this.rootValue, "");
   }
   /** Validates `focusSelector` once so `toTop` never parses a selector that throws. */
   focusSelectorValueChanged() {
-    this.#focusSelector = this.#validSelector(this.focusSelectorValue);
+    this.#focusSelector = validSelector(this.element, this.focusSelectorValue, "");
   }
   /** Scrolls the source to the top and, optionally, moves focus to a safe target. */
   toTop() {
@@ -299,17 +319,6 @@ var ScrollVisibilityController = class extends Controller {
     if (focused instanceof HTMLElement && this.elementTarget.contains(focused)) return focused;
     return null;
   }
-  /** Returns `declared` when it parses as a selector, and `""` when it does not. */
-  #validSelector(declared) {
-    if (declared.length > 0) {
-      try {
-        this.element.matches(declared);
-        return declared;
-      } catch {
-      }
-    }
-    return "";
-  }
   #scrollY() {
     if (this.#scrollSource === window) {
       return window.scrollY ?? window.pageYOffset ?? 0;

package/dist/controllers/scroll_visibility_controller.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../../src/utils/blur_deferral.ts","../../src/utils/reduced_motion.ts","../../src/utils/before_cache_reset.ts","../../src/utils/tabindex_loan.ts","../../src/controllers/scroll_visibility_controller.ts"],"names":[],"mappings":"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","file":"scroll_visibility_controller.js","sourcesContent":["/*\n Shared bookkeeping for updates that must wait until an element loses focus.\n \n A control that becomes redundant while the user is standing on it cannot be\n * removed from the page immediately: hiding a focused element (or turning it\n * into a native `disabled` one) drops focus to `<body>`, stranding a keyboard\n * user mid-widget. The fix every affected controller reached for is the same —\n * keep the element reachable, hold the destructive update, listen for `blur`,\n * and apply it then.\n \n {@link BlurDeferral} owns only the registry part of that: which elements are\n * currently holding an update back, attaching and detaching the `blur` listener,\n * and guaranteeing teardown. It is deliberately policy-free — what the\n * interim state looks like (`aria-disabled`, an ownership marker, nothing at\n * all), and what the deferred update actually is, stay in the controller, which\n * receives the element back through its release callback.\n \n Three contracts are worth stating up front, because each one is a hazard the\n * consumers would otherwise hit:\n \n - The release callback fires only on a real `blur`. `release()` /\n * `releaseAll()` cancel a deferral; they do not complete it. Conflating the\n * two makes `overflow-indicator` disable a button that just left the boundary.\n * - `elements` is a snapshot. Iterating the live key set while releasing\n * inside the loop is the failure this registry exists to prevent.\n * - The entry is detached before the callback runs, so a controller that\n * decides the update is still unsafe can simply defer again.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and contracts belong on the members.\n \n @example\n * ```ts\n * readonly #deferred = new BlurDeferral<HTMLElement>((trigger) => {\n * if (this.#connected) this.#evaluate();\n * });\n \n #hide(trigger: HTMLElement) {\n * if (document.activeElement === trigger) {\n * this.#deferred.deferOnly(trigger); // stays visible until blur\n * return;\n * }\n * this.#deferred.releaseAll();\n * trigger.hidden = true;\n * }\n \n disconnect() {\n * this.#deferred.releaseAll();\n * }\n * ```\n /\nexport class BlurDeferral<T extends HTMLElement = HTMLElement> {\n /* Elements currently holding an update back, mapped to their `blur` listener. /\n readonly #pending = new Map<T, () => void>();\n /* Called after a pending element blurs and has been detached. /\n readonly #onRelease: (element: T) => void;\n\n /* @param onRelease - Invoked once `element` actually blurs; never on `release`. /\n constructor(onRelease: (element: T) => void) {\n this.#onRelease = onRelease;\n }\n\n /* Number of elements currently holding an update back. /\n get size(): number {\n return this.#pending.size;\n }\n\n /* Snapshot of the pending elements, safe to iterate while releasing them. /\n get elements(): T[] {\n return [...this.#pending.keys()];\n }\n\n /* Whether `element` is currently holding an update back. /\n has(element: T): boolean {\n return this.#pending.has(element);\n }\n\n /* Holds an update back until `element` blurs. Idempotent (no stacked listeners). /\n defer(element: T): void {\n if (this.#pending.has(element)) return;\n const onBlur = (): void => {\n this.#detach(element);\n this.#onRelease(element);\n };\n this.#pending.set(element, onBlur);\n element.addEventListener(\"blur\", onBlur);\n }\n\n /* Defers `element` as the only pending entry, cancelling any others. /\n deferOnly(element: T): void {\n for (const pending of this.elements) {\n if (pending !== element) this.#detach(pending);\n }\n this.defer(element);\n }\n\n /* Cancels `element`'s deferral without completing it; no-ops when not pending. /\n release(element: T): void {\n this.#detach(element);\n }\n\n /* Cancels every deferral without completing any of them. /\n releaseAll(): void {\n for (const element of this.elements) this.#detach(element);\n }\n\n /* Removes the `blur` listener for `element` and forgets it. /\n #detach(element: T): void {\n const onBlur = this.#pending.get(element);\n if (onBlur) element.removeEventListener(\"blur\", onBlur);\n this.#pending.delete(element);\n }\n}\n","/\n Shared `prefers-reduced-motion` lookup for the motion-aware controllers\n .\n \n * This one-liner keeps the media query string and the environment guard\n * single-sourced across them. The preference is intentionally re-read on every\n * call — the controllers check it at each animation/scroll start (WCAG 2.2\n * 2.3.3), so flipping the OS setting takes effect immediately without any\n * listener or cache bookkeeping here.\n /\n\n/\n Whether the user currently requests reduced motion.\n \n @returns `true` when `(prefers-reduced-motion: reduce)` matches; `false`\n * otherwise, including environments without `window.matchMedia` (treated as\n * \"no preference\").\n /\nexport function prefersReducedMotion(): boolean {\n return (\n typeof window.matchMedia === \"function\" &&\n window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches\n );\n}\n","/\n Runs a controller's \"return to the initial state\" pass just before Turbo\n * caches the page.\n \n `disconnect()` cannot do this job, for two independent reasons. Turbo\n * queues the clone from this event rather than taking it here, and the body swap\n * that runs the controller's `disconnect()` is queued separately — so which of\n * the two lands first is not something a controller can rely on, and a rewind\n * written in `disconnect()` may reach only the DOM being thrown away. In the\n * other direction, `disconnect()` also fires on an in-page move (Stimulus tears\n * down and reconnects the same element), where rewinding would wipe a\n * legitimately in-progress interaction — a spinner mid-load would vanish. One\n * timing is unreliable, the other is too eager; `turbo:before-cache` is the only\n * point that is exactly \"the page is about to be frozen\".\n \n Scope is the subscription only: registering on `activate()`, unregistering on\n * `deactivate()`, and one shared document listener no matter how many instances\n * are live. What to return to its initial state — which `data-state`, which\n * `hidden`, which `aria-busy` — stays in the controller, because no two\n * consumers answer it the same way.\n \n Rewind state, not appearance. The pass writes attributes the controller\n * itself owns; the visual result of those attributes is the consumer's CSS, and\n * a library that reached for style or class names would be guessing at markup\n * it does not own.\n \n Both entry points are idempotent, so the lifecycle hooks can call them\n * unconditionally: a second `activate()` does not double-subscribe and does not\n * make the callback run twice, and `deactivate()` on an instance that never\n * subscribed is a no-op.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n \n @example\n * ```ts\n * readonly #beforeCache = new BeforeCacheReset(() => this.#rewind());\n \n connect() { this.#beforeCache.activate(); }\n * disconnect() { this.#beforeCache.deactivate(); }\n * ```\n /\nexport class BeforeCacheReset {\n /* Every subscribed instance, iterated by the one shared document listener. /\n static readonly #subscribers = new Set<BeforeCacheReset>();\n\n /* The shared listener; installed while at least one instance is subscribed. /\n static readonly #onBeforeCache = (): void => {\n for (const subscriber of BeforeCacheReset.#subscribers) subscriber.#rewind();\n };\n\n readonly #rewind: () => void;\n\n /* @param rewind - the pass that returns this controller's state to its initial form. /\n constructor(rewind: () => void) {\n this.#rewind = rewind;\n }\n\n /* Subscribes to `turbo:before-cache`; call from `connect()`. Idempotent. /\n activate(): void {\n const first = BeforeCacheReset.#subscribers.size === 0;\n BeforeCacheReset.#subscribers.add(this);\n if (first) {\n document.addEventListener(\"turbo:before-cache\", BeforeCacheReset.#onBeforeCache);\n }\n }\n\n /* Unsubscribes; call from `disconnect()`. Safe when never subscribed. /\n deactivate(): void {\n BeforeCacheReset.#subscribers.delete(this);\n if (BeforeCacheReset.#subscribers.size > 0) return;\n document.removeEventListener(\"turbo:before-cache\", BeforeCacheReset.#onBeforeCache);\n }\n}\n","import { BeforeCacheReset } from \"./before_cache_reset\";\n\n/\n Shared bookkeeping for a `tabindex` a controller lends an element temporarily.\n \n A controller that must move focus somewhere the author never made focusable\n * (a landmark root, a scroll destination) reaches for the same trick: add a\n * `tabindex` just-in-time and hand it back once it is no longer needed. The\n * borrow is the easy half; the return is what the two conditions below are for.\n \n Returning needs two conditions, not one. Owning the borrow is not enough:\n * the attribute must also still hold the value this instance wrote. A consumer\n * that changed it afterwards — `tabindex=\"0\"` to make the root its own Tab stop\n * — owns it now, and removing it there silently discards authored markup. The\n * bookkeeping is dropped either way, since the loan is over regardless of who\n * ends up owning the value.\n \n Never borrow over an existing value. An element that already carries a\n * `tabindex` is the author's to control, so there is nothing to lend and nothing\n * to return.\n \n Every live loan also owns a shared `turbo:before-cache` subscription. The loan\n * is returned before Turbo can copy it into a snapshot, so consumers get cache\n * safety without duplicating a lifecycle hook; `returnAll()` removes the\n * subscription again as soon as no loan remains.\n \n The registry is keyed by element, so a controller borrowing on a single\n * element (`this.element`) and one borrowing across a changing set of targets\n * use the same API — the single-element case is a set of one. It holds no\n * opinion about when to borrow or where focus goes next; that stays in the\n * controller.\n \n The API is deliberately two methods. This file's own doc block is dropped\n * from `dist`, but every member comment is inlined into each consumer entry\n * (`tsup` builds with `splitting: false`), so rationale belongs here, only the\n * contract belongs on the members, and every method no consumer calls is still\n * paid for once per consumer entry.\n \n @example\n * ```ts\n * readonly #tabindex = new TabindexLoan();\n \n #rescueFocus() {\n * this.#tabindex.lend(this.element);\n * this.element.focus();\n * }\n \n disconnect() {\n * this.#tabindex.returnAll();\n * }\n * ```\n /\nexport class TabindexLoan<T extends HTMLElement = HTMLElement> {\n readonly #value: string;\n readonly #lent = new Set<T>();\n /* Returns live loans before Turbo can copy them into its page snapshot. /\n readonly #beforeCache = new BeforeCacheReset(() => this.returnAll());\n\n /\n @param value - the `tabindex` to lend. `\"-1\"` (the default) is\n * programmatically focusable but not a Tab stop; `\"0\"` is a real Tab stop,\n * which a scroll region with no focusable content of its own needs.\n /\n constructor(value: string = \"-1\") {\n this.#value = value;\n }\n\n /* Lends `element` the value; no-ops when it already carries a `tabindex`. /\n lend(element: T): void {\n if (element.hasAttribute(\"tabindex\")) return;\n element.setAttribute(\"tabindex\", this.#value);\n this.#lent.add(element);\n // Subscribe only while a real loan exists. Keeping this guarantee here means\n // every consumer is Turbo-safe without another lifecycle hook to remember.\n this.#beforeCache.activate();\n }\n\n /* Takes back every loan whose value is still the one that was lent. /\n returnAll(): void {\n for (const element of this.#lent) {\n if (element.getAttribute(\"tabindex\") === this.#value) element.removeAttribute(\"tabindex\");\n }\n this.#lent.clear();\n this.#beforeCache.deactivate();\n }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { BlurDeferral } from \"../utils/blur_deferral\";\nimport { prefersReducedMotion } from \"../utils/reduced_motion\";\nimport { TabindexLoan } from \"../utils/tabindex_loan\";\n\n/* Default scroll threshold in px, and what a non-finite declaration falls back to. /\nconst DEFAULT_OFFSET = 400;\n\n/\n Headless Scroll Visibility behavior: shows or hides an element based on\n * scroll amount or direction (back-to-top buttons, hide-on-scroll headers). No\n * dedicated APG pattern; when the element is a button it follows the Button\n * practice.\n \n Markup contract (identifier: `stimeo--scroll-visibility`):\n * <div data-controller=\"stimeo--scroll-visibility\"\n * data-stimeo--scroll-visibility-offset-value=\"400\"\n * data-stimeo--scroll-visibility-mode-value=\"offset\">\n * <button type=\"button\" hidden\n * data-stimeo--scroll-visibility-target=\"element\"\n * data-action=\"stimeo--scroll-visibility#toTop\">Back to top</button>\n * </div>\n \n In `offset` mode the element is shown once the scroll source is scrolled past\n * `offset` px; in `direction` mode it is hidden while scrolling down and shown\n * while scrolling up. A `scroll` that carries no vertical movement — a\n * horizontal scroll, an overscroll bounce — has no direction, so `direction`\n * mode leaves the current visibility alone. Visibility is reflected through the\n * `hidden` attribute (so a hidden control also leaves the focus order) and\n * `data-state`.\n \n By default the window is the scroll source. When the page itself does not\n * scroll — e.g. a fixed-height app shell whose main column scrolls in a container\n * (`overflow: auto`) — point `root` at that container (a CSS selector) so the\n * controller observes the element's scroll instead of the (never-scrolling)\n * window. `toTop` then scrolls that same container.\n \n `change` dispatches `{ visible: boolean }` on transitions only: connecting\n * reflects the current scroll state onto the hooks without announcing it, so a\n * Turbo restore does not replay the state the snapshot already carries.\n \n @remarks\n * Behavior only — the look and any transition are the consumer's CSS. The scroll\n * listener is `passive`, coalesced through `requestAnimationFrame`, and removed on\n * `disconnect()` (Turbo navigation included). `offset` / `mode` are re-read at\n * runtime, so a Turbo morph that swaps either attribute is followed without\n * waiting for the next scroll; a selector (`root`, `focusSelector`) or a\n * threshold that cannot be parsed reads as its default, keeping the rest of the\n * element alive. A scroll never hides the control while it owns focus: that\n * hide waits for it to blur and is decided again from the scroll position at that\n * moment. `toTop` honors `prefers-reduced-motion` by forcing an\n * instant jump independently of the consumer's CSS `scroll-behavior`, and can\n * move focus to a `focusSelector` target (given `tabindex=\"-1\"` if needed, and\n * focused without scrolling so the smooth scroll survives) to keep keyboard\n * users oriented after the scroll. A live disconnect removes only a\n * `tabindex=\"-1\"` this controller instance added; authored tabindex values\n * remain. This teardown does not claim to rewrite a Turbo cache snapshot that\n * was cloned before disconnect.\n /\nexport class ScrollVisibilityController extends Controller<HTMLElement> {\n static override targets = [\"element\"];\n static override values = {\n offset: { type: Number, default: DEFAULT_OFFSET },\n mode: { type: String, default: \"offset\" },\n focusSelector: { type: String, default: \"\" },\n root: { type: String, default: \"\" },\n };\n static actions = [\"toTop\"] as const;\n static events = [\"change\"] as const;\n\n declare readonly elementTarget: HTMLElement;\n declare readonly hasElementTarget: boolean;\n\n declare offsetValue: number;\n declare modeValue: string;\n declare focusSelectorValue: string;\n declare rootValue: string;\n\n /* Pending rAF id that coalesces scroll bursts into one measurement. /\n #rafId: number \| null = null;\n /* Previous scroll position, for `direction` mode delta detection. /\n #lastScrollY = 0;\n /* Current visibility, tracked to dispatch `change` only on real transitions. /\n #visible: boolean \| null = null;\n /\n The observed scroll source: a container element when `root` resolves, else\n * the window. Captured on connect so teardown detaches from the same source.\n /\n #scrollSource: HTMLElement \| Window = window;\n /\n Gates the declaration callbacks to the connected window.\n \n Stimulus delivers a Value callback ahead of `connect()` and again for every\n * runtime change; without the gate, merely connecting would evaluate — and\n * announce — before `connect()` runs its own first reflection.\n /\n #connected = false;\n /* Validated threshold; a non-finite declaration reads as the default. /\n #offset = DEFAULT_OFFSET;\n /* Validated `root` selector; an unparsable declaration reads as absent. /\n #rootSelector = \"\";\n /* Validated `focusSelector`; an unparsable declaration reads as absent. /\n #focusSelector = \"\";\n /* Focus targets this instance lent a `tabindex` to. /\n readonly #tabindex = new TabindexLoan();\n /\n The hide held back while the control itself owns focus.\n \n Completing the deferral re-runs the ordinary evaluation rather than applying\n * the stale decision: by the time focus leaves, the scroll position may have\n * moved back past the threshold.\n /\n readonly #pendingHide = new BlurDeferral((): void => {\n if (this.#connected) this.#evaluate();\n });\n\n readonly #onScroll = (): void => {\n if (this.#rafId !== null) return;\n this.#rafId = requestAnimationFrame(() => {\n this.#rafId = null;\n this.#evaluate();\n });\n };\n\n override connect(): void {\n this.#scrollSource = this.#resolveScrollSource();\n this.#lastScrollY = this.#scrollY();\n this.#scrollSource.addEventListener(\"scroll\", this.#onScroll, { passive: true });\n this.#evaluate(false);\n this.#connected = true;\n }\n\n override disconnect(): void {\n this.#connected = false;\n this.#scrollSource.removeEventListener(\"scroll\", this.#onScroll);\n if (this.#rafId !== null) {\n cancelAnimationFrame(this.#rafId);\n this.#rafId = null;\n }\n this.#pendingHide.releaseAll();\n this.#tabindex.returnAll();\n this.#visible = null;\n }\n\n /* Writes the current visibility onto a control that arrives after connect. /\n elementTargetConnected(element: HTMLElement): void {\n if (this.#visible !== null) element.hidden = !this.#visible;\n }\n\n /* Drops a held-back hide together with the control it was waiting on. /\n elementTargetDisconnected(): void {\n // At most one hide is ever held back, and it rides an element inside the\n // target — the focus owner, which may be a descendant rather than the\n // target itself. Losing the target ends that wait either way.\n this.#pendingHide.releaseAll();\n }\n\n /\n Validates `offset` once, then re-renders.\n \n Re-renders when application code (or a Turbo morph) changes `offset` at\n * runtime. A declaration that is not a finite number reads as the default, so\n * the comparison path never sees `NaN` — which would answer `false` to every\n * comparison and strand the element (in `direction` mode, even the guarantee\n * that the very top always reveals).\n /\n offsetValueChanged(): void {\n this.#offset = Number.isFinite(this.offsetValue) ? this.offsetValue : DEFAULT_OFFSET;\n if (this.#connected) this.#evaluate();\n }\n\n /* Re-renders when application code (or a Turbo morph) changes `mode` at runtime. /\n modeValueChanged(): void {\n if (this.#connected) this.#evaluate();\n }\n\n /* Validates `root` once so connect never parses a selector that throws. /\n rootValueChanged(): void {\n this.#rootSelector = this.#validSelector(this.rootValue);\n }\n\n /* Validates `focusSelector` once so `toTop` never parses a selector that throws. /\n focusSelectorValueChanged(): void {\n this.#focusSelector = this.#validSelector(this.focusSelectorValue);\n }\n\n /* Scrolls the source to the top and, optionally, moves focus to a safe target. /\n toTop(): void {\n const behavior: ScrollBehavior = prefersReducedMotion() ? \"instant\" : \"smooth\";\n this.#scrollSource.scrollTo({ top: 0, behavior });\n if (this.#focusSelector) {\n const target = document.querySelector<HTMLElement>(this.#focusSelector);\n if (target) {\n this.#tabindex.lend(target);\n // Focusing scrolls the target into view by default, which lands the page\n // instantly and discards the scroll above.\n target.focus({ preventScroll: true });\n }\n }\n }\n\n /\n Decides the next visibility from the current scroll state and applies it.\n \n @param notify - whether a transition announces itself. The reflection\n * `connect()` performs is the current state, not a change.\n \n @stimeoRenderRoot\n /\n #evaluate(notify = true): void {\n const y = this.#scrollY();\n let nextVisible: boolean;\n if (this.modeValue === \"direction\") {\n // Near the very top, always reveal so a hide-on-scroll header is never\n // stranded off-screen when the page cannot scroll up any further.\n if (y <= this.#offset) {\n nextVisible = true;\n } else if (y === this.#lastScrollY) {\n // No vertical movement carries no direction, so it decides nothing.\n return;\n } else {\n nextVisible = y < this.#lastScrollY; // scrolling up reveals, down hides\n }\n } else {\n nextVisible = y > this.#offset;\n }\n this.#lastScrollY = y;\n this.#setVisible(nextVisible, notify);\n }\n\n /* Applies visibility to the target, syncing `hidden`, `data-state`, `change`. /\n #setVisible(next: boolean, notify: boolean): void {\n if (next === this.#visible) return;\n const focused = !next && this.hasElementTarget ? this.#focusedWithin() : null;\n if (focused) {\n // Hiding the element that holds focus drops it to the document body,\n // stranding a keyboard user mid-interaction (WCAG 2.4.7 / 2.4.11). Hold\n // the hide until it blurs; the state stays what the user can still see.\n this.#pendingHide.deferOnly(focused);\n return;\n }\n this.#visible = next;\n if (this.hasElementTarget) this.elementTarget.hidden = !next;\n this.element.setAttribute(\"data-state\", next ? \"visible\" : \"hidden\");\n if (notify) this.dispatch(\"change\", { detail: { visible: next } });\n }\n\n /* Resolves the scroll source from `root` (falling back to the window). /\n #resolveScrollSource(): HTMLElement \| Window {\n if (this.#rootSelector) {\n const root = document.querySelector<HTMLElement>(this.#rootSelector);\n if (root) return root;\n }\n return window;\n }\n\n /\n The focus owner inside the target, or `null` when focus is elsewhere.\n \n `blur` does not bubble, so the deferral has to ride the focused element\n * itself: waiting on a container that never receives the event would hold the\n * hide forever.\n /\n #focusedWithin(): HTMLElement \| null {\n const focused = document.activeElement;\n if (focused instanceof HTMLElement && this.elementTarget.contains(focused)) return focused;\n return null;\n }\n\n /* Returns `declared` when it parses as a selector, and `\"\"` when it does not. */\n #validSelector(declared: string): string {\n if (declared.length > 0) {\n try {\n this.element.matches(declared);\n return declared;\n } catch {\n // Unparsable selector: fall through to the default below.\n }\n }\n return \"\";\n }\n\n #scrollY(): number {\n if (this.#scrollSource === window) {\n return window.scrollY ?? window.pageYOffset ?? 0;\n }\n return (this.#scrollSource as HTMLElement).scrollTop;\n }\n}\n"]}
1	+ {"version":3,"sources":["../../src/utils/blur_deferral.ts","../../src/utils/declared_value.ts","../../src/utils/reduced_motion.ts","../../src/utils/before_cache_reset.ts","../../src/utils/tabindex_loan.ts","../../src/controllers/scroll_visibility_controller.ts"],"names":[],"mappings":"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","file":"scroll_visibility_controller.js","sourcesContent":["/*\n Shared bookkeeping for updates that must wait until an element loses focus.\n \n A control that becomes redundant while the user is standing on it cannot be\n * removed from the page immediately: hiding a focused element (or turning it\n * into a native `disabled` one) drops focus to `<body>`, stranding a keyboard\n * user mid-widget. The fix every affected controller reached for is the same —\n * keep the element reachable, hold the destructive update, listen for `blur`,\n * and apply it then.\n \n {@link BlurDeferral} owns only the registry part of that: which elements are\n * currently holding an update back, attaching and detaching the `blur` listener,\n * and guaranteeing teardown. It is deliberately policy-free — what the\n * interim state looks like (`aria-disabled`, an ownership marker, nothing at\n * all), and what the deferred update actually is, stay in the controller, which\n * receives the element back through its release callback.\n \n Three contracts are worth stating up front, because each one is a hazard the\n * consumers would otherwise hit:\n \n - The release callback fires only on a real `blur`. `release()` /\n * `releaseAll()` cancel a deferral; they do not complete it. Conflating the\n * two makes `overflow-indicator` disable a button that just left the boundary.\n * - `elements` is a snapshot. Iterating the live key set while releasing\n * inside the loop is the failure this registry exists to prevent.\n * - The entry is detached before the callback runs, so a controller that\n * decides the update is still unsafe can simply defer again.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and contracts belong on the members.\n \n @example\n * ```ts\n * readonly #deferred = new BlurDeferral<HTMLElement>((trigger) => {\n * if (this.#connected) this.#evaluate();\n * });\n \n #hide(trigger: HTMLElement) {\n * if (document.activeElement === trigger) {\n * this.#deferred.deferOnly(trigger); // stays visible until blur\n * return;\n * }\n * this.#deferred.releaseAll();\n * trigger.hidden = true;\n * }\n \n disconnect() {\n * this.#deferred.releaseAll();\n * }\n * ```\n /\nexport class BlurDeferral<T extends HTMLElement = HTMLElement> {\n /* Elements currently holding an update back, mapped to their `blur` listener. /\n readonly #pending = new Map<T, () => void>();\n /* Called after a pending element blurs and has been detached. /\n readonly #onRelease: (element: T) => void;\n\n /* @param onRelease - Invoked once `element` actually blurs; never on `release`. /\n constructor(onRelease: (element: T) => void) {\n this.#onRelease = onRelease;\n }\n\n /* Number of elements currently holding an update back. /\n get size(): number {\n return this.#pending.size;\n }\n\n /* Snapshot of the pending elements, safe to iterate while releasing them. /\n get elements(): T[] {\n return [...this.#pending.keys()];\n }\n\n /* Whether `element` is currently holding an update back. /\n has(element: T): boolean {\n return this.#pending.has(element);\n }\n\n /* Holds an update back until `element` blurs. Idempotent (no stacked listeners). /\n defer(element: T): void {\n if (this.#pending.has(element)) return;\n const onBlur = (): void => {\n this.#detach(element);\n this.#onRelease(element);\n };\n this.#pending.set(element, onBlur);\n element.addEventListener(\"blur\", onBlur);\n }\n\n /* Defers `element` as the only pending entry, cancelling any others. /\n deferOnly(element: T): void {\n for (const pending of this.elements) {\n if (pending !== element) this.#detach(pending);\n }\n this.defer(element);\n }\n\n /* Cancels `element`'s deferral without completing it; no-ops when not pending. /\n release(element: T): void {\n this.#detach(element);\n }\n\n /* Cancels every deferral without completing any of them. /\n releaseAll(): void {\n for (const element of this.elements) this.#detach(element);\n }\n\n /* Removes the `blur` listener for `element` and forgets it. /\n #detach(element: T): void {\n const onBlur = this.#pending.get(element);\n if (onBlur) element.removeEventListener(\"blur\", onBlur);\n this.#pending.delete(element);\n }\n}\n","/\n Readers for the String Values whose text can only be checked by handing it to\n * a parser: a CSS selector, a regular-expression source, a JSON object.\n \n Stimulus reads each of them as an ordinary string, so the controller connects\n * and the flaw surfaces later, inside the first handler that consumes the value\n * (a `SyntaxError` from `new RegExp`, a `DOMException` from the selector engine),\n * where it takes the whole handler down on every event. Parsing here, once, in\n * the `<name>ValueChanged` callback keeps the failure local to the declaration:\n * an unreadable value falls back to its default, the element stays alive, and\n * the hot path only ever receives a value that parsed.\n \n Which default a broken declaration falls back to is the caller's contract, so\n * every reader takes (or returns) the fallback rather than choosing one.\n /\n\n/\n The result of `parse(raw)`, or `fallback` when `parse` throws.\n \n Any exception counts as \"does not parse\": the parsers these Values feed\n * (`RegExp`, `JSON.parse`, the selector engine) all report a malformed input by\n * throwing, and none of them throws for another reason.\n /\nexport function parseDeclared<T>(raw: string, parse: (raw: string) => T, fallback: T): T {\n try {\n return parse(raw);\n } catch {\n return fallback;\n }\n}\n\n/* What {@link validSelector} needs of the element it probes with. /\nexport interface SelectorProbe {\n matches(selector: string): boolean;\n}\n\n/\n `raw` when it is a non-empty selector the DOM accepts, otherwise `fallback`.\n \n `element.matches` is the probe: the engine parses the selector and throws for\n * one it cannot read. Whether the selector actually matches `element` plays no\n * part, so a selector aimed at another element still passes.\n \n The parameter names the one method the probe uses rather than `Element`, so\n * this module carries no DOM type and the readers below stay importable from\n * the Node-side Inspector, which checks the same declarations statically.\n /\nexport function validSelector(element: SelectorProbe, raw: string, fallback: string): string {\n if (raw.length === 0) return fallback;\n return parseDeclared(\n raw,\n (selector) => {\n element.matches(selector);\n return selector;\n },\n fallback,\n );\n}\n\n/* How `compileRegExp` wraps a source before compiling it. /\nexport type RegExpAnchor = \"none\" \| \"exact\";\n\n/\n `source` compiled as a `RegExp`, or `null` when it does not compile.\n \n `\"exact\"` wraps the source as `^(?:source)$`, so the whole input has to match\n * and an alternation inside the source cannot escape the anchors. The source is\n * compiled on its own first, because an unbalanced source can be made to parse\n * by the wrapper's own parentheses — `0)\|(1` becomes `^(?:0)\|(1)$` — which would\n * accept a declaration that is not a regular expression and leave half of it\n * outside the anchors. The default that replaces a broken source is the\n * caller's, so `null` is returned rather than a fallback pattern.\n /\nexport function compileRegExp(source: string, anchor: RegExpAnchor = \"none\"): RegExp \| null {\n return parseDeclared(\n source,\n (text) => {\n const bare = new RegExp(text);\n return anchor === \"exact\" ? new RegExp(`^(?:${text})$`) : bare;\n },\n null,\n );\n}\n\n/\n The JSON object `raw` declares, or `null` when the text does not parse or\n * parses to something other than a plain object (`null`, an array, a scalar).\n * Values are returned as parsed; narrowing them is the caller's contract.\n /\nexport function parseJsonObject(raw: string): Record<string, unknown> \| null {\n const parsed = parseDeclared<unknown>(raw, (text) => JSON.parse(text), null);\n if (parsed === null \|\| typeof parsed !== \"object\" \|\| Array.isArray(parsed)) return null;\n return parsed as Record<string, unknown>;\n}\n","/\n Shared `prefers-reduced-motion` lookup for the motion-aware controllers\n .\n \n * This one-liner keeps the media query string and the environment guard\n * single-sourced across them. The preference is intentionally re-read on every\n * call — the controllers check it at each animation/scroll start (WCAG 2.2\n * 2.3.3), so flipping the OS setting takes effect immediately without any\n * listener or cache bookkeeping here.\n /\n\n/\n Whether the user currently requests reduced motion.\n \n @returns `true` when `(prefers-reduced-motion: reduce)` matches; `false`\n * otherwise, including environments without `window.matchMedia` (treated as\n * \"no preference\").\n /\nexport function prefersReducedMotion(): boolean {\n return (\n typeof window.matchMedia === \"function\" &&\n window.matchMedia(\"(prefers-reduced-motion: reduce)\").matches\n );\n}\n","/\n Runs a controller's \"return to the initial state\" pass just before Turbo\n * caches the page.\n \n `disconnect()` cannot do this job, for two independent reasons. Turbo\n * queues the clone from this event rather than taking it here, and the body swap\n * that runs the controller's `disconnect()` is queued separately — so which of\n * the two lands first is not something a controller can rely on, and a rewind\n * written in `disconnect()` may reach only the DOM being thrown away. In the\n * other direction, `disconnect()` also fires on an in-page move (Stimulus tears\n * down and reconnects the same element), where rewinding would wipe a\n * legitimately in-progress interaction — a spinner mid-load would vanish. One\n * timing is unreliable, the other is too eager; `turbo:before-cache` is the only\n * point that is exactly \"the page is about to be frozen\".\n \n Scope is the subscription only: registering on `activate()`, unregistering on\n * `deactivate()`, and one shared document listener no matter how many instances\n * are live. What to return to its initial state — which `data-state`, which\n * `hidden`, which `aria-busy` — stays in the controller, because no two\n * consumers answer it the same way.\n \n Rewind state, not appearance. The pass writes attributes the controller\n * itself owns; the visual result of those attributes is the consumer's CSS, and\n * a library that reached for style or class names would be guessing at markup\n * it does not own.\n \n Both entry points are idempotent, so the lifecycle hooks can call them\n * unconditionally: a second `activate()` does not double-subscribe and does not\n * make the callback run twice, and `deactivate()` on an instance that never\n * subscribed is a no-op.\n \n This file's own doc block is dropped from `dist`, but every member comment is\n * inlined into each consumer entry (`tsup` builds with `splitting: false`), so\n * rationale belongs here and only the contract belongs on the members.\n \n @example\n * ```ts\n * readonly #beforeCache = new BeforeCacheReset(() => this.#rewind());\n \n connect() { this.#beforeCache.activate(); }\n * disconnect() { this.#beforeCache.deactivate(); }\n * ```\n /\nexport class BeforeCacheReset {\n /* Every subscribed instance, iterated by the one shared document listener. /\n static readonly #subscribers = new Set<BeforeCacheReset>();\n\n /* The shared listener; installed while at least one instance is subscribed. /\n static readonly #onBeforeCache = (): void => {\n for (const subscriber of BeforeCacheReset.#subscribers) subscriber.#rewind();\n };\n\n readonly #rewind: () => void;\n\n /* @param rewind - the pass that returns this controller's state to its initial form. /\n constructor(rewind: () => void) {\n this.#rewind = rewind;\n }\n\n /* Subscribes to `turbo:before-cache`; call from `connect()`. Idempotent. /\n activate(): void {\n const first = BeforeCacheReset.#subscribers.size === 0;\n BeforeCacheReset.#subscribers.add(this);\n if (first) {\n document.addEventListener(\"turbo:before-cache\", BeforeCacheReset.#onBeforeCache);\n }\n }\n\n /* Unsubscribes; call from `disconnect()`. Safe when never subscribed. /\n deactivate(): void {\n BeforeCacheReset.#subscribers.delete(this);\n if (BeforeCacheReset.#subscribers.size > 0) return;\n document.removeEventListener(\"turbo:before-cache\", BeforeCacheReset.#onBeforeCache);\n }\n}\n","import { BeforeCacheReset } from \"./before_cache_reset\";\n\n/\n Shared bookkeeping for a `tabindex` a controller lends an element temporarily.\n \n A controller that must move focus somewhere the author never made focusable\n * (a landmark root, a scroll destination) reaches for the same trick: add a\n * `tabindex` just-in-time and hand it back once it is no longer needed. The\n * borrow is the easy half; the return is what the two conditions below are for.\n \n Returning needs two conditions, not one. Owning the borrow is not enough:\n * the attribute must also still hold the value this instance wrote. A consumer\n * that changed it afterwards — `tabindex=\"0\"` to make the root its own Tab stop\n * — owns it now, and removing it there silently discards authored markup. The\n * bookkeeping is dropped either way, since the loan is over regardless of who\n * ends up owning the value.\n \n Never borrow over an existing value. An element that already carries a\n * `tabindex` is the author's to control, so there is nothing to lend and nothing\n * to return.\n \n Every live loan also owns a shared `turbo:before-cache` subscription. The loan\n * is returned before Turbo can copy it into a snapshot, so consumers get cache\n * safety without duplicating a lifecycle hook; `returnAll()` removes the\n * subscription again as soon as no loan remains.\n \n The registry is keyed by element, so a controller borrowing on a single\n * element (`this.element`) and one borrowing across a changing set of targets\n * use the same API — the single-element case is a set of one. It holds no\n * opinion about when to borrow or where focus goes next; that stays in the\n * controller.\n \n The API is deliberately two methods. This file's own doc block is dropped\n * from `dist`, but every member comment is inlined into each consumer entry\n * (`tsup` builds with `splitting: false`), so rationale belongs here, only the\n * contract belongs on the members, and every method no consumer calls is still\n * paid for once per consumer entry.\n \n @example\n * ```ts\n * readonly #tabindex = new TabindexLoan();\n \n #rescueFocus() {\n * this.#tabindex.lend(this.element);\n * this.element.focus();\n * }\n \n disconnect() {\n * this.#tabindex.returnAll();\n * }\n * ```\n /\nexport class TabindexLoan<T extends HTMLElement = HTMLElement> {\n readonly #value: string;\n readonly #lent = new Set<T>();\n /* Returns live loans before Turbo can copy them into its page snapshot. /\n readonly #beforeCache = new BeforeCacheReset(() => this.returnAll());\n\n /\n @param value - the `tabindex` to lend. `\"-1\"` (the default) is\n * programmatically focusable but not a Tab stop; `\"0\"` is a real Tab stop,\n * which a scroll region with no focusable content of its own needs.\n /\n constructor(value: string = \"-1\") {\n this.#value = value;\n }\n\n /* Lends `element` the value; no-ops when it already carries a `tabindex`. /\n lend(element: T): void {\n if (element.hasAttribute(\"tabindex\")) return;\n element.setAttribute(\"tabindex\", this.#value);\n this.#lent.add(element);\n // Subscribe only while a real loan exists. Keeping this guarantee here means\n // every consumer is Turbo-safe without another lifecycle hook to remember.\n this.#beforeCache.activate();\n }\n\n /* Takes back every loan whose value is still the one that was lent. /\n returnAll(): void {\n for (const element of this.#lent) {\n if (element.getAttribute(\"tabindex\") === this.#value) element.removeAttribute(\"tabindex\");\n }\n this.#lent.clear();\n this.#beforeCache.deactivate();\n }\n}\n","import { Controller } from \"@hotwired/stimulus\";\nimport { BlurDeferral } from \"../utils/blur_deferral\";\nimport { validSelector } from \"../utils/declared_value\";\nimport { prefersReducedMotion } from \"../utils/reduced_motion\";\nimport { TabindexLoan } from \"../utils/tabindex_loan\";\n\n/* Default scroll threshold in px, and what a non-finite declaration falls back to. /\nconst DEFAULT_OFFSET = 400;\n\n/\n Headless Scroll Visibility behavior: shows or hides an element based on\n * scroll amount or direction (back-to-top buttons, hide-on-scroll headers). No\n * dedicated APG pattern; when the element is a button it follows the Button\n * practice.\n \n Markup contract (identifier: `stimeo--scroll-visibility`):\n * <div data-controller=\"stimeo--scroll-visibility\"\n * data-stimeo--scroll-visibility-offset-value=\"400\"\n * data-stimeo--scroll-visibility-mode-value=\"offset\">\n * <button type=\"button\" hidden\n * data-stimeo--scroll-visibility-target=\"element\"\n * data-action=\"click->stimeo--scroll-visibility#toTop\">Back to top</button>\n * </div>\n \n In `offset` mode the element is shown once the scroll source is scrolled past\n * `offset` px; in `direction` mode it is hidden while scrolling down and shown\n * while scrolling up. A `scroll` that carries no vertical movement — a\n * horizontal scroll, an overscroll bounce — has no direction, so `direction`\n * mode leaves the current visibility alone. Visibility is reflected through the\n * `hidden` attribute (so a hidden control also leaves the focus order) and\n * `data-state`.\n \n By default the window is the scroll source. When the page itself does not\n * scroll — e.g. a fixed-height app shell whose main column scrolls in a container\n * (`overflow: auto`) — point `root` at that container (a CSS selector) so the\n * controller observes the element's scroll instead of the (never-scrolling)\n * window. `toTop` then scrolls that same container.\n \n `change` dispatches `{ visible: boolean }` on transitions only: connecting\n * reflects the current scroll state onto the hooks without announcing it, so a\n * Turbo restore does not replay the state the snapshot already carries.\n \n @remarks\n * Behavior only — the look and any transition are the consumer's CSS. The scroll\n * listener is `passive`, coalesced through `requestAnimationFrame`, and removed on\n * `disconnect()` (Turbo navigation included). `offset` / `mode` are re-read at\n * runtime, so a Turbo morph that swaps either attribute is followed without\n * waiting for the next scroll; a selector (`root`, `focusSelector`) or a\n * threshold that cannot be parsed reads as its default, keeping the rest of the\n * element alive. A scroll never hides the control while it owns focus: that\n * hide waits for it to blur and is decided again from the scroll position at that\n * moment. `toTop` honors `prefers-reduced-motion` by forcing an\n * instant jump independently of the consumer's CSS `scroll-behavior`, and can\n * move focus to a `focusSelector` target (given `tabindex=\"-1\"` if needed, and\n * focused without scrolling so the smooth scroll survives) to keep keyboard\n * users oriented after the scroll. A live disconnect removes only a\n * `tabindex=\"-1\"` this controller instance added; authored tabindex values\n * remain. This teardown does not claim to rewrite a Turbo cache snapshot that\n * was cloned before disconnect.\n /\nexport class ScrollVisibilityController extends Controller<HTMLElement> {\n static override targets = [\"element\"];\n static override values = {\n offset: { type: Number, default: DEFAULT_OFFSET },\n mode: { type: String, default: \"offset\" },\n focusSelector: { type: String, default: \"\" },\n root: { type: String, default: \"\" },\n };\n static actions = [\"toTop\"] as const;\n static events = [\"change\"] as const;\n\n declare readonly elementTarget: HTMLElement;\n declare readonly hasElementTarget: boolean;\n\n declare offsetValue: number;\n declare modeValue: string;\n declare focusSelectorValue: string;\n declare rootValue: string;\n\n /* Pending rAF id that coalesces scroll bursts into one measurement. /\n #rafId: number \| null = null;\n /* Previous scroll position, for `direction` mode delta detection. /\n #lastScrollY = 0;\n /* Current visibility, tracked to dispatch `change` only on real transitions. /\n #visible: boolean \| null = null;\n /\n The observed scroll source: a container element when `root` resolves, else\n * the window. Captured on connect so teardown detaches from the same source.\n /\n #scrollSource: HTMLElement \| Window = window;\n /\n Gates the declaration callbacks to the connected window.\n \n Stimulus delivers a Value callback ahead of `connect()` and again for every\n * runtime change; without the gate, merely connecting would evaluate — and\n * announce — before `connect()` runs its own first reflection.\n /\n #connected = false;\n /* Validated threshold; a non-finite declaration reads as the default. /\n #offset = DEFAULT_OFFSET;\n /* Validated `root` selector; an unparsable declaration reads as absent. /\n #rootSelector = \"\";\n /* Validated `focusSelector`; an unparsable declaration reads as absent. /\n #focusSelector = \"\";\n /* Focus targets this instance lent a `tabindex` to. /\n readonly #tabindex = new TabindexLoan();\n /\n The hide held back while the control itself owns focus.\n \n Completing the deferral re-runs the ordinary evaluation rather than applying\n * the stale decision: by the time focus leaves, the scroll position may have\n * moved back past the threshold.\n /\n readonly #pendingHide = new BlurDeferral((): void => {\n if (this.#connected) this.#evaluate();\n });\n\n readonly #onScroll = (): void => {\n if (this.#rafId !== null) return;\n this.#rafId = requestAnimationFrame(() => {\n this.#rafId = null;\n this.#evaluate();\n });\n };\n\n override connect(): void {\n this.#scrollSource = this.#resolveScrollSource();\n this.#lastScrollY = this.#scrollY();\n this.#scrollSource.addEventListener(\"scroll\", this.#onScroll, { passive: true });\n this.#evaluate(false);\n this.#connected = true;\n }\n\n override disconnect(): void {\n this.#connected = false;\n this.#scrollSource.removeEventListener(\"scroll\", this.#onScroll);\n if (this.#rafId !== null) {\n cancelAnimationFrame(this.#rafId);\n this.#rafId = null;\n }\n this.#pendingHide.releaseAll();\n this.#tabindex.returnAll();\n this.#visible = null;\n }\n\n /* Writes the current visibility onto a control that arrives after connect. /\n elementTargetConnected(element: HTMLElement): void {\n if (this.#visible !== null) element.hidden = !this.#visible;\n }\n\n /* Drops a held-back hide together with the control it was waiting on. /\n elementTargetDisconnected(): void {\n // At most one hide is ever held back, and it rides an element inside the\n // target — the focus owner, which may be a descendant rather than the\n // target itself. Losing the target ends that wait either way.\n this.#pendingHide.releaseAll();\n }\n\n /\n Validates `offset` once, then re-renders.\n \n Re-renders when application code (or a Turbo morph) changes `offset` at\n * runtime. A declaration that is not a finite number reads as the default, so\n * the comparison path never sees `NaN` — which would answer `false` to every\n * comparison and strand the element (in `direction` mode, even the guarantee\n * that the very top always reveals).\n /\n offsetValueChanged(): void {\n this.#offset = Number.isFinite(this.offsetValue) ? this.offsetValue : DEFAULT_OFFSET;\n if (this.#connected) this.#evaluate();\n }\n\n /* Re-renders when application code (or a Turbo morph) changes `mode` at runtime. /\n modeValueChanged(): void {\n if (this.#connected) this.#evaluate();\n }\n\n /* Validates `root` once so connect never parses a selector that throws. /\n rootValueChanged(): void {\n this.#rootSelector = validSelector(this.element, this.rootValue, \"\");\n }\n\n /* Validates `focusSelector` once so `toTop` never parses a selector that throws. /\n focusSelectorValueChanged(): void {\n this.#focusSelector = validSelector(this.element, this.focusSelectorValue, \"\");\n }\n\n /* Scrolls the source to the top and, optionally, moves focus to a safe target. /\n toTop(): void {\n const behavior: ScrollBehavior = prefersReducedMotion() ? \"instant\" : \"smooth\";\n this.#scrollSource.scrollTo({ top: 0, behavior });\n if (this.#focusSelector) {\n const target = document.querySelector<HTMLElement>(this.#focusSelector);\n if (target) {\n this.#tabindex.lend(target);\n // Focusing scrolls the target into view by default, which lands the page\n // instantly and discards the scroll above.\n target.focus({ preventScroll: true });\n }\n }\n }\n\n /\n Decides the next visibility from the current scroll state and applies it.\n \n @param notify - whether a transition announces itself. The reflection\n * `connect()` performs is the current state, not a change.\n \n @stimeoRenderRoot\n /\n #evaluate(notify = true): void {\n const y = this.#scrollY();\n let nextVisible: boolean;\n if (this.modeValue === \"direction\") {\n // Near the very top, always reveal so a hide-on-scroll header is never\n // stranded off-screen when the page cannot scroll up any further.\n if (y <= this.#offset) {\n nextVisible = true;\n } else if (y === this.#lastScrollY) {\n // No vertical movement carries no direction, so it decides nothing.\n return;\n } else {\n nextVisible = y < this.#lastScrollY; // scrolling up reveals, down hides\n }\n } else {\n nextVisible = y > this.#offset;\n }\n this.#lastScrollY = y;\n this.#setVisible(nextVisible, notify);\n }\n\n /* Applies visibility to the target, syncing `hidden`, `data-state`, `change`. /\n #setVisible(next: boolean, notify: boolean): void {\n if (next === this.#visible) return;\n const focused = !next && this.hasElementTarget ? this.#focusedWithin() : null;\n if (focused) {\n // Hiding the element that holds focus drops it to the document body,\n // stranding a keyboard user mid-interaction (WCAG 2.4.7 / 2.4.11). Hold\n // the hide until it blurs; the state stays what the user can still see.\n this.#pendingHide.deferOnly(focused);\n return;\n }\n this.#visible = next;\n if (this.hasElementTarget) this.elementTarget.hidden = !next;\n this.element.setAttribute(\"data-state\", next ? \"visible\" : \"hidden\");\n if (notify) this.dispatch(\"change\", { detail: { visible: next } });\n }\n\n /* Resolves the scroll source from `root` (falling back to the window). /\n #resolveScrollSource(): HTMLElement \| Window {\n if (this.#rootSelector) {\n const root = document.querySelector<HTMLElement>(this.#rootSelector);\n if (root) return root;\n }\n return window;\n }\n\n /\n The focus owner inside the target, or `null` when focus is elsewhere.\n \n `blur` does not bubble, so the deferral has to ride the focused element\n * itself: waiting on a container that never receives the event would hold the\n * hide forever.\n */\n #focusedWithin(): HTMLElement \| null {\n const focused = document.activeElement;\n if (focused instanceof HTMLElement && this.elementTarget.contains(focused)) return focused;\n return null;\n }\n\n #scrollY(): number {\n if (this.#scrollSource === window) {\n return window.scrollY ?? window.pageYOffset ?? 0;\n }\n return (this.#scrollSource as HTMLElement).scrollTop;\n }\n}\n"]}

package/dist/controllers/scrollspy_controller.d.ts CHANGED Viewed

@@ -47,7 +47,7 @@ import { Controller } from '@hotwired/stimulus';
  * - `link` targets added or removed — Stimulus's target callbacks.
  * - a `link` target's `href` / `data-href` rewritten in place — a Turbo 8 morph
  *   keeps the element *and* its target marker, so no target callback fires;
- *   {@link ANCHOR_ATTRIBUTES} is watched for exactly this case.
+ *   those two attributes are watched for exactly this case.
  * - the reader's scroll position, including inside a stretch where no section
  *   crosses an observation threshold.
  *

package/dist/controllers/scrollspy_controller.js CHANGED Viewed

@@ -2,14 +2,19 @@ import { Controller } from '@hotwired/stimulus';
 // src/controllers/scrollspy_controller.ts
-// src/utils/intersection_watcher.ts
-function queryRoot(selector) {
-  if (!selector) return null;
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
   try {
-    return document.querySelector(selector);
+    return parse(raw);
   } catch {
+    return fallback;
   }
-  return null;
+}
+// src/utils/intersection_watcher.ts
+function queryRoot(selector) {
+  if (!selector) return null;
+  return parseDeclared(selector, (raw) => document.querySelector(raw), null);
 }
 var IntersectionWatcher = class {
   #onEntries;
@@ -239,7 +244,7 @@ var ScrollspyController = class extends Controller {
    * only rewrites attributes, so Stimulus fires no target callback: without
    * this, a link re-pointed from `#intro` to `#faq` would keep the controller
    * observing `#intro` for the rest of the page's life. The filter is exactly
-   * {@link ANCHOR_ATTRIBUTES}; guarding on `MutationObserver` keeps the
+   * `href` and `data-href`; guarding on `MutationObserver` keeps the
    * controller usable where the API is absent, matching `IntersectionWatcher`'s
    * own support guard.
    */