@develemit/web-hooks 0.0.0-stage → 0.1.0

package/dist/escape.js

@@ -0,0 +1,21 @@
+"use client";
+
+// src/escape/use-escape.ts
+import { useEffect, useRef } from "react";
+function useEscape(onEscape, active = true) {
+  const handlerRef = useRef(onEscape);
+  useEffect(() => {
+    handlerRef.current = onEscape;
+  });
+  useEffect(() => {
+    if (!active) return;
+    function onKeyDown(event) {
+      if (event.key === "Escape") handlerRef.current();
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active]);
+}
+export {
+  useEscape
+};

package/dist/focus-trap.cjs

@@ -0,0 +1,108 @@
+"use client";
+"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/focus-trap/index.ts
+var focus_trap_exports = {};
+__export(focus_trap_exports, {
+  FOCUSABLE_SELECTOR: () => FOCUSABLE_SELECTOR,
+  focusableWithin: () => focusableWithin,
+  nextFocusTarget: () => nextFocusTarget,
+  useFocusTrap: () => useFocusTrap
+});
+module.exports = __toCommonJS(focus_trap_exports);
+
+// src/focus-trap/focusables.ts
+var FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function focusableWithin(container) {
+  return Array.from(
+    container.querySelectorAll(FOCUSABLE_SELECTOR)
+  ).filter((el) => !el.closest("[hidden], [inert]"));
+}
+function nextFocusTarget(items, current, shiftKey, container) {
+  const first = items[0];
+  const last = items[items.length - 1];
+  if (!first || !last) return null;
+  if (!current || !container.contains(current)) return shiftKey ? last : first;
+  if (shiftKey && (current === first || current === container)) return last;
+  if (!shiftKey && current === last) return first;
+  return null;
+}
+
+// src/focus-trap/use-focus-trap.ts
+var import_react = require("react");
+var activeTraps = [];
+function useFocusTrap(containerRef, {
+  active,
+  initialFocusRef,
+  returnFocusRef,
+  restoreFocus = true
+}) {
+  const openerRef = (0, import_react.useRef)(null);
+  if (active && !openerRef.current && typeof document !== "undefined") {
+    openerRef.current = document.activeElement;
+  }
+  (0, import_react.useEffect)(() => {
+    const container = containerRef.current;
+    if (!active || !container) return;
+    const token = {};
+    activeTraps.push(token);
+    if (!container.contains(document.activeElement)) {
+      const target = initialFocusRef?.current ?? focusableWithin(container)[0] ?? container;
+      if (target === container && !container.hasAttribute("tabindex")) {
+        container.setAttribute("tabindex", "-1");
+      }
+      target.focus();
+    }
+    function onKeyDown(event) {
+      if (event.key !== "Tab" || !container) return;
+      if (activeTraps[activeTraps.length - 1] !== token) return;
+      const items = focusableWithin(container);
+      if (items.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const target = nextFocusTarget(
+        items,
+        document.activeElement,
+        event.shiftKey,
+        container
+      );
+      if (target) {
+        event.preventDefault();
+        target.focus();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      activeTraps.splice(activeTraps.indexOf(token), 1);
+      const opener = returnFocusRef?.current ?? openerRef.current;
+      openerRef.current = null;
+      if (restoreFocus && opener?.isConnected) opener.focus();
+    };
+  }, [active, containerRef, initialFocusRef, returnFocusRef, restoreFocus]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FOCUSABLE_SELECTOR,
+  focusableWithin,
+  nextFocusTarget,
+  useFocusTrap
+});

package/dist/focus-trap.d.cts

@@ -0,0 +1,17 @@
+import { RefObject } from 'react';
+
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+declare function focusableWithin(container: HTMLElement): HTMLElement[];
+/** The element Tab must be redirected to, or null when the browser's own move is fine. */
+declare function nextFocusTarget(items: HTMLElement[], current: Element | null, shiftKey: boolean, container: HTMLElement): HTMLElement | null;
+
+type UseFocusTrapOptions = {
+    active: boolean;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    /** Wins over the captured opener. Safari leaves <body> focused after a tap on a button. */
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    restoreFocus?: boolean;
+};
+declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, { active, initialFocusRef, returnFocusRef, restoreFocus, }: UseFocusTrapOptions): void;
+
+export { FOCUSABLE_SELECTOR, type UseFocusTrapOptions, focusableWithin, nextFocusTarget, useFocusTrap };

package/dist/focus-trap.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from 'react';
+
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+declare function focusableWithin(container: HTMLElement): HTMLElement[];
+/** The element Tab must be redirected to, or null when the browser's own move is fine. */
+declare function nextFocusTarget(items: HTMLElement[], current: Element | null, shiftKey: boolean, container: HTMLElement): HTMLElement | null;
+
+type UseFocusTrapOptions = {
+    active: boolean;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    /** Wins over the captured opener. Safari leaves <body> focused after a tap on a button. */
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    restoreFocus?: boolean;
+};
+declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, { active, initialFocusRef, returnFocusRef, restoreFocus, }: UseFocusTrapOptions): void;
+
+export { FOCUSABLE_SELECTOR, type UseFocusTrapOptions, focusableWithin, nextFocusTarget, useFocusTrap };

package/dist/focus-trap.js

@@ -0,0 +1,79 @@
+"use client";
+
+// src/focus-trap/focusables.ts
+var FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function focusableWithin(container) {
+  return Array.from(
+    container.querySelectorAll(FOCUSABLE_SELECTOR)
+  ).filter((el) => !el.closest("[hidden], [inert]"));
+}
+function nextFocusTarget(items, current, shiftKey, container) {
+  const first = items[0];
+  const last = items[items.length - 1];
+  if (!first || !last) return null;
+  if (!current || !container.contains(current)) return shiftKey ? last : first;
+  if (shiftKey && (current === first || current === container)) return last;
+  if (!shiftKey && current === last) return first;
+  return null;
+}
+
+// src/focus-trap/use-focus-trap.ts
+import { useEffect, useRef } from "react";
+var activeTraps = [];
+function useFocusTrap(containerRef, {
+  active,
+  initialFocusRef,
+  returnFocusRef,
+  restoreFocus = true
+}) {
+  const openerRef = useRef(null);
+  if (active && !openerRef.current && typeof document !== "undefined") {
+    openerRef.current = document.activeElement;
+  }
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!active || !container) return;
+    const token = {};
+    activeTraps.push(token);
+    if (!container.contains(document.activeElement)) {
+      const target = initialFocusRef?.current ?? focusableWithin(container)[0] ?? container;
+      if (target === container && !container.hasAttribute("tabindex")) {
+        container.setAttribute("tabindex", "-1");
+      }
+      target.focus();
+    }
+    function onKeyDown(event) {
+      if (event.key !== "Tab" || !container) return;
+      if (activeTraps[activeTraps.length - 1] !== token) return;
+      const items = focusableWithin(container);
+      if (items.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const target = nextFocusTarget(
+        items,
+        document.activeElement,
+        event.shiftKey,
+        container
+      );
+      if (target) {
+        event.preventDefault();
+        target.focus();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      activeTraps.splice(activeTraps.indexOf(token), 1);
+      const opener = returnFocusRef?.current ?? openerRef.current;
+      openerRef.current = null;
+      if (restoreFocus && opener?.isConnected) opener.focus();
+    };
+  }, [active, containerRef, initialFocusRef, returnFocusRef, restoreFocus]);
+}
+export {
+  FOCUSABLE_SELECTOR,
+  focusableWithin,
+  nextFocusTarget,
+  useFocusTrap
+};

