@develemit/web-hooks 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.3.0 - 2026-11-06
+
+- `push`: `usePushSubscription({ vapidPublicKey, onSubscribe, onUnsubscribe, resubscribeOnLoad = true })` returning `{ support, permission, subscribed, busy, error, subscribe, unsubscribe }`, plus `urlBase64ToUint8Array`, `getPushSupport` (`'supported' | 'unsupported' | 'ios-needs-install'`) and the pure `shouldResubscribe`. The VAPID key is always converted to a `Uint8Array`, the browser's `pushManager.getSubscription()` is the source of truth, mounting never asks for permission, a dropped iOS subscription is re-made silently when permission is already granted, and an `onSubscribe` rejection with `status` 410 unsubscribes and subscribes once more. The package makes no HTTP requests; the app's callbacks do.
+- `keyboard-inset`: `useKeyboardInset({ minInset = 150, enabled = true })` returns the on-screen keyboard height in CSS px (0 when closed), plus the pure `computeKeyboardInset` and `isEditableElement`. Reports only while a text field is focused and ignores gaps under `minInset`, which removes the phantom ~100pt gap in a standalone iPhone PWA. After a blur it re-reads on the next animation frame so moving between fields doesn't flicker to 0.
+- `share`: `shareOrCopy({ title, text, url })` returning `{ status: 'shared' | 'copied' | 'cancelled' | 'failed' }`. Uses the native share sheet when present (honouring `navigator.canShare`), treats an `AbortError` as `cancelled` with no copy, and otherwise falls back to the clipboard module's `copyText`, so it works over plain http. Also `shareTextFor` (copies `text` then `url`, never `title`), `isShareCancel`, `canShareFiles` (detection only) and `useShareFeedback()`.
+- `online-status`: `useOnlineStatus()` built on `useSyncExternalStore`; `true` on the server and during hydration, so no mismatch when the device starts offline.
+- `service-worker`: `useServiceWorker({ url, scope, enabled })` returning `{ supported, updateAvailable, applyUpdate }`, plus `unregisterAll()` and the pure `deriveUpdateState`. A first install is never reported as an update; `applyUpdate()` posts `{ type: 'SKIP_WAITING' }` and the page reloads once on `controllerchange` (a module-level guard prevents loops; other tabs follow when an old worker was in control). The app's worker must handle `SKIP_WAITING`. The package never reads `process.env`; pass `enabled`.
+- `pwa`: `useInstallPrompt()` (`canPrompt`, `prompt()` returning `accepted | dismissed | unavailable` from `userChoice`, `installed`, `needsIosInstructions`), `useIsStandalone()`, `startInstallPromptCapture()` for the `beforeinstallprompt` that fires before hydration, and the pure `detectPlatform`, `isStandalone`, `isIos`, `isIosSafari`. iPadOS in desktop mode counts as iOS; Chrome, Firefox, Edge, Opera and in-app webviews on iOS are not iOS Safari. Both listeners are removed on unmount. Dismissal storage is left to the app.
+- `outside-press`: `useOutsidePress(refs, fn, { ignore })` takes a CSS selector. A press whose target is inside a matching element counts as inside, for popups that are found with `closest(selector)` and have no ref. New optional third argument to the pure `isOutside`.
+- `drawer-swipe`: `useDrawerSwipe({ ignoreSelector })` (default `'[data-no-swipe]'`, `null` disables). A swipe that starts inside a match, or inside a descendant of one, never opens or closes the drawer. New pure `isInIgnoredRegion`, and `resolveSwipeIntent` takes an optional `startedInIgnoredRegion`.
+- `clipboard`: `readText()` resolves to `{ ok: true, text }` or `{ ok: false, reason: 'unavailable' | 'denied' }` and never throws. Over plain http there is no way to read the clipboard, so it returns `unavailable` (show "paste manually").
+
 ## 0.2.0 - 2026-11-05
 
 - `unsaved-guard`: `useUnsavedChangesGuard(dirty)` and the pure `handleBeforeUnload`. Attached only while dirty and sets `returnValue = ''` as well as `preventDefault()`, which older Safari and Chrome need. `beforeunload` only; in-app navigation stays in the app.

package/README.md

@@ -18,6 +18,12 @@ that every app ends up hand-copying from the last one.
 | `@develemit/web-hooks/unsaved-guard` | Warn before the tab closes while a form is dirty |
 | `@develemit/web-hooks/hotkey` | Keyboard shortcuts such as `mod+k` |
 | `@develemit/web-hooks/auto-grow` | Grow a textarea with its content, keyboard-aware |
