@develemit/web-hooks 0.1.0 → 0.2.0

package/dist/chunk-DNU57XEJ.js

@@ -0,0 +1,82 @@
+"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(() => {
+    if (!active) openerRef.current = null;
+  }, [active]);
+  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;
+      if (restoreFocus && opener?.isConnected) opener.focus();
+    };
+  }, [active, containerRef, initialFocusRef, returnFocusRef, restoreFocus]);
+}
+
+export {
+  FOCUSABLE_SELECTOR,
+  focusableWithin,
+  nextFocusTarget,
+  useFocusTrap
+};

package/dist/chunk-IWQDAJEP.js

@@ -0,0 +1,69 @@
+"use client";
+
+// src/debounce/debouncer.ts
+function createDebouncer(getFn, getMs) {
+  let timer;
+  let pending;
+  function clear() {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    pending = void 0;
+  }
+  function run() {
+    const args = pending;
+    clear();
+    if (args) getFn()(...args);
+  }
+  return {
+    call(...args) {
+      if (timer !== void 0) clearTimeout(timer);
+      pending = args;
+      timer = setTimeout(run, getMs());
+    },
+    cancel: clear,
+    flush() {
+      if (pending) run();
+    },
+    isPending: () => pending !== void 0
+  };
+}
+
+// src/debounce/use-debounced-value.ts
+import { useEffect, useState } from "react";
+function useDebouncedValue(value, ms) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebounced(value), ms);
+    return () => clearTimeout(timer);
+  }, [value, ms]);
+  return debounced;
+}
+
+// src/debounce/use-debounced-callback.ts
+import { useEffect as useEffect2, useRef, useState as useState2 } from "react";
+function useDebouncedCallback(fn, ms) {
+  const fnRef = useRef(fn);
+  const msRef = useRef(ms);
+  useEffect2(() => {
+    fnRef.current = fn;
+    msRef.current = ms;
+  });
+  const [debounced] = useState2(() => {
+    const debouncer = createDebouncer(
+      () => fnRef.current,
+      () => msRef.current
+    );
+    return Object.assign((...args) => debouncer.call(...args), {
+      cancel: debouncer.cancel,
+      flush: debouncer.flush
+    });
+  });
+  useEffect2(() => () => debounced.cancel(), [debounced]);
+  return debounced;
+}
+
+export {
+  createDebouncer,
+  useDebouncedValue,
+  useDebouncedCallback
+};

package/dist/chunk-LZKAGDER.js

@@ -0,0 +1,22 @@
+"use client";
+
+// src/unsaved-guard/handle-before-unload.ts
+function handleBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+
+// src/unsaved-guard/use-unsaved-changes-guard.ts
+import { useEffect } from "react";
+function useUnsavedChangesGuard(dirty) {
+  useEffect(() => {
+    if (!dirty) return;
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+  }, [dirty]);
+}
+
+export {
+  handleBeforeUnload,
+  useUnsavedChangesGuard
+};

package/dist/chunk-NKLEB5TR.js

