@develemit/web-hooks 0.1.0 → 0.3.0

package/dist/chunk-5KIH2XLV.js

@@ -0,0 +1,136 @@
+"use client";
+
+// src/storage-state/use-storage-state.ts
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+
+// src/storage-state/storage-store.ts
+function getStorage(kind) {
+  try {
+    if (typeof window === "undefined") return null;
+    return kind === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function readRaw(storage, key) {
+  try {
+    return storage ? storage.getItem(key) : null;
+  } catch {
+    return null;
+  }
+}
+function writeRaw(storage, key, value) {
+  try {
+    if (!storage) return false;
+    storage.setItem(key, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeRaw(storage, key) {
+  try {
+    if (!storage) return false;
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseOr(raw, parse, fallback) {
+  if (raw === null) return fallback;
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+var slot = (kind, key) => `${kind}\0${key}`;
+var memory = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Map();
+function readCurrent(kind, key) {
+  const held = memory.get(slot(kind, key));
+  if (held !== void 0) return held;
+  return readRaw(getStorage(kind), key);
+}
+function notify(id) {
+  for (const listener of [...listeners.get(id) ?? []]) listener();
+}
+function writeCurrent(kind, key, raw) {
+  const id = slot(kind, key);
+  if (writeRaw(getStorage(kind), key, raw)) memory.delete(id);
+  else memory.set(id, raw);
+  notify(id);
+}
+function removeCurrent(kind, key) {
+  const id = slot(kind, key);
+  if (removeRaw(getStorage(kind), key)) memory.delete(id);
+  else memory.set(id, null);
+  notify(id);
+}
+function onStorageEvent(event) {
+  const kinds = [];
+  if (!event.storageArea || event.storageArea === getStorage("local")) kinds.push("local");
+  if (!event.storageArea || event.storageArea === getStorage("session")) kinds.push("session");
+  for (const id of [...listeners.keys()]) {
+    const [kind, key] = id.split("\0");
+    if (!kinds.includes(kind)) continue;
+    if (event.key !== null && event.key !== key) continue;
+    memory.delete(id);
+    notify(id);
+  }
+}
+function subscribeToKey(kind, key, listener) {
+  const id = slot(kind, key);
+  const wasEmpty = listeners.size === 0;
+  let set = listeners.get(id);
+  if (!set) listeners.set(id, set = /* @__PURE__ */ new Set());
+  set.add(listener);
+  if (wasEmpty) window.addEventListener("storage", onStorageEvent);
+  return () => {
+    const current = listeners.get(id);
+    current?.delete(listener);
+    if (current?.size === 0) listeners.delete(id);
+    if (listeners.size === 0) window.removeEventListener("storage", onStorageEvent);
+  };
+}
+
+// src/storage-state/use-storage-state.ts
+function useStorageState(key, defaultValue, options = {}) {
+  const kind = options.storage ?? "local";
+  const serialize = options.serialize ?? JSON.stringify;
+  const parse = options.parse ?? JSON.parse;
+  const latest = useRef({ serialize, parse, defaultValue });
+  useEffect(() => {
+    latest.current = { serialize, parse, defaultValue };
+  });
+  const cache = useRef(null);
+  const subscribe = useCallback((onChange) => subscribeToKey(kind, key, onChange), [kind, key]);
+  const getSnapshot = useCallback(() => {
+    const raw = readCurrent(kind, key);
+    const hit = cache.current;
+    if (hit && hit.kind === kind && hit.key === key && hit.raw === raw && hit.parse === parse) return hit.value;
+    const value2 = parseOr(raw, parse, defaultValue);
+    cache.current = { kind, key, raw, parse, value: value2 };
+    return value2;
+  }, [kind, key, parse, defaultValue]);
+  const getServerSnapshot = useCallback(() => defaultValue, [defaultValue]);
+  const value = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const set = useCallback(
+    (next) => {
+      const { serialize: encode, parse: decode, defaultValue: fallback } = latest.current;
+      try {
+        const resolved = typeof next === "function" ? next(parseOr(readCurrent(kind, key), decode, fallback)) : next;
+        writeCurrent(kind, key, encode(resolved));
+      } catch {
+      }
+    },
+    [kind, key]
+  );
+  const remove = useCallback(() => removeCurrent(kind, key), [kind, key]);
+  return [value, set, remove];
+}
+
+export {
+  useStorageState
+};

package/dist/chunk-5XRVPZHD.js

@@ -0,0 +1,125 @@
+"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, startedInIgnoredRegion = false) {
+  if (startedInIgnoredRegion) return null;
+  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;
+}
+var DEFAULT_IGNORE_SELECTOR = "[data-no-swipe]";
+function isInIgnoredRegion(target, selector) {
+  if (!selector || !(target instanceof Element)) return false;
+  return target.closest(selector) !== null;
+}
+
+// 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,
+  ignoreSelector = DEFAULT_IGNORE_SELECTOR
+}) {
+  const start = useRef(null);
+  const handlers = useRef({ drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector };
+  useEffect(() => {
+    if (!enabled) return;
+    function handleStart(event) {
+      start.current = null;
+      if (event.touches.length !== 1) return;
+      if (isWideViewport(handlers.current.maxViewportWidth)) return;
+      if (isInIgnoredRegion(event.target, handlers.current.ignoreSelector)) 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,
+  DEFAULT_IGNORE_SELECTOR,
+  isInIgnoredRegion,
+  useDrawerSwipe
+};

package/dist/chunk-6KCRVSLS.js

@@ -0,0 +1,80 @@
+"use client";
+
+// src/scroll-lock/use-scroll-lock.ts
+import { useEffect } from "react";
+
+// src/scroll-lock/lock-styles.ts
+var LOCKED_PROPERTIES = [
+  "position",
+  "top",
+  "left",
+  "right",
+  "width",
+  "overflow",
+  "paddingRight"
+];
+function computeLockStyles({ scrollY, scrollbarWidth, existingPaddingRight }) {
+  const styles = {
+    position: "fixed",
+    top: `-${scrollY}px`,
+    left: "0",
+    right: "0",
+    width: "100%",
+    overflow: "hidden"
+  };
+  if (scrollbarWidth > 0) styles.paddingRight = `${existingPaddingRight + scrollbarWidth}px`;
+  return styles;
+}
+
+// src/scroll-lock/scroll-lock.ts
+var count = 0;
+var saved = null;
+function applyFirstLock() {
+  const { body, documentElement } = document;
+  const inline = {};
+  for (const property of LOCKED_PROPERTIES) inline[property] = body.style[property];
+  saved = { scrollY: window.scrollY, inline };
+  const styles = computeLockStyles({
+    scrollY: saved.scrollY,
+    scrollbarWidth: Math.max(0, window.innerWidth - documentElement.clientWidth),
+    existingPaddingRight: parseFloat(getComputedStyle(body).paddingRight) || 0
+  });
+  Object.assign(body.style, styles);
+}
+function restoreLastLock() {
+  if (!saved) return;
+  const { scrollY, inline } = saved;
+  saved = null;
+  Object.assign(document.body.style, inline);
+  window.scrollTo(0, scrollY);
+}
+function lockScroll() {
+  if (count === 0) applyFirstLock();
+  count += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    count -= 1;
+    if (count === 0) restoreLastLock();
+  };
+}
+function unlockScroll() {
+  if (count === 0) return;
+  count -= 1;
+  if (count === 0) restoreLastLock();
+}
+
+// src/scroll-lock/use-scroll-lock.ts
+function useScrollLock(active = true) {
+  useEffect(() => {
+    if (!active) return;
+    return lockScroll();
+  }, [active]);
+}
+
+export {
+  lockScroll,
+  unlockScroll,
+  useScrollLock
+};

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-DQBKU7HI.js

@@ -0,0 +1,46 @@
+"use client";
+
+// src/outside-press/outside-press.ts
+function isOutside(target, elements, ignoreSelector) {
+  if (!target) return false;
+  if (!target.isConnected) return false;
+  if (ignoreSelector && isInIgnoredRegion(target, ignoreSelector)) return false;
+  return !elements.some((el) => el?.contains(target));
+}
+function isPrimaryPress(event) {
+  return !(event.pointerType === "mouse" && event.button !== 0);
+}
+function isInIgnoredRegion(target, selector) {
+  const element = target instanceof Element ? target : target.parentElement;
+  return element?.closest(selector) != null;
+}
+
+// src/outside-press/use-outside-press.ts
+import { useEffect, useRef } from "react";
+function useOutsidePress(refs, onOutsidePress, { enabled = true, ignore } = {}) {
+  const refsRef = useRef(refs);
+  const handlerRef = useRef(onOutsidePress);
+  const ignoreRef = useRef(ignore);
+  useEffect(() => {
+    ignoreRef.current = ignore;
+    refsRef.current = refs;
+    handlerRef.current = onOutsidePress;
+  });
+  useEffect(() => {
+    if (!enabled) return;
+    function onPointerDown(event) {
+      if (!isPrimaryPress(event)) return;
+      const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];
+      const elements = list.map((ref) => ref.current);
+      if (isOutside(event.target, elements, ignoreRef.current)) handlerRef.current(event);
+    }
+    document.addEventListener("pointerdown", onPointerDown, true);
+    return () => document.removeEventListener("pointerdown", onPointerDown, true);
+  }, [enabled]);
+}
+
+export {
+  isOutside,
+  isPrimaryPress,
+  useOutsidePress
+};

package/dist/chunk-EXEJI4FK.js

@@ -0,0 +1,43 @@
+"use client";
+import {
+  copyText
+} from "./chunk-FE3BQD2I.js";
+
+// 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 };
+}
+
+// src/clipboard/read-text.ts
+async function readText() {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.readText && typeof window !== "undefined" && window.isSecureContext;
+  if (!hasClipboardApi) return { ok: false, reason: "unavailable" };
+  try {
+    return { ok: true, text: await navigator.clipboard.readText() };
+  } catch {
+    return { ok: false, reason: "denied" };
+  }
+}
+
+export {
+  useCopyFeedback,
+  readText
+};

package/dist/chunk-FE3BQD2I.js

@@ -0,0 +1,44 @@
+"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";
+  const previouslyFocused = document.activeElement;
+  document.body.appendChild(textarea);
+  try {
+    textarea.focus({ preventScroll: true });
+    textarea.select();
+    textarea.setSelectionRange(0, text.length);
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+    if (previouslyFocused instanceof HTMLElement && previouslyFocused !== document.body) {
+      previouslyFocused.focus({ preventScroll: true });
+    }
+  }
+}
+
+export {
+  copyText
+};

package/dist/chunk-HTVNN2NM.js

@@ -0,0 +1,29 @@
+"use client";
+import {
+  COARSE_POINTER_QUERY,
+  REDUCED_MOTION_QUERY,
+  getMatches,
+  subscribe
+} from "./chunk-WVM2LTWQ.js";
+
+// src/media-query/use-media-query.ts
+import { useCallback, useSyncExternalStore } from "react";
+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 {
+  useMediaQuery,
+  useReducedMotion,
+  useCoarsePointer
+};

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
+};