+| `@develemit/web-hooks/pwa` | Detect iOS and installed-PWA mode, and drive the install prompt |
+| `@develemit/web-hooks/online-status` | Track online/offline, hydration-safe |
+| `@develemit/web-hooks/service-worker` | Register a service worker and apply updates with one reload |
+| `@develemit/web-hooks/share` | Native share sheet with a clipboard fallback that works over plain http |
+| `@develemit/web-hooks/keyboard-inset` | On-screen keyboard height, without the phantom gap in standalone iPhone PWAs |
+| `@develemit/web-hooks/push` | Web push subscription, with iOS install detection and silent re-subscribe |
 
 Behavior only. No styling and no components: each app keeps its own look.
 
@@ -44,6 +50,11 @@ useDrawerSwipe({
 The left 60px band is left to the browser's back gesture, and swipes that start
 inside a horizontally scrolling container stay with that container.
 
+Mark a region that scrolls or gestures on its own (a terminal, a code view)
+with `data-no-swipe`, and swipes starting inside it are ignored. Pass
+`ignoreSelector: '.my-region'` to use a different selector, or `null` to turn
+the opt-out off.
+
 ### Drawer with focus trap and Escape
 
 ```tsx
@@ -83,6 +94,11 @@ const { copy, status } = useCopyFeedback({ resetMs: 1500 });
 rejects. On plain-http origins (a PWA over a Tailscale address)
 `navigator.clipboard` doesn't exist, so it falls back to `execCommand('copy')`.
 
+`readText()` is the paste side. It resolves to `{ ok: true, text }` or
+`{ ok: false, reason: 'unavailable' | 'denied' }` and never rejects. Reading has
+no fallback: over plain http it returns `unavailable`, so show a "paste
+manually" hint.
+
 ### Lock page scroll behind an overlay
 
 ```tsx
@@ -135,6 +151,9 @@ portalled panel's ref too. Right clicks are ignored, and a target removed from
 the DOM during the event counts as inside. The callback is read through a ref,
 so it needs no `useCallback`.
 
+When the popup has no ref, pass `{ ignore: '.inline-cell-search' }`: a press
+inside any element matching the selector counts as inside (unreleased).
+
 ### visibility-polling
 
 ```tsx
@@ -248,3 +267,129 @@ back to `window` `resize`. At `maxHeight` it stops growing and sets
 `overflowY: auto`. The pure `nextHeight(scrollHeight, maxHeight)` does the
 clamping.
 
+### Install prompt and platform detection
+
+```tsx
+import { startInstallPromptCapture, useInstallPrompt, useIsStandalone } from '@develemit/web-hooks/pwa';
+
+// Root client component, outside React's lifecycle: Android Chrome often fires
+// `beforeinstallprompt` before hydration, and it fires only once.
+startInstallPromptCapture();
+
+const { canPrompt, prompt, installed, needsIosInstructions } = useInstallPrompt();
+if (canPrompt) await prompt(); // 'accepted' | 'dismissed' | 'unavailable'
+```
+
+`needsIosInstructions` is true in iOS Safari (not Chrome, Firefox, Edge, Opera
+or an in-app browser) when the app isn't installed. iPads in desktop mode count
+as iOS. The pure `detectPlatform(env)`, `isIos()`, `isIosSafari()` and
+`isStandalone()` are exported too; they read the globals when called and
+return `false` on the server.
+
+The package doesn't store dismissal: the key and snooze rules are product
+decisions. Combine the hook with `useStorageState` from `storage-state`.
+
+### Online status and service worker
+
+```tsx
+import { useOnlineStatus } from '@develemit/web-hooks/online-status';
+import { useServiceWorker } from '@develemit/web-hooks/service-worker';
+
+const online = useOnlineStatus(); // true on the server and during hydration
+
+const { updateAvailable, applyUpdate, supported } = useServiceWorker({
+  url: '/sw.js',
+  scope: '/',
+  enabled: process.env.NODE_ENV === 'production',
+});
+if (updateAvailable) showBanner({ onTap: applyUpdate });
+```
+
+`applyUpdate()` posts `{ type: 'SKIP_WAITING' }` to the waiting worker and the
+page reloads once when the new worker takes control. Your worker must handle
+that message:
+
+```js
+self.addEventListener('message', (event) => {
+  if (event.data?.type === 'SKIP_WAITING') self.skipWaiting();
+});
+```
+
+A first install (no controller yet) is not reported as an update. In dev, call
+`unregisterAll()` to clear workers left by a production build. Browsers without
+service workers get `supported: false`.
+
+### Share
+
+```tsx
+import { useShareFeedback } from '@develemit/web-hooks/share';
+
+const { share, status } = useShareFeedback(); // 'idle' | 'shared' | 'copied' | 'cancelled' | 'failed'
+<button onClick={() => void share({ title, text, url })}>Share</button>;
+```
+
+`shareOrCopy(data)` opens the native share sheet when there is one. Closing the
+sheet is `cancelled`, not a failure, and copies nothing. Any other share error
+(for example `NotAllowedError` when the call isn't from a user gesture), a
+missing `navigator.share`, or `canShare(data) === false` falls back to
+`copyText`, which works over plain http. The copied text is `text` then `url`
+joined by a newline (`url` alone when that is all there is); `title` is not
+copied. Call it directly from the tap handler, before any `await`, so the
+browser still sees a user gesture. `canShareFiles(files)` is detection only.
+
+### Keyboard inset
+
+```tsx
+import { useKeyboardInset } from '@develemit/web-hooks/keyboard-inset';
+
+const inset = useKeyboardInset();
+
+useEffect(() => {
+  document.documentElement.style.setProperty('--keyboard-inset', `${inset}px`);
+}, [inset]);
+```
+
+Returns the height of the on-screen keyboard in CSS pixels, `0` when it is
+closed, on the server and when `visualViewport` is missing. It reports an
+inset only while a text field is focused and ignores gaps under `minInset`
+(default 150), because a standalone iPhone PWA reports a ~100pt gap between the
+layout and visual viewport with no keyboard open. The hook returns a number;
+apply it as padding or `bottom` yourself, for example `padding-bottom:
+var(--keyboard-inset)` with the effect above. The pure `computeKeyboardInset`
+and `isEditableElement` are exported too.
+
+### Push
+
+```tsx
+import { usePushSubscription } from '@develemit/web-hooks/push';
+
+const push = usePushSubscription({
+  vapidPublicKey: process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY!,
+  onSubscribe: (sub) => api.post('/push/subscribe', sub),
+  onUnsubscribe: (endpoint) => api.delete('/push/subscribe', { endpoint }),
+});
+
+if (push.support === 'ios-needs-install') return <InstallHint />;
+<button onClick={push.subscribe} disabled={push.busy}>Enable</button>
+```
+
+Returns `{ support, permission, subscribed, busy, error, subscribe, unsubscribe }`.
+`support` is `'supported'`, `'unsupported'` or `'ios-needs-install'`: iOS only
+allows Web Push in an installed PWA (16.4+), so an iPhone Safari tab (or any
+iOS browser outside the home-screen app) gets `ios-needs-install` and
+`subscribe()` does nothing.
+
+Call `subscribe()` from a tap handler: the hook never requests permission on
+mount, because browsers (and iOS especially) need a user gesture. `subscribed`
+comes from `pushManager.getSubscription()`, never from a stored flag. The
+service worker comes from `navigator.serviceWorker.ready`; this package never
+registers one for push (use `useServiceWorker`).
+
+iOS silently drops push subscriptions. With `resubscribeOnLoad` (default
+`true`), when permission is already `granted` and the browser has no
+subscription, the hook subscribes again without a prompt and calls
+`onSubscribe`. If `onSubscribe` rejects with an error whose `status` is `410`,
+the dead subscription is unsubscribed and one fresh one is made and sent. The
+package never makes HTTP requests: `onSubscribe(subscription:
+PushSubscriptionJSON)` and `onUnsubscribe(endpoint)` are yours. The pure
+`urlBase64ToUint8Array`, `getPushSupport` and `shouldResubscribe` are exported.

package/dist/chunk-4PVVTQ5V.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  copyText
+} from "./chunk-FE3BQD2I.js";
+
+// 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
+import { useCallback, useEffect, useRef, useState } from "react";
+function useShareFeedback({ 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 share = 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 };
+}
+
+export {
+  shareTextFor,
+  isShareCancel,
+  shareOrCopy,
+  canShareFiles,
+  useShareFeedback
+};

package/dist/{chunk-OZ4PU4E3.js → chunk-5XRVPZHD.js}

@@ -11,7 +11,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;
@@ -33,6 +34,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
 import { useEffect, useRef } from "react";
@@ -44,17 +50,19 @@ function useDrawerSwipe({
   onOpen,
   onClose,
   enabled = true,
-  maxViewportWidth = 768
+  maxViewportWidth = 768,
+  ignoreSelector = DEFAULT_IGNORE_SELECTOR
 }) {
   const start = useRef(null);
-  const handlers = useRef({ drawerOpen, onOpen, onClose, maxViewportWidth });
-  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  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;
       }
@@ -111,5 +119,7 @@ export {
   isInOpenZone,
   resolveSwipeIntent,
   isInsideHorizontalScroller,
+  DEFAULT_IGNORE_SELECTOR,
+  isInIgnoredRegion,
   useDrawerSwipe
 };

package/dist/{chunk-3UGRXQIA.js → chunk-DQBKU7HI.js}

@@ -1,21 +1,28 @@
 "use client";
 
 // 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 && 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 } = {}) {
+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;
   });
@@ -25,7 +32,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);

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-3CACI4OQ.js → chunk-FE3BQD2I.js}

@@ -39,30 +39,6 @@ function execCommandCopy(text) {
   }
 }
 
-// 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 };
-}
-
 export {
-  copyText,
-  useCopyFeedback
+  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-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-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
+};