@@ -0,0 +1,98 @@
+"use client";
+
+// src/hotkey/parse-hotkey.ts
+var KEY_ALIASES = {
+  esc: "escape",
+  space: " ",
+  plus: "+",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright"
+};
+function parseHotkey(combo) {
+  const parsed = { key: "", mod: false, ctrl: false, meta: false, alt: false, shift: false };
+  const parts = combo.trim().toLowerCase().split(/\+(?=.)/);
+  for (const part of parts) {
+    const token = part.trim();
+    if (token === "mod" || token === "ctrl" || token === "meta" || token === "alt" || token === "shift") {
+      parsed[token] = true;
+    } else {
+      parsed.key = KEY_ALIASES[token] ?? token;
+    }
+  }
+  if (!parsed.key) throw new Error(`Invalid hotkey "${combo}": no key`);
+  return parsed;
+}
+
+// src/hotkey/match-hotkey.ts
+var CODE_FOR_SYMBOL = {
+  "/": "Slash",
+  ".": "Period",
+  ",": "Comma",
+  ";": "Semicolon",
+  "'": "Quote",
+  "[": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  "-": "Minus",
+  "=": "Equal",
+  "`": "Backquote"
+};
+function physicalCode(key) {
+  if (/^[a-z]$/.test(key)) return `Key${key.toUpperCase()}`;
+  if (/^[0-9]$/.test(key)) return `Digit${key}`;
+  return CODE_FOR_SYMBOL[key] ?? null;
+}
+function keyMatches(event, parsed) {
+  if (event.key.toLowerCase() === parsed.key) return true;
+  return parsed.shift && physicalCode(parsed.key) === event.code;
+}
+function matchHotkey(event, combo, isApple) {
+  const parsed = typeof combo === "string" ? parseHotkey(combo) : combo;
+  const wantMeta = parsed.meta || parsed.mod && isApple;
+  const wantCtrl = parsed.ctrl || parsed.mod && !isApple;
+  return event.metaKey === wantMeta && event.ctrlKey === wantCtrl && event.altKey === parsed.alt && event.shiftKey === parsed.shift && keyMatches(event, parsed);
+}
+function detectApple(nav) {
+  if (!nav) return false;
+  const platform = nav.userAgentData?.platform || nav.platform || "";
+  return /mac|iphone|ipad|ipod/i.test(platform);
+}
+function isEditableTarget(target) {
+  const el = target;
+  if (!el || typeof el.tagName !== "string") return false;
+  const tag = el.tagName.toLowerCase();
+  return tag === "input" || tag === "textarea" || tag === "select" || el.isContentEditable === true;
+}
+
+// src/hotkey/use-hotkey.ts
+import { useEffect, useRef } from "react";
+function useHotkey(combo, onHotkey, options = {}) {
+  const { enabled = true, allowInInputs = false, preventDefault = true } = options;
+  const handlerRef = useRef(onHotkey);
+  useEffect(() => {
+    handlerRef.current = onHotkey;
+  });
+  useEffect(() => {
+    if (!enabled) return;
+    const parsed = parseHotkey(combo);
+    function onKeyDown(event) {
+      if (event.isComposing || event.keyCode === 229) return;
+      if (!allowInInputs && isEditableTarget(event.target)) return;
+      if (!matchHotkey(event, parsed, detectApple(navigator))) return;
+      if (preventDefault) event.preventDefault();
+      handlerRef.current(event);
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [combo, enabled, allowInInputs, preventDefault]);
+}
+
+export {
+  parseHotkey,
+  matchHotkey,
+  detectApple,
+  isEditableTarget,
+  useHotkey
+};

package/dist/chunk-OZ4PU4E3.js

@@ -0,0 +1,115 @@
+"use client";
+
+// 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
+import { useEffect, useRef } from "react";
+function isWideViewport(maxViewportWidth) {
+  return window.matchMedia(`(min-width: ${maxViewportWidth}px)`).matches;
+}
+function useDrawerSwipe({
+  drawerOpen,
+  onOpen,
+  onClose,
+  enabled = true,
+  maxViewportWidth = 768
+}) {
+  const start = useRef(null);
+  const handlers = useRef({ drawerOpen, onOpen, onClose, maxViewportWidth });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  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]);
+}
+
+export {
+  BACK_ZONE_PX,
+  FORWARD_ZONE_PX,
+  OPEN_DISTANCE_PX,
+  CLOSE_DISTANCE_PX,
+  VERTICAL_CANCEL_PX,
+  MAX_SWIPE_DURATION_MS,
+  isInOpenZone,
+  resolveSwipeIntent,
+  isInsideHorizontalScroller,
+  useDrawerSwipe
+};

package/dist/chunk-S4YKMGQE.js

@@ -0,0 +1,23 @@
+"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.isComposing || event.keyCode === 229) return;
+      if (event.key === "Escape") handlerRef.current();
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active]);
+}
+
+export {
+  useEscape
+};

package/dist/chunk-UPVNSGIK.js

@@ -0,0 +1,72 @@
+"use client";
+
+// src/visibility-polling/schedule.ts
+function nextDelay(intervalMs, jitter, random) {
+  const fraction = Math.min(1, Math.max(0, jitter));
+  return intervalMs + random() * fraction * intervalMs;
+}
+
+// src/visibility-polling/use-visibility-polling.ts
+import { useEffect, useRef } from "react";
+var isHidden = () => document.visibilityState === "hidden";
+function useVisibilityPolling(fn, intervalMs, { enabled = true, immediate = true, jitter = 0, runOnVisible = true } = {}) {
+  const fnRef = useRef(fn);
+  const optionsRef = useRef({ immediate, jitter, runOnVisible });
+  useEffect(() => {
+    fnRef.current = fn;
+    optionsRef.current = { immediate, jitter, runOnVisible };
+  });
+  const runningRef = useRef(false);
+  const scheduleRef = useRef(null);
+  useEffect(() => {
+    if (!enabled) return;
+    let active = true;
+    let timer = null;
+    function clearTimer() {
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+    }
+    function schedule() {
+      clearTimer();
+      if (!active || isHidden()) return;
+      timer = setTimeout(run, nextDelay(intervalMs, optionsRef.current.jitter, Math.random));
+    }
+    async function run() {
+      timer = null;
+      if (!active || runningRef.current || isHidden()) return;
+      runningRef.current = true;
+      try {
+        await fnRef.current();
+      } catch {
+      } finally {
+        runningRef.current = false;
+      }
+      scheduleRef.current?.();
+    }
+    function onVisibilityChange() {
+      if (isHidden()) {
+        clearTimer();
+      } else if (optionsRef.current.runOnVisible) {
+        clearTimer();
+        void run();
+      } else if (!runningRef.current) {
+        schedule();
+      }
+    }
+    scheduleRef.current = schedule;
+    if (optionsRef.current.immediate && !isHidden()) void run();
+    else schedule();
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      active = false;
+      scheduleRef.current = null;
+      clearTimer();
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  }, [enabled, intervalMs]);
+}
+
+export {
+  nextDelay,
+  useVisibilityPolling
+};