package/dist/index.cjs

@@ -0,0 +1,308 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BACK_ZONE_PX: () => BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX: () => CLOSE_DISTANCE_PX,
+  FOCUSABLE_SELECTOR: () => FOCUSABLE_SELECTOR,
+  FORWARD_ZONE_PX: () => FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS: () => MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX: () => OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX: () => VERTICAL_CANCEL_PX,
+  copyText: () => copyText,
+  focusableWithin: () => focusableWithin,
+  isInOpenZone: () => isInOpenZone,
+  isInsideHorizontalScroller: () => isInsideHorizontalScroller,
+  nextFocusTarget: () => nextFocusTarget,
+  resolveSwipeIntent: () => resolveSwipeIntent,
+  useCopyFeedback: () => useCopyFeedback,
+  useDrawerSwipe: () => useDrawerSwipe,
+  useEscape: () => useEscape,
+  useFocusTrap: () => useFocusTrap
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/drawer-swipe/swipe-intent.ts
+var BACK_ZONE_PX = 60;
+var FORWARD_ZONE_PX = 30;
+var OPEN_DISTANCE_PX = 80;
+var CLOSE_DISTANCE_PX = 60;
+var VERTICAL_CANCEL_PX = 40;
+var MAX_SWIPE_DURATION_MS = 450;
+var HORIZONTAL_DOMINANCE = 1.5;
+function isInOpenZone(x, viewportWidth) {
+  return x > BACK_ZONE_PX && x < viewportWidth - FORWARD_ZONE_PX;
+}
+function resolveSwipeIntent(start, end, drawerOpen, viewportWidth) {
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  if (end.time - start.time > MAX_SWIPE_DURATION_MS) return null;
+  if (Math.abs(dx) < Math.abs(dy) * HORIZONTAL_DOMINANCE) return null;
+  if (drawerOpen) {
+    return dx <= -CLOSE_DISTANCE_PX ? "close" : null;
+  }
+  if (dx < OPEN_DISTANCE_PX) return null;
+  return isInOpenZone(start.x, viewportWidth) ? "open" : null;
+}
+function isInsideHorizontalScroller(target) {
+  let node = target instanceof Element ? target : null;
+  while (node && node !== document.body) {
+    const { overflowX } = window.getComputedStyle(node);
+    if ((overflowX === "auto" || overflowX === "scroll") && node.scrollWidth > node.clientWidth) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+
+// src/drawer-swipe/use-drawer-swipe.ts
+var import_react = require("react");
+function isWideViewport(maxViewportWidth) {
+  return window.matchMedia(`(min-width: ${maxViewportWidth}px)`).matches;
+}
+function useDrawerSwipe({
+  drawerOpen,
+  onOpen,
+  onClose,
+  enabled = true,
+  maxViewportWidth = 768
+}) {
+  const start = (0, import_react.useRef)(null);
+  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    function handleStart(event) {
+      start.current = null;
+      if (event.touches.length !== 1) return;
+      if (isWideViewport(handlers.current.maxViewportWidth)) return;
+      if (!handlers.current.drawerOpen && isInsideHorizontalScroller(event.target)) {
+        return;
+      }
+      const touch = event.touches[0];
+      if (!touch) return;
+      start.current = { x: touch.clientX, y: touch.clientY, time: Date.now() };
+    }
+    function handleMove(event) {
+      const origin = start.current;
+      const touch = event.touches[0];
+      if (!origin || !touch) return;
+      if (Math.abs(touch.clientY - origin.y) > VERTICAL_CANCEL_PX) {
+        start.current = null;
+      }
+    }
+    function handleEnd(event) {
+      const origin = start.current;
+      start.current = null;
+      const touch = event.changedTouches[0];
+      if (!origin || !touch) return;
+      const { drawerOpen: drawerOpen2, onOpen: onOpen2, onClose: onClose2 } = handlers.current;
+      const intent = resolveSwipeIntent(
+        origin,
+        { x: touch.clientX, y: touch.clientY, time: Date.now() },
+        drawerOpen2,
+        window.innerWidth
+      );
+      if (intent === "open") onOpen2();
+      if (intent === "close") onClose2();
+    }
+    function handleCancel() {
+      start.current = null;
+    }
+    document.addEventListener("touchstart", handleStart, { passive: true });
+    document.addEventListener("touchmove", handleMove, { passive: true });
+    document.addEventListener("touchend", handleEnd, { passive: true });
+    document.addEventListener("touchcancel", handleCancel, { passive: true });
+    return () => {
+      document.removeEventListener("touchstart", handleStart);
+      document.removeEventListener("touchmove", handleMove);
+      document.removeEventListener("touchend", handleEnd);
+      document.removeEventListener("touchcancel", handleCancel);
+    };
+  }, [enabled]);
+}
+
+// src/focus-trap/focusables.ts
+var FOCUSABLE_SELECTOR = 'a[href], button:not([disabled]), input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+function focusableWithin(container) {
+  return Array.from(
+    container.querySelectorAll(FOCUSABLE_SELECTOR)
+  ).filter((el) => !el.closest("[hidden], [inert]"));
+}
+function nextFocusTarget(items, current, shiftKey, container) {
+  const first = items[0];
+  const last = items[items.length - 1];
+  if (!first || !last) return null;
+  if (!current || !container.contains(current)) return shiftKey ? last : first;
+  if (shiftKey && (current === first || current === container)) return last;
+  if (!shiftKey && current === last) return first;
+  return null;
+}
+
+// src/focus-trap/use-focus-trap.ts
+var import_react2 = require("react");
+var activeTraps = [];
+function useFocusTrap(containerRef, {
+  active,
+  initialFocusRef,
+  returnFocusRef,
+  restoreFocus = true
+}) {
+  const openerRef = (0, import_react2.useRef)(null);
+  if (active && !openerRef.current && typeof document !== "undefined") {
+    openerRef.current = document.activeElement;
+  }
+  (0, import_react2.useEffect)(() => {
+    const container = containerRef.current;
+    if (!active || !container) return;
+    const token = {};
+    activeTraps.push(token);
+    if (!container.contains(document.activeElement)) {
+      const target = initialFocusRef?.current ?? focusableWithin(container)[0] ?? container;
+      if (target === container && !container.hasAttribute("tabindex")) {
+        container.setAttribute("tabindex", "-1");
+      }
+      target.focus();
+    }
+    function onKeyDown(event) {
+      if (event.key !== "Tab" || !container) return;
+      if (activeTraps[activeTraps.length - 1] !== token) return;
+      const items = focusableWithin(container);
+      if (items.length === 0) {
+        event.preventDefault();
+        return;
+      }
+      const target = nextFocusTarget(
+        items,
+        document.activeElement,
+        event.shiftKey,
+        container
+      );
+      if (target) {
+        event.preventDefault();
+        target.focus();
+      }
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      activeTraps.splice(activeTraps.indexOf(token), 1);
+      const opener = returnFocusRef?.current ?? openerRef.current;
+      openerRef.current = null;
+      if (restoreFocus && opener?.isConnected) opener.focus();
+    };
+  }, [active, containerRef, initialFocusRef, returnFocusRef, restoreFocus]);
+}
+
+// src/escape/use-escape.ts
+var import_react3 = require("react");
+function useEscape(onEscape, active = true) {
+  const handlerRef = (0, import_react3.useRef)(onEscape);
+  (0, import_react3.useEffect)(() => {
+    handlerRef.current = onEscape;
+  });
+  (0, import_react3.useEffect)(() => {
+    if (!active) return;
+    function onKeyDown(event) {
+      if (event.key === "Escape") handlerRef.current();
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active]);
+}
+
+// src/clipboard/copy-text.ts
+async function copyText(text) {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.writeText && typeof window !== "undefined" && window.isSecureContext;
+  if (hasClipboardApi) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return { ok: true };
+    } catch {
+    }
+  }
+  if (execCommandCopy(text)) return { ok: true };
+  return { ok: false, reason: hasClipboardApi ? "denied" : "unavailable" };
+}
+function execCommandCopy(text) {
+  if (typeof document === "undefined") return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.readOnly = true;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-1000px";
+  textarea.style.left = "-1000px";
+  textarea.style.fontSize = "16px";
+  document.body.appendChild(textarea);
+  try {
+    textarea.select();
+    textarea.setSelectionRange(0, text.length);
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+  }
+}
+
+// src/clipboard/use-copy-feedback.ts
+var import_react4 = require("react");
+function useCopyFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = (0, import_react4.useState)("idle");
+  const timerRef = (0, import_react4.useRef)(void 0);
+  const clearTimer = (0, import_react4.useCallback)(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  (0, import_react4.useEffect)(() => clearTimer, [clearTimer]);
+  const copy = (0, import_react4.useCallback)(
+    async (text) => {
+      const result = await copyText(text);
+      clearTimer();
+      setStatus(result.ok ? "copied" : "failed");
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { copy, status };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX,
+  FOCUSABLE_SELECTOR,
+  FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX,
+  copyText,
+  focusableWithin,
+  isInOpenZone,
+  isInsideHorizontalScroller,
+  nextFocusTarget,
+  resolveSwipeIntent,
+  useCopyFeedback,
+  useDrawerSwipe,
+  useEscape,
+  useFocusTrap
+});

package/dist/index.d.cts

@@ -0,0 +1,60 @@
+import { RefObject } from 'react';
+
+type SwipePoint = {
+    x: number;
+    y: number;
+    time: number;
+};
+declare const BACK_ZONE_PX = 60;
+declare const FORWARD_ZONE_PX = 30;
+declare const OPEN_DISTANCE_PX = 80;
+declare const CLOSE_DISTANCE_PX = 60;
+declare const VERTICAL_CANCEL_PX = 40;
+declare const MAX_SWIPE_DURATION_MS = 450;
+type SwipeIntent = 'open' | 'close' | null;
+declare function isInOpenZone(x: number, viewportWidth: number): boolean;
+declare function resolveSwipeIntent(start: SwipePoint, end: SwipePoint, drawerOpen: boolean, viewportWidth: number): SwipeIntent;
+declare function isInsideHorizontalScroller(target: EventTarget | null): boolean;
+
+type UseDrawerSwipeOptions = {
+    drawerOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    enabled?: boolean;
+    maxViewportWidth?: number;
+};
+declare function useDrawerSwipe({ drawerOpen, onOpen, onClose, enabled, maxViewportWidth, }: UseDrawerSwipeOptions): void;
+
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+declare function focusableWithin(container: HTMLElement): HTMLElement[];
+/** The element Tab must be redirected to, or null when the browser's own move is fine. */
+declare function nextFocusTarget(items: HTMLElement[], current: Element | null, shiftKey: boolean, container: HTMLElement): HTMLElement | null;
+
+type UseFocusTrapOptions = {
+    active: boolean;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    /** Wins over the captured opener. Safari leaves <body> focused after a tap on a button. */
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    restoreFocus?: boolean;
+};
+declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, { active, initialFocusRef, returnFocusRef, restoreFocus, }: UseFocusTrapOptions): void;
+
+declare function useEscape(onEscape: () => void, active?: boolean): void;
+
+type CopyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'unavailable' | 'denied';
+};
+declare function copyText(text: string): Promise<CopyResult>;
+
+type CopyStatus = 'idle' | 'copied' | 'failed';
+declare function useCopyFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    copy: (text: string) => Promise<CopyResult>;
+    status: CopyStatus;
+};
+
+export { BACK_ZONE_PX, CLOSE_DISTANCE_PX, type CopyResult, type CopyStatus, FOCUSABLE_SELECTOR, FORWARD_ZONE_PX, MAX_SWIPE_DURATION_MS, OPEN_DISTANCE_PX, type SwipeIntent, type SwipePoint, type UseDrawerSwipeOptions, type UseFocusTrapOptions, VERTICAL_CANCEL_PX, copyText, focusableWithin, isInOpenZone, isInsideHorizontalScroller, nextFocusTarget, resolveSwipeIntent, useCopyFeedback, useDrawerSwipe, useEscape, useFocusTrap };

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { RefObject } from 'react';
+
+type SwipePoint = {
+    x: number;
+    y: number;
+    time: number;
+};
+declare const BACK_ZONE_PX = 60;
+declare const FORWARD_ZONE_PX = 30;
+declare const OPEN_DISTANCE_PX = 80;
+declare const CLOSE_DISTANCE_PX = 60;
+declare const VERTICAL_CANCEL_PX = 40;
+declare const MAX_SWIPE_DURATION_MS = 450;
+type SwipeIntent = 'open' | 'close' | null;
+declare function isInOpenZone(x: number, viewportWidth: number): boolean;
+declare function resolveSwipeIntent(start: SwipePoint, end: SwipePoint, drawerOpen: boolean, viewportWidth: number): SwipeIntent;
+declare function isInsideHorizontalScroller(target: EventTarget | null): boolean;
+
+type UseDrawerSwipeOptions = {
+    drawerOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    enabled?: boolean;
+    maxViewportWidth?: number;
+};
+declare function useDrawerSwipe({ drawerOpen, onOpen, onClose, enabled, maxViewportWidth, }: UseDrawerSwipeOptions): void;
+
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), input:not([disabled]):not([type=\"hidden\"]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+declare function focusableWithin(container: HTMLElement): HTMLElement[];
+/** The element Tab must be redirected to, or null when the browser's own move is fine. */
+declare function nextFocusTarget(items: HTMLElement[], current: Element | null, shiftKey: boolean, container: HTMLElement): HTMLElement | null;
+
+type UseFocusTrapOptions = {
+    active: boolean;
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    /** Wins over the captured opener. Safari leaves <body> focused after a tap on a button. */
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    restoreFocus?: boolean;
+};
+declare function useFocusTrap(containerRef: RefObject<HTMLElement | null>, { active, initialFocusRef, returnFocusRef, restoreFocus, }: UseFocusTrapOptions): void;
+
+declare function useEscape(onEscape: () => void, active?: boolean): void;
+
+type CopyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'unavailable' | 'denied';
+};
+declare function copyText(text: string): Promise<CopyResult>;
+
+type CopyStatus = 'idle' | 'copied' | 'failed';
+declare function useCopyFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    copy: (text: string) => Promise<CopyResult>;
+    status: CopyStatus;
+};
+
+export { BACK_ZONE_PX, CLOSE_DISTANCE_PX, type CopyResult, type CopyStatus, FOCUSABLE_SELECTOR, FORWARD_ZONE_PX, MAX_SWIPE_DURATION_MS, OPEN_DISTANCE_PX, type SwipeIntent, type SwipePoint, type UseDrawerSwipeOptions, type UseFocusTrapOptions, VERTICAL_CANCEL_PX, copyText, focusableWithin, isInOpenZone, isInsideHorizontalScroller, nextFocusTarget, resolveSwipeIntent, useCopyFeedback, useDrawerSwipe, useEscape, useFocusTrap };