@develemit/web-hooks 0.1.0 → 0.3.0

package/dist/chunk-JG3GPTMY.js

@@ -0,0 +1,101 @@
+"use client";
+
+// src/service-worker/use-service-worker.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/service-worker/update-state.ts
+function deriveUpdateState({ hasController: hasController2, waiting, installingState }) {
+  if (!hasController2) return false;
+  return waiting || installingState === "installed";
+}
+
+// src/service-worker/register.ts
+var reloaded = false;
+function isServiceWorkerSupported() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator;
+}
+var hasController = () => Boolean(navigator.serviceWorker.controller);
+async function unregisterAll() {
+  if (!isServiceWorkerSupported()) return;
+  try {
+    const registrations = await navigator.serviceWorker.getRegistrations();
+    await Promise.all(registrations.map((r) => r.unregister()));
+  } catch {
+  }
+}
+function registerServiceWorker({ url, scope, onUpdateAvailable }, { reload = () => window.location.reload() } = {}) {
+  let registration;
+  let disposed = false;
+  let applying = false;
+  const cleanups = [];
+  const controlledAtStart = hasController();
+  const onControllerChange = () => {
+    if (!(applying || controlledAtStart) || reloaded) return;
+    reloaded = true;
+    reload();
+  };
+  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+  cleanups.push(() => navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange));
+  const watchInstalling = (reg) => {
+    const worker = reg.installing;
+    if (!worker) return;
+    const onState = () => {
+      if (deriveUpdateState({ hasController: hasController(), waiting: false, installingState: worker.state })) {
+        onUpdateAvailable();
+      }
+    };
+    worker.addEventListener("statechange", onState);
+    cleanups.push(() => worker.removeEventListener("statechange", onState));
+  };
+  navigator.serviceWorker.register(url, scope === void 0 ? void 0 : { scope }).then((reg) => {
+    if (disposed) return;
+    registration = reg;
+    if (deriveUpdateState({ hasController: hasController(), waiting: Boolean(reg.waiting) })) {
+      onUpdateAvailable();
+    }
+    const onUpdateFound = () => watchInstalling(reg);
+    reg.addEventListener("updatefound", onUpdateFound);
+    cleanups.push(() => reg.removeEventListener("updatefound", onUpdateFound));
+  }).catch(() => {
+  });
+  return {
+    applyUpdate() {
+      const waiting = registration?.waiting;
+      if (!waiting) return;
+      applying = true;
+      waiting.postMessage({ type: "SKIP_WAITING" });
+    },
+    dispose() {
+      disposed = true;
+      cleanups.splice(0).forEach((fn) => fn());
+    }
+  };
+}
+
+// src/service-worker/use-service-worker.ts
+function useServiceWorker({ url, scope, enabled = true }) {
+  const [supported, setSupported] = useState(true);
+  const [updateAvailable, setUpdateAvailable] = useState(false);
+  const handle = useRef(void 0);
+  useEffect(() => {
+    if (!enabled) return;
+    if (!isServiceWorkerSupported()) {
+      setSupported(false);
+      return;
+    }
+    const registered = registerServiceWorker({ url, scope, onUpdateAvailable: () => setUpdateAvailable(true) });
+    handle.current = registered;
+    return () => {
+      registered.dispose();
+      handle.current = void 0;
+    };
+  }, [url, scope, enabled]);
+  const applyUpdate = useCallback(() => handle.current?.applyUpdate(), []);
+  return { supported, updateAvailable, applyUpdate };
+}
+
+export {
+  deriveUpdateState,
+  unregisterAll,
+  useServiceWorker
+};

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

