@t007/utils 0.0.24 → 0.0.26

package/dist/hooks/vanilla.cjs

@@ -0,0 +1,407 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/vanilla.ts
+var vanilla_exports = {};
+__export(vanilla_exports, {
+  initArrowNavigation: () => initArrowNavigation,
+  initFocusTrap: () => initFocusTrap,
+  initOutsideClick: () => initOutsideClick,
+  initScrollAssist: () => initScrollAssist,
+  initVScrollerator: () => initVScrollerator,
+  removeArrowNavigation: () => removeArrowNavigation,
+  removeFocusTrap: () => removeFocusTrap,
+  removeOutsideClick: () => removeOutsideClick,
+  removeScrollAssist: () => removeScrollAssist,
+  rippleHandler: () => rippleHandler
+});
+module.exports = __toCommonJS(vanilla_exports);
+
+// src/hooks/vanilla/scrollAssist.ts
+var import_sia_reactor = require("sia-reactor");
+
+// src/core/dom.ts
+var import_utils = require("sia-reactor/utils");
+var INTERACTIVE_SELECTOR = 'button,[href],input,label,select,textarea,details>summary,[contenteditable],iframe,audio[controls],video[controls],[tabindex]:not([tabindex="-1"])';
+var isInteractive = (target) => target instanceof HTMLElement && target.matches(INTERACTIVE_SELECTOR);
+function getActiveElement(root = document) {
+  const activeEl = root.activeElement;
+  return !activeEl ? null : activeEl.shadowRoot ? getActiveElement(activeEl.shadowRoot) : activeEl;
+}
+
+// src/core/num.ts
+var import_utils2 = require("sia-reactor/utils");
+
+// src/hooks/vanilla/scrollAssist.ts
+function initScrollAssist(el, { pxPerSecond = 80, assistClassName = "t007-scroll-assist", vertical = true, horizontal = true } = import_sia_reactor.NIL) {
+  const parent = el?.parentElement, existing = (t007._scrollers ??= /* @__PURE__ */ new WeakMap()).get(el);
+  if (!parent || existing) return existing ? existing : void 0;
+  t007._scroller_r_observer ??= new ResizeObserver((entries) => {
+    for (const { target } of entries) t007._scrollers.get(target)?.update();
+  });
+  t007._scroller_m_observer ??= new MutationObserver((entries) => {
+    const els = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      let node = entry.target instanceof Element ? entry.target : null;
+      while (node && !t007._scrollers.has(node)) node = node.parentElement;
+      if (node) els.add(node);
+    }
+    for (const el2 of els) t007._scrollers.get(el2)?.update();
+  });
+  const assist = {};
+  let scrollId = null, last = performance.now(), assistWidth = 20, assistHeight = 20;
+  const update = () => {
+    const hasInteractive = !!parent.querySelector(INTERACTIVE_SELECTOR);
+    if (horizontal) {
+      const w = assist.left?.offsetWidth || assistWidth, check = hasInteractive ? el.clientWidth < w * 2 : false;
+      assist.left.style.display = check ? "none" : el.scrollLeft > 0 ? "block" : "none";
+      assist.right.style.display = check ? "none" : el.scrollLeft + el.clientWidth < el.scrollWidth - 1 ? "block" : "none";
+      assistWidth = w;
+    }
+    if (vertical) {
+      const h = assist.up?.offsetHeight || assistHeight, check = hasInteractive ? el.clientHeight < h * 2 : false;
+      assist.up.style.display = check ? "none" : el.scrollTop > 0 ? "block" : "none";
+      assist.down.style.display = check ? "none" : el.scrollTop + el.clientHeight < el.scrollHeight - 1 ? "block" : "none";
+      assistHeight = h;
+    }
+  };
+  const scroll = (dir) => {
+    const frame = () => {
+      const now = performance.now(), dt = now - last;
+      last = now;
+      const d = pxPerSecond * dt / 1e3;
+      if (dir === "left") el.scrollLeft = Math.max(0, el.scrollLeft - d);
+      if (dir === "right") el.scrollLeft = Math.min(el.scrollWidth - el.clientWidth, el.scrollLeft + d);
+      if (dir === "up") el.scrollTop = Math.max(0, el.scrollTop - d);
+      if (dir === "down") el.scrollTop = Math.min(el.scrollHeight - el.clientHeight, el.scrollTop + d);
+      scrollId = requestAnimationFrame(frame);
+    };
+    last = performance.now();
+    frame();
+  };
+  const stop = () => (cancelAnimationFrame(scrollId ?? 0), scrollId = null);
+  const addAssist = (dir) => {
+    const div = (0, import_utils.createEl)("div", { className: assistClassName }, { scrollDirection: dir }, { display: "none" });
+    if (!div) return;
+    for (const evt of ["pointerenter", "dragenter"]) div.addEventListener(evt, () => scroll(dir));
+    for (const evt of ["pointerleave", "pointerup", "pointercancel", "dragleave", "dragend"]) div.addEventListener(evt, stop);
+    dir === "left" || dir === "up" ? parent.insertBefore(div, el) : parent.append(div);
+    assist[dir] = div;
+  };
+  if (horizontal) for (const dir of ["left", "right"]) addAssist(dir);
+  if (vertical) for (const dir of ["up", "down"]) addAssist(dir);
+  const handle = {
+    update,
+    destroy() {
+      stop(), el.removeEventListener("scroll", update);
+      t007._scroller_r_observer.unobserve(el), t007._scrollers.delete(el);
+      for (const a of Object.values(assist)) a.remove();
+    }
+  };
+  update(), el.addEventListener("scroll", update);
+  t007._scroller_r_observer.observe(el), t007._scroller_m_observer.observe(el, { childList: true, subtree: true, characterData: true });
+  return t007._scrollers.set(el, handle), handle;
+}
+var removeScrollAssist = (el) => t007._scrollers.get(el)?.destroy();
+
+// src/hooks/vanilla/scrollerator.ts
+var import_sia_reactor2 = require("sia-reactor");
+function initVScrollerator({ baseSpeed = 3, maxSpeed = 10, stepDelay = 2e3, baseRate = 16, lineHeight = 80, margin = 80, car = window } = import_sia_reactor2.NIL) {
+  let linesPerSec = baseSpeed, accelId = null, lastTime = null;
+  const drive = (clientY, brake = false, offsetY = 0) => {
+    if (car !== window) clientY -= offsetY;
+    const now = performance.now(), speed = linesPerSec * lineHeight * ((lastTime ? now - lastTime : baseRate) / 1e3);
+    if (!brake && (clientY < margin || clientY > (car.innerHeight ?? car.offsetHeight) - margin)) {
+      accelId === null ? accelId = setTimeout(() => linesPerSec += 1, stepDelay) : linesPerSec > baseSpeed && (linesPerSec = Math.min(linesPerSec + 1, maxSpeed));
+      car.scrollBy?.(0, clientY < margin ? -speed : speed);
+    } else reset();
+    return lastTime = !brake ? now : null, speed;
+  };
+  const reset = () => (accelId && clearTimeout(accelId), accelId = null, linesPerSec = baseSpeed, lastTime = null);
+  return { drive, reset };
+}
+
+// src/hooks/vanilla/outsideClick.ts
+var import_sia_reactor3 = require("sia-reactor");
+var stacks = /* @__PURE__ */ new WeakMap();
+function initOutsideClick(el, { enabled = false, onOutsideClick = import_sia_reactor3.NOOP, clickOnClick = true, clickOnEscape = true, clickOnFocusOut = false, allowInputs = true, root = window, scoped = true, capture = true } = import_sia_reactor3.NIL) {
+  const existing = (t007._outsiders ??= /* @__PURE__ */ new WeakMap()).get(el);
+  if (!enabled || existing) return existing ? existing : void 0;
+  scoped = scoped && root instanceof HTMLElement, root = scoped ? root : root === document ? document : window;
+  const stack = stacks.get(root) ?? [], onScopedOut = (e, t, p = e.touches?.[0] || e, rect = el.getBoundingClientRect()) => {
+    if (stack.at(-1) !== el || p.clientX >= rect.left && p.clientX <= rect.right && p.clientY >= rect.top && p.clientY <= rect.bottom) return false;
+    return (!scoped ? true : root.contains(t)) && onOutsideClick(e);
+  }, handleClick = ((e) => clickOnClick && !(allowInputs && isInteractive(e.target)) && onScopedOut(e, e.target)), handleEscape = ((e) => clickOnEscape && e.key === "Escape" && !e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey && stack.at(-1) === el && onOutsideClick(e)), handleFocusOut = (e) => clickOnFocusOut && onScopedOut(e, e.relatedTarget);
+  root.addEventListener("mousedown", handleClick, capture), root.addEventListener("touchstart", handleClick, { passive: true, capture });
+  root.addEventListener("keydown", handleEscape, capture), el.addEventListener("focusout", handleFocusOut, capture);
+  if (!stack.includes(el)) stack.push(el), stacks.set(root, stack);
+  const destroy = () => {
+    root.removeEventListener("mousedown", handleClick, capture), root.removeEventListener("touchstart", handleClick, capture);
+    root.removeEventListener("keydown", handleEscape, capture);
+    el.removeEventListener("focusout", handleFocusOut, capture);
+    t007._outsiders.delete(el), stack.splice(stack.indexOf(el), 1);
+  };
+  return t007._outsiders.set(el, destroy), destroy;
+}
+var removeOutsideClick = (el) => t007._outsiders?.get(el)?.();
+
+// src/hooks/vanilla/focusTrap.ts
+var import_sia_reactor4 = require("sia-reactor");
+var stacks2 = /* @__PURE__ */ new WeakMap();
+function initFocusTrap(el, { enabled = false, initialSelector = "[data-autofocus]", ringClassName = "focus-outline", root = window, scoped = true, capture = true } = import_sia_reactor4.NIL) {
+  const existing = (t007._ftrappers ??= /* @__PURE__ */ new WeakMap()).get(el);
+  if (!enabled || existing) return existing ? existing : void 0;
+  scoped = scoped && root instanceof HTMLElement, root = scoped ? root : root === document ? document : window;
+  const stack = stacks2.get(root) ?? [], focused = document.querySelector(":focus"), initial = el.querySelector(initialSelector), first = (0, import_utils.createEl)("span", { tabIndex: 0 }, { focusGuard: "start" }, { position: "absolute", width: "0", height: "0", pointerEvents: "none" }), last = (0, import_utils.createEl)("span", { tabIndex: 0 }, { focusGuard: "end" }, { position: "absolute", width: "0", height: "0", pointerEvents: "none" }), getFocusable = (c = el) => Array.prototype.filter.call(c.querySelectorAll(INTERACTIVE_SELECTOR), (el2) => !el2.hasAttribute("disabled") && !el2.hasAttribute("aria-hidden") && !el2.hasAttribute("data-focus-guard")), resetFocus = (i = 0, els = getFocusable()) => els?.length ? els.at(i).focus() : (!el.hasAttribute("tabindex") && (el.tabIndex = -1), el.focus()), edgeFocus = (pre = false) => {
+    if (!scoped) return resetFocus(pre ? -1 : 0);
+    else if (root.hasAttribute("tabindex")) return root.focus();
+    const items = getFocusable();
+    if (!items.length) return resetFocus(0, null);
+    const all = getFocusable(root.parentElement?.closest(`:has(${INTERACTIVE_SELECTOR})`) || document.body);
+    for (let target, len = all.length, i = all.indexOf(items[pre ? 0 : items.length - 1]) + (pre ? -1 : 1); pre ? i >= 0 : i < len; pre ? i-- : i++) if (!root.contains(target = all[i])) return target.focus();
+    (pre ? first : last).blur();
+  }, handleFocusIn = () => stack.at(-1) === el && getActiveElement() !== root && !el.contains(getActiveElement()) && setTimeout(resetFocus, 0, 0), handleInitialBlur = () => initial.classList.remove(ringClassName);
+  first.addEventListener("focus", (e) => el.contains(e.relatedTarget) ? edgeFocus(true) : resetFocus(), capture), el.prepend(first);
+  last.addEventListener("focus", (e) => el.contains(e.relatedTarget) ? edgeFocus() : resetFocus(-1), capture), el.append(last);
+  root.addEventListener("focusin", handleFocusIn, capture);
+  if (!el.querySelector(":focus")) !initial ? resetFocus() : setTimeout(() => (initial.classList.add(ringClassName), initial.focus(), initial.addEventListener("blur", handleInitialBlur, capture)));
+  if (!stack.includes(el)) stack.push(el), stacks2.set(root, stack);
+  const destroy = () => {
+    focused?.isConnected && focused.focus(), first.remove(), last.remove();
+    root.removeEventListener("focusin", handleFocusIn, capture);
+    initial?.removeEventListener("blur", handleInitialBlur, capture);
+    t007._ftrappers.delete(el), stack.splice(stack.indexOf(el), 1);
+  };
+  return t007._ftrappers.set(el, destroy), destroy;
+}
+var removeFocusTrap = (el) => t007._ftrappers?.get(el)?.();
+
+// src/hooks/react/useArrowNavigation/consts.ts
+var import_sia_reactor5 = require("sia-reactor");
+var H_NAV_KEYS = ["ArrowRight", "ArrowLeft", "Home", "End"];
+var V_NAV_KEYS = ["ArrowUp", "ArrowDown", "PageDown", "PageUp"];
+var NAV_KEYS = [...H_NAV_KEYS, ...V_NAV_KEYS];
+var DEFAULT_CONFIG = {
+  enabled: null,
+  selector: "[data-arrow-item]",
+  focusOnHover: true,
+  loop: true,
+  virtual: false,
+  typeahead: false,
+  rovingTab: null,
+  defaultTabbableIndex: null,
+  baseTabIndex: "0",
+  resetMs: 500,
+  rtl: null,
+  grid: {},
+  activeClass: "focus-outlined",
+  inputSelector: "input,textarea,[contenteditable='true']",
+  focusOptions: { preventScroll: false },
+  scrollIntoView: { block: "nearest", inline: "nearest" },
+  onSelect: import_sia_reactor5.NOOP,
+  onFocusOut: import_sia_reactor5.NOOP
+};
+
+// src/hooks/react/useArrowNavigation/utils.ts
+var getTargetIndex = ({ key, currIndex, length, gridX, gridY, vGridY, loop, ctrlKey = false, rtl }) => {
+  const rowStart = currIndex - currIndex % gridX, rowEnd = Math.min(rowStart + gridX - 1, length - 1), colStart = currIndex % gridX, colEnd = Math.min(colStart + gridX * (gridY - 1), length - 1), canX = gridX > 1, canY = gridY > 1, horizontalMove = rtl ? { ArrowRight: canX ? -1 : 0, ArrowLeft: canX ? 1 : 0 } : { ArrowRight: canX ? 1 : 0, ArrowLeft: canX ? -1 : 0 }, move = { ...horizontalMove, ArrowDown: canY ? gridX : 0, ArrowUp: canY ? -gridX : 0, Home: ctrlKey ? 0 : rowStart, End: ctrlKey ? length - 1 : rowEnd, PageDown: (vGridY - 1) * gridX, PageUp: -(vGridY - 1) * gridX }[key] ?? 0;
+  let targetIndex = key === "Home" || key === "End" ? move : currIndex + move;
+  if (key === "ArrowDown") {
+    if (!loop && targetIndex >= length) targetIndex -= move;
+  } else if (key === "ArrowUp") {
+    if (!loop && targetIndex < 0) targetIndex += Math.abs(move);
+  } else if (key === "PageDown") {
+    if (!loop && targetIndex >= length) targetIndex = colEnd;
+  } else if (key === "PageUp") {
+    if (!loop && targetIndex < 0) targetIndex = colStart;
+  }
+  return loop ? (targetIndex + length) % length : (0, import_utils2.clamp)(0, targetIndex, length - 1);
+};
+var getCommonAncestor = (first, second) => {
+  if (!first) return null;
+  if (!second) return first.parentElement;
+  const ancestors = /* @__PURE__ */ new Set();
+  let current = first;
+  while (current) ancestors.add(current), current = current.parentElement;
+  current = second;
+  while (current) {
+    if (ancestors.has(current)) return current;
+    current = current.parentElement;
+  }
+  return null;
+};
+var getGrid = (all, x = true, y = true, vY = true) => {
+  const len = all.length, grid = {};
+  if (!len) return grid;
+  let cols = all.findIndex((el) => el.offsetTop !== all[0].offsetTop);
+  cols = cols > 0 ? cols : len;
+  if (x) grid.x = cols;
+  let rows = Math.ceil(len / cols);
+  if (y) grid.y = rows;
+  if (vY) {
+    const itemHeight = all[0].offsetHeight ?? 0, containerHeight = getCommonAncestor(all[0], all[1])?.clientHeight ?? 0;
+    rows = (0, import_utils2.clamp)(1, Math.floor(containerHeight / itemHeight), rows) || rows;
+    grid.vY = rows;
+  }
+  return grid;
+};
+
+// src/hooks/vanilla/arrowNavigation.ts
+function initArrowNavigation(container, config = {}) {
+  const existing = (t007._ashooters ??= /* @__PURE__ */ new WeakMap()).get(container);
+  if (!config.enabled || existing) return existing ? existing : void 0;
+  const { enabled: isEnabled, selector, focusOnHover, loop, virtual, typeahead, resetMs, activeClass, inputSelector, defaultTabbableIndex, baseTabIndex, grid, rtl: isRtl, focusOptions, scrollIntoView, onSelect, onFocusOut, rovingTab } = { ...DEFAULT_CONFIG, ...config };
+  let gridX = grid.x || 1, gridY = grid.y || 1, vGridY = grid.vY || 1, activeIndex = -1, buffer = "", timeout = null, items = [];
+  const enabled = isEnabled ?? virtual, roving = rovingTab ?? !virtual, rtl = isRtl ?? getComputedStyle(container).direction === "rtl", shouldSnub = () => !enabled || !container, isItemDisabled = (el) => !el || el.hasAttribute("disabled") || el.hasAttribute("aria-disabled"), getItems = () => items = Array.from(container.querySelectorAll(selector));
+  const getAbleIndex = (targetIndex, e = { key: "ArrowRight", ctrlKey: false }) => {
+    if (shouldSnub() || !items.length) return null;
+    let index = targetIndex;
+    let attempts = 0;
+    while (attempts < items.length) {
+      if (!isItemDisabled(items[index])) return index;
+      index = getTargetIndex({ key: e.key, currIndex: index, gridX, gridY, vGridY, length: items.length, loop, ctrlKey: e.ctrlKey, rtl });
+      attempts++;
+    }
+    return null;
+  };
+  const goToIndex = (targetIndex, e = { key: "ArrowRight" }) => {
+    if (shouldSnub()) return;
+    const idx = getAbleIndex(targetIndex, e);
+    if (idx === null) return;
+    resetActiveIndex(idx);
+    onSelect?.(items[idx], e), updateDOM();
+    if (virtual) {
+      items[idx]?.scrollIntoView(scrollIntoView);
+      container.setAttribute("aria-activedescendant", items[idx].id || "");
+    } else items[idx]?.focus(focusOptions);
+  };
+  const updateDOM = () => {
+    if (shouldSnub() || !virtual && !roving || !items.length) return;
+    const hasDefaultTabbable = defaultTabbableIndex !== null && defaultTabbableIndex !== void 0, tabbableIndex = hasDefaultTabbable && !isItemDisabled(items[defaultTabbableIndex]) ? defaultTabbableIndex : getAbleIndex(0);
+    for (let i = 0, len = items.length; i < len; i++) {
+      const el = items[i], isActive = i === activeIndex;
+      if (roving) el.setAttribute("tabindex", i === activeIndex || activeIndex === -1 && i === tabbableIndex ? baseTabIndex : "-1");
+      else if (virtual && activeIndex > 0) el.setAttribute("tabindex", i > activeIndex ? baseTabIndex : "-1");
+      else el.setAttribute("tabindex", baseTabIndex);
+      if (virtual) el.setAttribute("aria-selected", String(isActive)), el.classList.toggle(activeClass, isActive);
+    }
+  };
+  const resetActiveIndex = (index = -1) => (activeIndex = index, updateDOM());
+  const typeAhead = (key) => {
+    if (shouldSnub() || !typeahead) return;
+    buffer += key.toLowerCase();
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => buffer = "", resetMs);
+    const start = activeIndex >= 0 ? activeIndex + 1 : 0;
+    for (let i = 0; i < items.length; i++) {
+      const idx = (start + i) % items.length, label = (items[idx].getAttribute("data-label") || items[idx].innerText || "").trim().toLowerCase();
+      if (label.startsWith(buffer)) return goToIndex(idx);
+    }
+  };
+  const simulateKey = (e) => {
+    if (shouldSnub() || getActiveElement()?.matches("option")) return;
+    const { key } = e;
+    if (!items.length) return;
+    if (virtual && (key === " " || key === "Enter")) return items[activeIndex]?.click();
+    if (e.target?.matches(DEFAULT_CONFIG.inputSelector) && !virtual) return;
+    if (typeahead && key.length === 1 && /^[a-z0-9]$/i.test(key)) return typeAhead(key);
+    if (!NAV_KEYS.includes(key)) return;
+    if (!(e.currentTarget?.matches(DEFAULT_CONFIG.inputSelector) && gridX <= 1 && H_NAV_KEYS.includes(key))) e.preventDefault?.(), e.stopPropagation?.();
+    const currIndex = virtual ? activeIndex : items.indexOf(getActiveElement()), targetIndex = getTargetIndex({ currIndex, gridX, gridY, vGridY, length: items.length, loop, rtl, key, ctrlKey: e.ctrlKey });
+    goToIndex(targetIndex, e);
+  };
+  getItems(), updateDOM();
+  const interactiveEls = !virtual ? [container] : [container.querySelector(inputSelector)];
+  for (const el of interactiveEls) el?.addEventListener("keydown", simulateKey);
+  const handleFocusOut = (e) => {
+    if (!container.contains(e.relatedTarget)) return resetActiveIndex(), updateDOM(), onFocusOut?.(e);
+    const among = items.includes(e.relatedTarget);
+    if (!among && (defaultTabbableIndex ?? -1) >= 0) return resetActiveIndex(), updateDOM();
+    if (virtual) resetActiveIndex(), updateDOM();
+  };
+  container.addEventListener("focusout", handleFocusOut);
+  const handleHover = (e) => {
+    if (!enabled || !focusOnHover) return;
+    const el = e.currentTarget, idx = items.indexOf(el);
+    if (idx !== -1) goToIndex(idx);
+  };
+  for (const el of items) el.addEventListener("mouseenter", handleHover);
+  const mutationObserver = new MutationObserver(() => {
+    const oldEl = items[activeIndex];
+    getItems();
+    const newEl = items[activeIndex];
+    updateDOM();
+    if (oldEl && newEl && oldEl === newEl) return;
+    resetActiveIndex();
+    updateDOM();
+  });
+  mutationObserver.observe(container, { childList: true, subtree: true });
+  const setGrid = (g) => {
+    if (g.x !== void 0) gridX = g.x;
+    if (g.y !== void 0) gridY = g.y;
+    if (g.vY !== void 0) vGridY = g.vY;
+  };
+  const calcGrid = () => setGrid(getGrid(items, !grid.x, !grid.y, !grid.vY));
+  setGrid(grid), calcGrid();
+  const ancestor = items.length > 1 ? getCommonAncestor(items[0], items[1]) : container;
+  const resizeObserver = new ResizeObserver(calcGrid);
+  if (ancestor) resizeObserver.observe(ancestor);
+  const destroy = () => {
+    for (const el of interactiveEls) el?.removeEventListener("keydown", simulateKey);
+    container.removeEventListener("focusout", handleFocusOut);
+    for (const el of items) el.removeEventListener("mouseenter", handleHover);
+    mutationObserver.disconnect(), resizeObserver.disconnect();
+    if (timeout) clearTimeout(timeout);
+  };
+  const handle = { gridX: () => gridX, gridY: () => gridY, vGridY: () => vGridY, items: () => items, activeIndex: () => activeIndex, activeItem: () => items[activeIndex] ?? null, getAbleIndex, typeAhead, goToIndex, simulateKey, destroy };
+  return t007._ashooters.set(container, handle), handle;
+}
+var removeArrowNavigation = (container) => t007._ashooters?.get(container)?.destroy();
+
+// src/hooks/vanilla/ripple.ts
+var import_sia_reactor6 = require("sia-reactor");
+function rippleHandler(e, { target, forceCenter = false, wrapperClassName = "t007-ripple-wrapper", className = "t007-ripple", holdClassName = "t007-ripple-hold", fadeClassName = "t007-ripple-fade" } = import_sia_reactor6.NIL) {
+  const el = target || e.currentTarget;
+  if (!el || e.target !== e.currentTarget && isInteractive(e.target) || el.hasAttribute("disabled") || e.pointerType === "mouse" && e.button !== 0) return;
+  e.stopPropagation?.();
+  const { offsetWidth: rW, offsetHeight: rH } = el, { width: w, height: h, left: l, top: t } = el.getBoundingClientRect(), size = Math.max(rW, rH), x = forceCenter ? rW / 2 - size / 2 : (e.clientX - l) * rW / w - size / 2, y = forceCenter ? rH / 2 - size / 2 : (e.clientY - t) * rH / h - size / 2, wrapper = (0, import_utils.createEl)("span", { className: wrapperClassName }), ripple = (0, import_utils.createEl)("span", { className: className + " " + holdClassName }, {}, { cssText: `width:${size}px;height:${size}px;left:${x}px;top:${y}px;` });
+  let canRelease = false;
+  ripple.addEventListener("animationend", () => canRelease = true, { once: true });
+  el.append(wrapper.appendChild(ripple).parentElement);
+  const release = () => {
+    if (!canRelease) return ripple.addEventListener("animationend", release, { once: true });
+    ripple.classList.replace(holdClassName, fadeClassName);
+    ripple.addEventListener("animationend", () => setTimeout(() => wrapper.remove()));
+    for (const evt of ["pointerup", "pointercancel"]) (el.ownerDocument?.defaultView || window).removeEventListener(evt, release);
+  };
+  for (const evt of ["pointerup", "pointercancel"]) (el.ownerDocument?.defaultView || window).addEventListener(evt, release);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initArrowNavigation,
+  initFocusTrap,
+  initOutsideClick,
+  initScrollAssist,
+  initVScrollerator,
+  removeArrowNavigation,
+  removeFocusTrap,
+  removeOutsideClick,
+  removeScrollAssist,
+  rippleHandler
+});

