@develemit/web-hooks 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -24,30 +24,49 @@ __export(src_exports, {
   BACK_ZONE_PX: () => BACK_ZONE_PX,
   CLOSE_DISTANCE_PX: () => CLOSE_DISTANCE_PX,
   COARSE_POINTER_QUERY: () => COARSE_POINTER_QUERY,
+  DEFAULT_IGNORE_SELECTOR: () => DEFAULT_IGNORE_SELECTOR,
   FOCUSABLE_SELECTOR: () => FOCUSABLE_SELECTOR,
   FORWARD_ZONE_PX: () => FORWARD_ZONE_PX,
   MAX_SWIPE_DURATION_MS: () => MAX_SWIPE_DURATION_MS,
   OPEN_DISTANCE_PX: () => OPEN_DISTANCE_PX,
   REDUCED_MOTION_QUERY: () => REDUCED_MOTION_QUERY,
   VERTICAL_CANCEL_PX: () => VERTICAL_CANCEL_PX,
+  canShareFiles: () => canShareFiles,
+  computeKeyboardInset: () => computeKeyboardInset,
   copyText: () => copyText,
   createDebouncer: () => createDebouncer,
+  deriveUpdateState: () => deriveUpdateState,
   detectApple: () => detectApple,
+  detectPlatform: () => detectPlatform,
   focusableWithin: () => focusableWithin,
+  getPushSupport: () => getPushSupport,
   handleBeforeUnload: () => handleBeforeUnload,
+  isEditableElement: () => isEditableElement,
   isEditableTarget: () => isEditableTarget,
+  isInIgnoredRegion: () => isInIgnoredRegion,
   isInOpenZone: () => isInOpenZone,
   isInsideHorizontalScroller: () => isInsideHorizontalScroller,
+  isIos: () => isIos,
+  isIosSafari: () => isIosSafari,
   isOutside: () => isOutside,
   isPrimaryPress: () => isPrimaryPress,
+  isShareCancel: () => isShareCancel,
+  isStandalone: () => isStandalone,
   lockScroll: () => lockScroll,
   matchHotkey: () => matchHotkey,
   nextDelay: () => nextDelay,
   nextFocusTarget: () => nextFocusTarget,
   nextHeight: () => nextHeight,
   parseHotkey: () => parseHotkey,
+  readText: () => readText,
   resolveSwipeIntent: () => resolveSwipeIntent,
+  shareOrCopy: () => shareOrCopy,
+  shareTextFor: () => shareTextFor,
+  shouldResubscribe: () => shouldResubscribe,
+  startInstallPromptCapture: () => startInstallPromptCapture,
   unlockScroll: () => unlockScroll,
+  unregisterAll: () => unregisterAll,
+  urlBase64ToUint8Array: () => urlBase64ToUint8Array,
   useAutoGrowTextarea: () => useAutoGrowTextarea,
   useCoarsePointer: () => useCoarsePointer,
   useCopyFeedback: () => useCopyFeedback,
@@ -57,10 +76,17 @@ __export(src_exports, {
   useEscape: () => useEscape,
   useFocusTrap: () => useFocusTrap,
   useHotkey: () => useHotkey,
+  useInstallPrompt: () => useInstallPrompt,
+  useIsStandalone: () => useIsStandalone,
+  useKeyboardInset: () => useKeyboardInset,
   useMediaQuery: () => useMediaQuery,
+  useOnlineStatus: () => useOnlineStatus,
   useOutsidePress: () => useOutsidePress,
+  usePushSubscription: () => usePushSubscription,
   useReducedMotion: () => useReducedMotion,
   useScrollLock: () => useScrollLock,
+  useServiceWorker: () => useServiceWorker,
+  useShareFeedback: () => useShareFeedback,
   useStorageState: () => useStorageState,
   useUnsavedChangesGuard: () => useUnsavedChangesGuard,
   useVisibilityPolling: () => useVisibilityPolling
@@ -78,7 +104,8 @@ 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) {
+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;
@@ -100,6 +127,11 @@ function isInsideHorizontalScroller(target) {
   }
   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
 var import_react = require("react");
@@ -111,17 +143,19 @@ function useDrawerSwipe({
   onOpen,
   onClose,
   enabled = true,
-  maxViewportWidth = 768
+  maxViewportWidth = 768,
+  ignoreSelector = DEFAULT_IGNORE_SELECTOR
 }) {
   const start = (0, import_react.useRef)(null);
-  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth });
-  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector };
   (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 (isInIgnoredRegion(event.target, handlers.current.ignoreSelector)) return;
       if (!handlers.current.drawerOpen && isInsideHorizontalScroller(event.target)) {
         return;
       }
@@ -322,6 +356,17 @@ function useCopyFeedback({ resetMs = 1500 } = {}) {
   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" };
+  }
+}
+
 // src/scroll-lock/use-scroll-lock.ts
 var import_react5 = require("react");
 
@@ -436,9 +481,9 @@ function subscribe(query, onChange) {
 function useMediaQuery(query, options = {}) {
   const serverDefault = options.serverDefault ?? false;
   const subscribeToQuery = (0, import_react6.useCallback)((onChange) => subscribe(query, onChange), [query]);
-  const getSnapshot = (0, import_react6.useCallback)(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
-  const getServerSnapshot = (0, import_react6.useCallback)(() => serverDefault, [serverDefault]);
-  return (0, import_react6.useSyncExternalStore)(subscribeToQuery, getSnapshot, getServerSnapshot);
+  const getSnapshot2 = (0, import_react6.useCallback)(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
+  const getServerSnapshot2 = (0, import_react6.useCallback)(() => serverDefault, [serverDefault]);
+  return (0, import_react6.useSyncExternalStore)(subscribeToQuery, getSnapshot2, getServerSnapshot2);
 }
 function useReducedMotion(options) {
   return useMediaQuery(REDUCED_MOTION_QUERY, options);
@@ -448,21 +493,28 @@ function useCoarsePointer(options) {
 }
 
 // src/outside-press/outside-press.ts
-function isOutside(target, elements) {
+function isOutside(target, elements, ignoreSelector) {
   if (!target) return false;
   if (!target.isConnected) return false;
+  if (ignoreSelector && isInIgnoredRegion2(target, ignoreSelector)) return false;
   return !elements.some((el) => el?.contains(target));
 }
 function isPrimaryPress(event) {
   return !(event.pointerType === "mouse" && event.button !== 0);
 }
+function isInIgnoredRegion2(target, selector) {
+  const element = target instanceof Element ? target : target.parentElement;
+  return element?.closest(selector) != null;
+}
 
 // src/outside-press/use-outside-press.ts
 var import_react7 = require("react");
-function useOutsidePress(refs, onOutsidePress, { enabled = true } = {}) {
+function useOutsidePress(refs, onOutsidePress, { enabled = true, ignore } = {}) {
   const refsRef = (0, import_react7.useRef)(refs);
   const handlerRef = (0, import_react7.useRef)(onOutsidePress);
+  const ignoreRef = (0, import_react7.useRef)(ignore);
   (0, import_react7.useEffect)(() => {
+    ignoreRef.current = ignore;
     refsRef.current = refs;
     handlerRef.current = onOutsidePress;
   });
@@ -472,7 +524,7 @@ function useOutsidePress(refs, onOutsidePress, { enabled = true } = {}) {
       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)) handlerRef.current(event);
+      if (isOutside(event.target, elements, ignoreRef.current)) handlerRef.current(event);
     }
     document.addEventListener("pointerdown", onPointerDown, true);
     return () => document.removeEventListener("pointerdown", onPointerDown, true);
@@ -690,9 +742,9 @@ function onStorageEvent(event) {
 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);
+  let set2 = listeners.get(id);
+  if (!set2) listeners.set(id, set2 = /* @__PURE__ */ new Set());
+  set2.add(listener);
   if (wasEmpty) window.addEventListener("storage", onStorageEvent);
   return () => {
     const current = listeners.get(id);
@@ -712,8 +764,8 @@ function useStorageState(key, defaultValue, options = {}) {
     latest.current = { serialize, parse, defaultValue };
   });
   const cache = (0, import_react11.useRef)(null);
-  const subscribe2 = (0, import_react11.useCallback)((onChange) => subscribeToKey(kind, key, onChange), [kind, key]);
-  const getSnapshot = (0, import_react11.useCallback)(() => {
+  const subscribe3 = (0, import_react11.useCallback)((onChange) => subscribeToKey(kind, key, onChange), [kind, key]);
+  const getSnapshot2 = (0, import_react11.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;
@@ -721,9 +773,9 @@ function useStorageState(key, defaultValue, options = {}) {
     cache.current = { kind, key, raw, parse, value: value2 };
     return value2;
   }, [kind, key, parse, defaultValue]);
-  const getServerSnapshot = (0, import_react11.useCallback)(() => defaultValue, [defaultValue]);
-  const value = (0, import_react11.useSyncExternalStore)(subscribe2, getSnapshot, getServerSnapshot);
-  const set = (0, import_react11.useCallback)(
+  const getServerSnapshot2 = (0, import_react11.useCallback)(() => defaultValue, [defaultValue]);
+  const value = (0, import_react11.useSyncExternalStore)(subscribe3, getSnapshot2, getServerSnapshot2);
+  const set2 = (0, import_react11.useCallback)(
     (next) => {
       const { serialize: encode, parse: decode, defaultValue: fallback } = latest.current;
       try {
@@ -735,7 +787,7 @@ function useStorageState(key, defaultValue, options = {}) {
     [kind, key]
   );
   const remove = (0, import_react11.useCallback)(() => removeCurrent(kind, key), [kind, key]);
-  return [value, set, remove];
+  return [value, set2, remove];
 }
 
 // src/unsaved-guard/handle-before-unload.ts
@@ -870,35 +922,594 @@ function useAutoGrowTextarea(ref, value, { maxHeight } = {}) {
     return () => target.removeEventListener("resize", resize);
   }, [resize]);
 }
+
+// src/pwa/use-is-standalone.ts
+var import_react15 = require("react");
+
+// 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;
+
+// src/pwa/use-is-standalone.ts
+function useIsStandalone() {
+  const subscribeToMode = (0, import_react15.useCallback)((onChange) => subscribe(STANDALONE_QUERY, onChange), []);
+  return (0, import_react15.useSyncExternalStore)(subscribeToMode, isStandalone, () => false);
+}
+
+// src/pwa/use-install-prompt.ts
+var import_react16 = require("react");
+
+// src/pwa/install-store.ts
+var state = { event: null, installed: false };
+var subscribers = /* @__PURE__ */ new Set();
+var permanent = false;
+var holders = 0;
+var attached = false;
+function set(next) {
+  state = next;
+  subscribers.forEach((fn) => fn());
+}
+function onBeforeInstallPrompt(e) {
+  e.preventDefault();
+  set({ ...state, event: e });
+}
+function onAppInstalled() {
+  set({ event: null, installed: true });
+}
+function sync() {
+  const wanted = permanent || holders > 0;
+  if (wanted === attached || typeof window === "undefined") return;
+  attached = wanted;
+  const toggle = wanted ? window.addEventListener : window.removeEventListener;
+  toggle.call(window, "beforeinstallprompt", onBeforeInstallPrompt);
+  toggle.call(window, "appinstalled", onAppInstalled);
+}
+function startInstallPromptCapture() {
+  permanent = true;
+  sync();
+}
+function acquireCapture() {
+  holders += 1;
+  sync();
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    holders -= 1;
+    sync();
+  };
+}
+function getInstallState() {
+  return state;
+}
+function subscribeInstallState(onChange) {
+  subscribers.add(onChange);
+  return () => {
+    subscribers.delete(onChange);
+  };
+}
+async function promptInstall() {
+  const event = state.event;
+  if (!event) return "unavailable";
+  set({ ...state, event: null });
+  try {
+    await event.prompt();
+    const { outcome } = await event.userChoice;
+    return outcome;
+  } catch {
+    return "dismissed";
+  }
+}
+
+// src/pwa/use-install-prompt.ts
+var serverState = { event: null, installed: false };
+function useInstallPrompt() {
+  const state2 = (0, import_react16.useSyncExternalStore)(subscribeInstallState, getInstallState, () => serverState);
+  const standalone = useIsStandalone();
+  const iosSafari = (0, import_react16.useSyncExternalStore)(
+    () => () => {
+    },
+    isIosSafari,
+    () => false
+  );
+  (0, import_react16.useEffect)(() => acquireCapture(), []);
+  const installed = state2.installed || standalone;
+  return {
+    canPrompt: state2.event !== null && !installed,
+    prompt: promptInstall,
+    installed,
+    needsIosInstructions: iosSafari && !installed
+  };
+}
+
+// src/online-status/use-online-status.ts
+var import_react17 = require("react");
+function subscribe2(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 (0, import_react17.useSyncExternalStore)(subscribe2, getSnapshot, getServerSnapshot);
+}
+
+// src/service-worker/use-service-worker.ts
+var import_react18 = require("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, onError }, { reload = () => window.location.reload() } = {}) {
+  let registration;
+  let disposed = false;
+  let applying = false;
+  const cleanups = [];
+  const controlledAtStart = hasController();
+  let activatedUnasked = false;
+  const reloadOnce = () => {
+    if (reloaded) return;
+    reloaded = true;
+    reload();
+  };
+  const onControllerChange = () => {
+    if (applying) return reloadOnce();
+    if (!controlledAtStart || activatedUnasked) return;
+    activatedUnasked = true;
+    onUpdateAvailable();
+  };
+  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((error) => {
+    if (disposed) return;
+    try {
+      onError?.(error);
+    } catch {
+    }
+  });
+  return {
+    applyUpdate() {
+      if (activatedUnasked) return reloadOnce();
+      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, onError }) {
+  const [supported, setSupported] = (0, import_react18.useState)(true);
+  const [updateAvailable, setUpdateAvailable] = (0, import_react18.useState)(false);
+  const onErrorRef = (0, import_react18.useRef)(onError);
+  onErrorRef.current = onError;
+  const handle = (0, import_react18.useRef)(void 0);
+  (0, import_react18.useEffect)(() => {
+    if (!enabled) return;
+    if (!isServiceWorkerSupported()) {
+      setSupported(false);
+      return;
+    }
+    const registered = registerServiceWorker({
+      url,
+      scope,
+      onUpdateAvailable: () => setUpdateAvailable(true),
+      onError: (error) => onErrorRef.current?.(error)
+    });
+    handle.current = registered;
+    return () => {
+      registered.dispose();
+      handle.current = void 0;
+    };
+  }, [url, scope, enabled]);
+  const applyUpdate = (0, import_react18.useCallback)(() => handle.current?.applyUpdate(), []);
+  return { supported, updateAvailable, applyUpdate };
+}
+
+// src/share/share-text.ts
+function shareTextFor({ text, url }) {
+  return [text, url].filter((part) => !!part).join("\n");
+}
+function isShareCancel(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+
+// src/share/share-or-copy.ts
+async function shareOrCopy(data) {
+  if (canShareNatively(data)) {
+    try {
+      await navigator.share(data);
+      return { status: "shared" };
+    } catch (error) {
+      if (isShareCancel(error)) return { status: "cancelled" };
+    }
+  }
+  const result = await copyText(shareTextFor(data));
+  return { status: result.ok ? "copied" : "failed" };
+}
+function canShareFiles(files) {
+  if (typeof navigator === "undefined" || typeof navigator.canShare !== "function") return false;
+  try {
+    return navigator.canShare({ files });
+  } catch {
+    return false;
+  }
+}
+function canShareNatively(data) {
+  if (typeof navigator === "undefined" || typeof navigator.share !== "function") return false;
+  if (typeof navigator.canShare !== "function") return true;
+  try {
+    return navigator.canShare(data);
+  } catch {
+    return false;
+  }
+}
+
+// src/share/use-share-feedback.ts
+var import_react19 = require("react");
+function useShareFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = (0, import_react19.useState)("idle");
+  const timerRef = (0, import_react19.useRef)(void 0);
+  const clearTimer = (0, import_react19.useCallback)(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  (0, import_react19.useEffect)(() => clearTimer, [clearTimer]);
+  const share = (0, import_react19.useCallback)(
+    async (data) => {
+      const result = await shareOrCopy(data);
+      clearTimer();
+      setStatus(result.status);
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { share, status };
+}
+
+// src/keyboard-inset/use-keyboard-inset.ts
+var import_react20 = require("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] = (0, import_react20.useState)(0);
+  (0, import_react20.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;
+}
+
+// src/push/use-push-subscription.ts
+var import_react21 = require("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 isKeyReady(key) {
+  return key.trim().length > 0;
+}
+function shouldResubscribe({ permission, hasSubscription, resubscribeOnLoad, hasKey = true }) {
+  return hasKey && 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] = (0, import_react21.useState)("unsupported");
+  const [permission, setPermission] = (0, import_react21.useState)("unsupported");
+  const [subscribed, setSubscribed] = (0, import_react21.useState)(false);
+  const [busy, setBusy] = (0, import_react21.useState)(false);
+  const [error, setError] = (0, import_react21.useState)(null);
+  const hasKey = isKeyReady(options.vapidPublicKey);
+  const latest = (0, import_react21.useRef)(options);
+  latest.current = options;
+  (0, import_react21.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, hasKey })) return;
+        await ensureSubscribed(reg, latest.current);
+        if (!cancelled) setSubscribed(true);
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [resubscribeOnLoad, hasKey]);
+  const subscribe3 = (0, import_react21.useCallback)(async () => {
+    if (getPushSupport() !== "supported") return;
+    if (!isKeyReady(latest.current.vapidPublicKey)) {
+      setError("push key not ready");
+      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 = (0, import_react21.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: subscribe3, unsubscribe };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BACK_ZONE_PX,
   CLOSE_DISTANCE_PX,
   COARSE_POINTER_QUERY,
+  DEFAULT_IGNORE_SELECTOR,
   FOCUSABLE_SELECTOR,
   FORWARD_ZONE_PX,
   MAX_SWIPE_DURATION_MS,
   OPEN_DISTANCE_PX,
   REDUCED_MOTION_QUERY,
   VERTICAL_CANCEL_PX,
+  canShareFiles,
+  computeKeyboardInset,
   copyText,
   createDebouncer,
+  deriveUpdateState,
   detectApple,
+  detectPlatform,
   focusableWithin,
+  getPushSupport,
   handleBeforeUnload,
+  isEditableElement,
   isEditableTarget,
+  isInIgnoredRegion,
   isInOpenZone,
   isInsideHorizontalScroller,
+  isIos,
+  isIosSafari,
   isOutside,
   isPrimaryPress,
+  isShareCancel,
+  isStandalone,
   lockScroll,
   matchHotkey,
   nextDelay,
   nextFocusTarget,
   nextHeight,
   parseHotkey,
+  readText,
   resolveSwipeIntent,
+  shareOrCopy,
+  shareTextFor,
+  shouldResubscribe,
+  startInstallPromptCapture,
   unlockScroll,
+  unregisterAll,
+  urlBase64ToUint8Array,
   useAutoGrowTextarea,
   useCoarsePointer,
   useCopyFeedback,
@@ -908,10 +1519,17 @@ function useAutoGrowTextarea(ref, value, { maxHeight } = {}) {
   useEscape,
   useFocusTrap,
   useHotkey,
+  useInstallPrompt,
+  useIsStandalone,
+  useKeyboardInset,
   useMediaQuery,
+  useOnlineStatus,
   useOutsidePress,
+  usePushSubscription,
   useReducedMotion,
   useScrollLock,
+  useServiceWorker,
+  useShareFeedback,
   useStorageState,
   useUnsavedChangesGuard,
   useVisibilityPolling