@@ -0,0 +1,86 @@
+"use client";
+
+// src/keyboard-inset/use-keyboard-inset.ts
+import { useEffect, useState } from "react";
+
+// src/keyboard-inset/compute-inset.ts
+var DEFAULT_MIN_INSET = 150;
+function computeKeyboardInset(r) {
+  if (!r.editableFocused) return 0;
+  const occluded = r.layoutHeight - r.visualHeight - r.visualOffsetTop;
+  return occluded >= (r.minInset ?? DEFAULT_MIN_INSET) ? Math.round(occluded) : 0;
+}
+var NON_TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "button",
+  "checkbox",
+  "radio",
+  "range",
+  "submit",
+  "reset",
+  "file",
+  "color",
+  "image",
+  "hidden"
+]);
+function isEditableElement(el) {
+  if (!el) return false;
+  const tag = el.tagName.toLowerCase();
+  if (tag === "select") return !el.disabled;
+  if (tag === "textarea" || tag === "input") {
+    const field = el;
+    if (field.readOnly || field.disabled) return false;
+    return tag === "textarea" || !NON_TEXT_INPUT_TYPES.has(field.type);
+  }
+  if (el.isContentEditable === true) return true;
+  const attr = el.getAttribute("contenteditable");
+  return attr !== null && attr !== "false";
+}
+
+// src/keyboard-inset/use-keyboard-inset.ts
+function useKeyboardInset({ minInset = DEFAULT_MIN_INSET, enabled = true } = {}) {
+  const [inset, setInset] = useState(0);
+  useEffect(() => {
+    const vv = typeof window === "undefined" ? null : window.visualViewport;
+    if (!enabled || !vv) {
+      setInset(0);
+      return;
+    }
+    const update = () => setInset(
+      computeKeyboardInset({
+        layoutHeight: window.innerHeight,
+        visualHeight: vv.height,
+        visualOffsetTop: vv.offsetTop,
+        editableFocused: isEditableElement(document.activeElement),
+        minInset
+      })
+    );
+    let frame = 0;
+    const onFocusOut = () => {
+      cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(update);
+    };
+    const onFocusIn = () => {
+      cancelAnimationFrame(frame);
+      update();
+    };
+    vv.addEventListener("resize", update);
+    vv.addEventListener("scroll", update);
+    document.addEventListener("focusin", onFocusIn);
+    document.addEventListener("focusout", onFocusOut);
+    update();
+    return () => {
+      cancelAnimationFrame(frame);
+      vv.removeEventListener("resize", update);
+      vv.removeEventListener("scroll", update);
+      document.removeEventListener("focusin", onFocusIn);
+      document.removeEventListener("focusout", onFocusOut);
+    };
+  }, [enabled, minInset]);
+  return inset;
+}
+
+export {
+  computeKeyboardInset,
+  isEditableElement,
+  useKeyboardInset
+};

package/dist/chunk-UJ366T3Y.js