package/dist/hooks/vanilla.d.cts

@@ -0,0 +1,35 @@
+export { a as ScrollAssistConfig, S as ScrollAssistHandle, b as ScrollDir, i as initScrollAssist, r as removeScrollAssist } from '../scrollAssist-y9wFmYgt.cjs';
+export { F as FocusTrapConfig, O as OutsideClickConfig, R as RippleConfig, i as initFocusTrap, a as initOutsideClick, r as removeFocusTrap, b as removeOutsideClick, c as rippleHandler } from '../ripple-DcMWw_AP.cjs';
+export { A as ArrowNavigationHandle, i as initArrowNavigation, r as removeArrowNavigation } from '../arrowNavigation-DK8mqVOk.cjs';
+
+/** Configuration for the vertical edge-scrolling helper. */
+interface ScrolleratorOptions {
+    /** Starting lines-per-second speed. Defaults to `3`. */
+    baseSpeed?: number;
+    /** Maximum accelerated speed. Defaults to `10`. */
+    maxSpeed?: number;
+    /** Delay before acceleration kicks in. Defaults to `2000`. */
+    stepDelay?: number;
+    /** Base frame rate used to estimate movement. Defaults to `16`. */
+    baseRate?: number;
+    /** Approximate line height in pixels. Defaults to `80`. */
+    lineHeight?: number;
+    /** Edge margin that triggers scrolling. Defaults to `80`. */
+    margin?: number;
+    /** Scroll container or window target. Defaults to `window`. */
+    car?: Window | HTMLElement;
+}
+/** Scrolling controls returned by initVScrollerator. */
+interface Scrollerator {
+    /** Trigger a scroll frame and return the computed distance. */
+    drive: (clientY: number, brake?: boolean, offsetY?: number) => number;
+    /** Reset speed and timers. */
+    reset: () => void;
+}
+/** Create an edge-driven vertical scrolling controller.
+ * @param options Scrollerator configuration.
+ * @returns Drive and reset controls for the controller.
+ */
+declare function initVScrollerator({ baseSpeed, maxSpeed, stepDelay, baseRate, lineHeight, margin, car }?: ScrolleratorOptions): Scrollerator;
+
+export { initVScrollerator };