package/dist/chunk-UZADAINO.js

@@ -0,0 +1,61 @@
+"use client";
+
+// src/media-query/use-media-query.ts
+import { useCallback, useSyncExternalStore } from "react";
+
+// src/media-query/media-query.ts
+var REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+var COARSE_POINTER_QUERY = "(pointer: coarse)";
+var lists = /* @__PURE__ */ new WeakMap();
+function getList(query) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return null;
+  const owner = window.matchMedia;
+  let byQuery = lists.get(owner);
+  if (!byQuery) {
+    byQuery = /* @__PURE__ */ new Map();
+    lists.set(owner, byQuery);
+  }
+  let list = byQuery.get(query);
+  if (!list) {
+    list = owner.call(window, query);
+    byQuery.set(query, list);
+  }
+  return list;
+}
+function getMatches(query) {
+  return getList(query)?.matches ?? null;
+}
+function subscribe(query, onChange) {
+  const list = getList(query);
+  if (!list) return () => {
+  };
+  if (typeof list.addEventListener === "function") {
+    list.addEventListener("change", onChange);
+    return () => list.removeEventListener("change", onChange);
+  }
+  list.addListener(onChange);
+  return () => list.removeListener(onChange);
+}
+
+// src/media-query/use-media-query.ts
+function useMediaQuery(query, options = {}) {
+  const serverDefault = options.serverDefault ?? false;
+  const subscribeToQuery = useCallback((onChange) => subscribe(query, onChange), [query]);
+  const getSnapshot = useCallback(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
+  const getServerSnapshot = useCallback(() => serverDefault, [serverDefault]);
+  return useSyncExternalStore(subscribeToQuery, getSnapshot, getServerSnapshot);
+}
+function useReducedMotion(options) {
+  return useMediaQuery(REDUCED_MOTION_QUERY, options);
+}
+function useCoarsePointer(options) {
+  return useMediaQuery(COARSE_POINTER_QUERY, options);
+}
+
+export {
+  REDUCED_MOTION_QUERY,
+  COARSE_POINTER_QUERY,
+  useMediaQuery,
+  useReducedMotion,
+  useCoarsePointer
+};

package/dist/clipboard.cjs

@@ -48,8 +48,10 @@ function execCommandCopy(text) {
   textarea.style.top = "-1000px";
   textarea.style.left = "-1000px";
   textarea.style.fontSize = "16px";
+  const previouslyFocused = document.activeElement;
   document.body.appendChild(textarea);
   try {
+    textarea.focus({ preventScroll: true });
     textarea.select();
     textarea.setSelectionRange(0, text.length);
     return document.execCommand("copy");
@@ -57,6 +59,9 @@ function execCommandCopy(text) {
     return false;
   } finally {
     document.body.removeChild(textarea);
+    if (previouslyFocused instanceof HTMLElement && previouslyFocused !== document.body) {
+      previouslyFocused.focus({ preventScroll: true });
+    }
   }
 }
 

package/dist/clipboard.js

@@ -1,61 +1,8 @@
 "use client";
-
-// 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
-import { useCallback, useEffect, useRef, useState } from "react";
-function useCopyFeedback({ resetMs = 1500 } = {}) {
-  const [status, setStatus] = useState("idle");
-  const timerRef = useRef(void 0);
-  const clearTimer = useCallback(() => {
-    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
-    timerRef.current = void 0;
-  }, []);
-  useEffect(() => clearTimer, [clearTimer]);
-  const copy = 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 };
-}
+import {
+  copyText,
+  useCopyFeedback
+} from "./chunk-3CACI4OQ.js";
 export {
   copyText,
   useCopyFeedback