@@ -0,0 +1,146 @@
+"use client";
+import {
+  isIos,
+  isStandalone
+} from "./chunk-YFMMSLMB.js";
+
+// src/push/use-push-subscription.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/push/support.ts
+function getPushSupport(env = readPushEnv()) {
+  if (env.isIos && !env.isStandalone) return "ios-needs-install";
+  if (!env.hasPushManager || !env.hasServiceWorker || !env.hasNotification) return "unsupported";
+  return "supported";
+}
+function readPushEnv() {
+  const browser = typeof window !== "undefined" && typeof navigator !== "undefined";
+  return {
+    hasPushManager: browser && "PushManager" in window,
+    hasServiceWorker: browser && "serviceWorker" in navigator,
+    hasNotification: browser && "Notification" in window,
+    isIos: browser && isIos(),
+    isStandalone: browser && isStandalone()
+  };
+}
+function readPermission() {
+  if (typeof window === "undefined" || !("Notification" in window)) return "unsupported";
+  return Notification.permission;
+}
+function shouldResubscribe({ permission, hasSubscription, resubscribeOnLoad }) {
+  return resubscribeOnLoad && permission === "granted" && !hasSubscription;
+}
+function isGone(error) {
+  return typeof error === "object" && error !== null && error.status === 410;
+}
+
+// src/push/vapid.ts
+function urlBase64ToUint8Array(key) {
+  const padding = "=".repeat((4 - key.length % 4) % 4);
+  const base64 = (key + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+
+// src/push/register.ts
+function subscribeFresh(reg, vapidPublicKey) {
+  return reg.pushManager.subscribe({
+    userVisibleOnly: true,
+    // lib.dom wants ArrayBufferView<ArrayBuffer>; a Uint8Array satisfies the runtime contract.
+    applicationServerKey: urlBase64ToUint8Array(vapidPublicKey)
+  });
+}
+async function ensureSubscribed(reg, { vapidPublicKey, onSubscribe }, existing) {
+  let sub = existing ?? await reg.pushManager.getSubscription() ?? await subscribeFresh(reg, vapidPublicKey);
+  try {
+    await onSubscribe(sub.toJSON());
+  } catch (error) {
+    if (!isGone(error)) throw error;
+    await sub.unsubscribe();
+    sub = await subscribeFresh(reg, vapidPublicKey);
+    await onSubscribe(sub.toJSON());
+  }
+  return sub;
+}
+
+// src/push/use-push-subscription.ts
+var messageOf = (error, fallback) => error instanceof Error ? error.message : fallback;
+function usePushSubscription(options) {
+  const { resubscribeOnLoad = true } = options;
+  const [support, setSupport] = useState("unsupported");
+  const [permission, setPermission] = useState("unsupported");
+  const [subscribed, setSubscribed] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const latest = useRef(options);
+  latest.current = options;
+  useEffect(() => {
+    const current = getPushSupport();
+    setSupport(current);
+    setPermission(readPermission());
+    if (current !== "supported") return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const reg = await navigator.serviceWorker.ready;
+        const existing = await reg.pushManager.getSubscription();
+        if (cancelled) return;
+        const permissionNow = readPermission();
+        setPermission(permissionNow);
+        if (existing) return setSubscribed(true);
+        if (!shouldResubscribe({ permission: permissionNow, hasSubscription: false, resubscribeOnLoad })) return;
+        await ensureSubscribed(reg, latest.current);
+        if (!cancelled) setSubscribed(true);
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [resubscribeOnLoad]);
+  const subscribe = useCallback(async () => {
+    if (getPushSupport() !== "supported") return;
+    setError(null);
+    setBusy(true);
+    try {
+      const result = await Notification.requestPermission();
+      setPermission(result);
+      if (result !== "granted") return;
+      const reg = await navigator.serviceWorker.ready;
+      await ensureSubscribed(reg, latest.current);
+      setSubscribed(true);
+    } catch (e) {
+      setError(messageOf(e, "subscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const unsubscribe = useCallback(async () => {
+    if (getPushSupport() !== "supported") return;
+    setError(null);
+    setBusy(true);
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      if (sub) {
+        await latest.current.onUnsubscribe(sub.endpoint);
+        await sub.unsubscribe();
+      }
+      setSubscribed(false);
+    } catch (e) {
+      setError(messageOf(e, "unsubscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  return { support, permission, subscribed, busy, error, subscribe, unsubscribe };
+}
+
+export {
+  getPushSupport,
+  shouldResubscribe,
+  urlBase64ToUint8Array,
+  usePushSubscription
+};

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

@@ -0,0 +1,42 @@
+"use client";
+
+// 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);
+}
+
+export {
+  REDUCED_MOTION_QUERY,
+  COARSE_POINTER_QUERY,
+  getMatches,
+  subscribe
+};

package/dist/chunk-WXL22EWK.js

@@ -0,0 +1,21 @@
+"use client";
+
+// src/online-status/use-online-status.ts
+import { useSyncExternalStore } from "react";
+function subscribe(callback) {
+  window.addEventListener("online", callback);
+  window.addEventListener("offline", callback);
+  return () => {
+    window.removeEventListener("online", callback);
+    window.removeEventListener("offline", callback);
+  };
+}
+var getSnapshot = () => navigator.onLine;
+var getServerSnapshot = () => true;
+function useOnlineStatus() {
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+export {
+  useOnlineStatus
+};

package/dist/chunk-YFMMSLMB.js

@@ -0,0 +1,41 @@
+"use client";
+
+// src/pwa/detect.ts
+var IOS_UA = /iPhone|iPad|iPod/;
+var IOS_OTHER_BROWSER = /CriOS|FxiOS|EdgiOS|OPiOS/;
+var IN_APP_WEBVIEW = /FBAN|FBAV|Instagram/;
+var STANDALONE_QUERY = "(display-mode: standalone)";
+function detectPlatform(env) {
+  const isIos2 = IOS_UA.test(env.userAgent) || env.platform === "MacIntel" && env.maxTouchPoints > 1;
+  const isIosSafari2 = isIos2 && !IOS_OTHER_BROWSER.test(env.userAgent) && !IN_APP_WEBVIEW.test(env.userAgent);
+  return { isIos: isIos2, isIosSafari: isIosSafari2, isStandalone: env.standaloneMedia || env.navigatorStandalone };
+}
+function readStandaloneMedia() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+  return window.matchMedia(STANDALONE_QUERY).matches;
+}
+function readNavigatorStandalone() {
+  if (typeof navigator === "undefined") return false;
+  return navigator.standalone === true;
+}
+function readPlatform() {
+  if (typeof navigator === "undefined") return { isIos: false, isIosSafari: false, isStandalone: false };
+  return detectPlatform({
+    userAgent: navigator.userAgent ?? "",
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? 0,
+    standaloneMedia: readStandaloneMedia(),
+    navigatorStandalone: readNavigatorStandalone()
+  });
+}
+var isStandalone = () => readPlatform().isStandalone;
+var isIos = () => readPlatform().isIos;
+var isIosSafari = () => readPlatform().isIosSafari;
+
+export {
+  STANDALONE_QUERY,
+  detectPlatform,
+  isStandalone,
+  isIos,
+  isIosSafari
+};