package/dist/hooks/vanilla.d.ts

@@ -0,0 +1,35 @@
+export { a as ScrollAssistConfig, S as ScrollAssistHandle, b as ScrollDir, i as initScrollAssist, r as removeScrollAssist } from '../scrollAssist-y9wFmYgt.js';
+export { F as FocusTrapConfig, O as OutsideClickConfig, R as RippleConfig, i as initFocusTrap, a as initOutsideClick, r as removeFocusTrap, b as removeOutsideClick, c as rippleHandler } from '../ripple-DcMWw_AP.js';
+export { A as ArrowNavigationHandle, i as initArrowNavigation, r as removeArrowNavigation } from '../arrowNavigation-VenvPI4H.js';
+
+/** Configuration for the vertical edge-scrolling helper. */
+interface ScrolleratorOptions {
+    /** Starting lines-per-second speed. Defaults to `3`. */
+    baseSpeed?: number;
+    /** Maximum accelerated speed. Defaults to `10`. */
+    maxSpeed?: number;
+    /** Delay before acceleration kicks in. Defaults to `2000`. */
+    stepDelay?: number;
+    /** Base frame rate used to estimate movement. Defaults to `16`. */
+    baseRate?: number;
+    /** Approximate line height in pixels. Defaults to `80`. */
+    lineHeight?: number;
+    /** Edge margin that triggers scrolling. Defaults to `80`. */
+    margin?: number;
+    /** Scroll container or window target. Defaults to `window`. */
+    car?: Window | HTMLElement;
+}
+/** Scrolling controls returned by initVScrollerator. */
+interface Scrollerator {
+    /** Trigger a scroll frame and return the computed distance. */
+    drive: (clientY: number, brake?: boolean, offsetY?: number) => number;
+    /** Reset speed and timers. */
+    reset: () => void;
+}
+/** Create an edge-driven vertical scrolling controller.
+ * @param options Scrollerator configuration.
+ * @returns Drive and reset controls for the controller.
+ */
+declare function initVScrollerator({ baseSpeed, maxSpeed, stepDelay, baseRate, lineHeight, margin, car }?: ScrolleratorOptions): Scrollerator;
+
+export { initVScrollerator };