@develemit/web-hooks 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # 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.
+- `hotkey`: `useHotkey('mod+k', fn, { enabled, allowInInputs, preventDefault })` and the pure `parseHotkey`, `matchHotkey`, `detectApple`. Ignores case and Caps Lock, `mod` is Cmd on Apple and Ctrl elsewhere, exact modifier match, text fields skipped by default.
+- `auto-grow`: `useAutoGrowTextarea(ref, value, { maxHeight })` and the pure `nextHeight`. Re-measures on value change and on `visualViewport` resize (keyboard), with a `window` fallback; `overflowY: auto` only when capped.
+- `debounce`: `useDebouncedValue(value, ms)`, `useDebouncedCallback(fn, ms)` (returns a stable function with `cancel` and `flush`, cancels on unmount, always calls the latest `fn`) and the pure `createDebouncer`.
+- `storage-state`: `useStorageState(key, defaultValue, { storage, serialize, parse })` returning `[value, set, remove]`. Built on `useSyncExternalStore`, so the first client render matches the server (the default) with no hydration mismatch; stays in sync across hooks and tabs; bad JSON gives the default; a refused `setItem` (quota, Safari private mode) is kept in memory so the UI still updates.
+- `visibility-polling`: `useVisibilityPolling(fn, intervalMs, { enabled, immediate, jitter, runOnVisible })` and the pure `nextDelay`. Chained timeouts so a slow run never overlaps, paused while the page is hidden (a locked phone makes no calls), one run on becoming visible, and the listener is always removed on unmount.
+- `outside-press`: `useOutsidePress(refs, onOutsidePress, { enabled })` and the pure `isOutside`. Listens to `pointerdown` in the capture phase so taps on non-clickable elements close menus on iPhone, only while enabled, with the trigger and portalled panels as inside refs.
+- `media-query`: `useMediaQuery(query, { serverDefault })`, `useReducedMotion` and `useCoarsePointer`. Correct on the first client render, no hydration mismatch, safe without `matchMedia`, and one shared `MediaQueryList` per query.
+- `scroll-lock`: `useScrollLock` and `lockScroll()` / `unlockScroll()`. Counted locks, `position: fixed` so iOS Safari and standalone PWAs stop scrolling the background, exact restore of previous inline styles and scroll position, scrollbar-width padding on desktop.
+- `clipboard`: the `execCommand` fallback now puts focus back on the element that had it (and never scrolls to the temporary textarea). It used to leave `<body>` focused after a copy on plain-http PWAs.
+- `focus-trap`: under StrictMode the captured opener was dropped by the simulated effect cleanup, so closing a trap (e.g. a dialog stacked in an open nav) left focus on `<body>`. The opener is now cleared when the trap deactivates.
+- `escape`: `useEscape` ignores Escape pressed during IME composition (`isComposing` or `keyCode` 229), so cancelling a composition no longer closes the menu.
+- The root `@develemit/web-hooks` entry now carries the `"use client"` banner like the subpath entries, so a server component importing from the root fails loudly in Next.
+
 ## 0.1.0
 
 - `drawer-swipe`: `useDrawerSwipe` and the pure `resolveSwipeIntent`. Swipe right from mid-screen opens a mobile nav drawer, left closes it. The left 60px band is left to the browser's back gesture.

package/README.md

@@ -9,6 +9,21 @@ that every app ends up hand-copying from the last one.
 | `@develemit/web-hooks/focus-trap` | Keep Tab focus inside an open dialog or drawer, restore it on close |
 | `@develemit/web-hooks/escape` | Run a callback when Escape is pressed |
 | `@develemit/web-hooks/clipboard` | Copy text, with the fallback that works on plain-http PWAs |
+| `@develemit/web-hooks/scroll-lock` | Lock page scroll behind a modal or drawer, counted, and it works on iOS |
+| `@develemit/web-hooks/media-query` | Track a media query, reduced motion or a coarse pointer, with no hydration mismatch |
+| `@develemit/web-hooks/outside-press` | Close a menu or popover on a press outside it, including taps on iPhone |
+| `@develemit/web-hooks/visibility-polling` | Poll on an interval that pauses while the page is hidden |
+| `@develemit/web-hooks/debounce` | Debounce a value or a callback |
+| `@develemit/web-hooks/storage-state` | State persisted to localStorage or sessionStorage, SSR-safe and synced across tabs |
+| `@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.
 
@@ -35,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
@@ -74,6 +94,123 @@ 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
+import { useScrollLock } from '@develemit/web-hooks/scroll-lock';
+
+useScrollLock(open);
+```
+
+Uses `position: fixed` on `body` because iOS Safari ignores `overflow: hidden`
+for touch scrolling. Locks are counted, so a lightbox closing inside an open
+drawer leaves the page locked. When the last lock releases, the exact previous
+inline styles and the scroll position come back. `lockScroll()` returns a
+release function (safe to call twice) for use outside React.
+
+### Match a media query
+
+```tsx
+import { useMediaQuery, useReducedMotion, useCoarsePointer } from '@develemit/web-hooks/media-query';
+
+const narrow = useMediaQuery('(max-width: 767px)', { serverDefault: false });
+const reduce = useReducedMotion();
+const touch = useCoarsePointer();
+```
+
+Built on `useSyncExternalStore`, so the first client render already has the
+real value (no desktop frame on a phone). The server render and hydration use
+`serverDefault` (default `false`); React then re-renders with the real value
+without a mismatch warning. There are no built-in breakpoints: pass your own
+query. Where `matchMedia` is missing (jsdom tests) the hook returns
+`serverDefault` instead of throwing. Hooks with the same query share one
+`MediaQueryList`, and Safari before 14 is supported through `addListener`.
+
+### Close on an outside press
+
+```tsx
+import { useOutsidePress } from '@develemit/web-hooks/outside-press';
+import { useEscape } from '@develemit/web-hooks/escape';
+
+const menu = useRef<HTMLDivElement>(null);
+const trigger = useRef<HTMLButtonElement>(null);
+useOutsidePress([menu, trigger], () => setOpen(false), { enabled: open });
+useEscape(() => setOpen(false), open);
+```
+
+Listens to `pointerdown` on `document` in the capture phase, only while
+`enabled`. `mousedown` never fires on iOS for a tap on a non-clickable element,
+so copies built on it leave the menu open. Pass the trigger as well as the
+panel, or tapping the trigger closes and instantly reopens the menu. Pass a
+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
+import { useVisibilityPolling } from '@develemit/web-hooks/visibility-polling';
+
+useVisibilityPolling(() => refresh(), 5000, { jitter: 0.2 });
+```
+
+Runs `fn` every `intervalMs` only while the page is visible. When the tab is
+hidden (a locked phone) the timer is cleared; when it is visible again `fn`
+runs once right away and the schedule resumes. The next run is scheduled after
+the previous one finishes, so a slow promise never overlaps. Options:
+`enabled` (default true), `immediate` (run on mount, default true), `jitter`
+(0–1 fraction of the interval added at random, default 0) and `runOnVisible`
+(default true). `fn` is read through a ref. A throw or rejection doesn't stop
+the schedule; handle errors inside `fn`. It decides when to run, not caching
+or dedupe.
+
+### debounce
+
+```tsx
+import { useDebouncedValue, useDebouncedCallback } from '@develemit/web-hooks/debounce';
+
+const debouncedSearch = useDebouncedValue(search, 300);
+
+const run = useDebouncedCallback((q: string) => fetchResults(q), 300);
+run('inv'); // later calls reset the timer; only the last runs
+run.cancel(); // drop the pending call
+run.flush(); // run it now
+```
+
+`useDebouncedValue` returns the value once it has stopped changing for `ms`.
+`useDebouncedCallback` returns one function for the life of the component; it
+always calls the latest `fn` and `ms`, so it needs no `useCallback`, and a
+pending call is cancelled on unmount.
+
+### storage-state
+
+```tsx
+import { useStorageState } from '@develemit/web-hooks/storage-state';
+
+const [recent, setRecent, clearRecent] = useStorageState<string[]>('recent', []);
+setRecent((prev) => ['pnpm dev', ...prev]);
+const [draft, setDraft] = useStorageState('draft', '', { storage: 'session' });
+```
+
+The server and the first client render both return `defaultValue`; the stored
+value arrives right after hydration, so there is no mismatch. Hooks with the
+same key stay in sync in this tab, and other tabs through the `storage` event.
+The setter takes a value or an updater. Options: `storage` (`'local'` default,
+or `'session'`), `serialize` and `parse` (JSON by default; a `parse` that
+throws gives `defaultValue`, so legacy non-JSON values and validators both
+work). A refused `setItem` (full quota, Safari private mode) never throws: the
+new value is kept in memory for the rest of the page's life and the UI
+updates. Keep `defaultValue` stable (a constant or a primitive); it is read
+again only when the stored value or key changes.
+
 ### Migrating from the per-app copies
 
 | App | Old | New |
@@ -82,3 +219,177 @@ rejects. On plain-http origins (a PWA over a Tailscale address)
 | emit-social | `useFocusTrap(ref, { active, returnFocusRef })` plus `useEscape(fn, active)` | Same signatures. |
 | develemit-commerce | `const onKeyDown = useFocusTrap(ref, active, onEscape)` | `useFocusTrap(ref, { active })` and `useEscape(onEscape, active)`. Drop the returned `onKeyDown` handler. |
 | centraflow | `const ref = useFocusTrap(active)` | `const ref = useRef<HTMLElement>(null)`, then `useFocusTrap(ref, { active })`. |
+
+### unsaved-guard
+
+```tsx
+import { useUnsavedChangesGuard } from '@develemit/web-hooks/unsaved-guard';
+
+useUnsavedChangesGuard(isDirty);
+```
+
+While `dirty` is true the browser asks before the tab closes or reloads. It
+sets both `preventDefault()` and `returnValue = ''`, because older Safari and
+Chrome ignore `preventDefault()` alone. This covers `beforeunload` only:
+Next's App Router has no stable way to block in-app navigation, so that stays
+in the app.
+
+### hotkey
+
+```tsx
+import { useHotkey, matchHotkey } from '@develemit/web-hooks/hotkey';
+
+useHotkey('mod+k', () => setOpen((o) => !o));
+useHotkey('mod+k', toggle, { allowInInputs: true, preventDefault: false });
+```
+
+Combos are modifiers (`mod`, `ctrl`, `meta`, `alt`, `shift`) then one key:
+`mod+k`, `shift+/`, `escape`. `mod` is Cmd on Apple devices (iPad in desktop
+mode included) and Ctrl elsewhere. Case and Caps Lock don't matter, and the
+modifier set must match exactly. Text fields (`input`, `textarea`, `select`,
+contenteditable) are skipped unless `allowInInputs`. Options: `enabled`
+(default true), `allowInInputs` (false), `preventDefault` (true). `matchHotkey(event,
+combo, isApple)` is the pure matcher; `detectApple(navigator)` supplies
+`isApple`. No key sequences.
+
+### auto-grow
+
+```tsx
+import { useAutoGrowTextarea } from '@develemit/web-hooks/auto-grow';
+
+const ref = useRef<HTMLTextAreaElement>(null);
+useAutoGrowTextarea(ref, value, { maxHeight: 240 });
+```
+
+Resizes the textarea to fit its content on every `value` change and whenever
+the visual viewport resizes (the iPhone keyboard opening or closing), falling
+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/auto-grow.cjs

@@ -0,0 +1,60 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auto-grow/index.ts
+var auto_grow_exports = {};
+__export(auto_grow_exports, {
+  nextHeight: () => nextHeight,
+  useAutoGrowTextarea: () => useAutoGrowTextarea
+});
+module.exports = __toCommonJS(auto_grow_exports);
+
+// src/auto-grow/next-height.ts
+function nextHeight(scrollHeight, maxHeight) {
+  const content = Math.ceil(scrollHeight);
+  if (maxHeight !== void 0 && content > maxHeight) return { height: maxHeight, capped: true };
+  return { height: content, capped: false };
+}
+
+// src/auto-grow/use-auto-grow-textarea.ts
+var import_react = require("react");
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? import_react.useEffect : import_react.useLayoutEffect;
+function useAutoGrowTextarea(ref, value, { maxHeight } = {}) {
+  const resize = (0, import_react.useCallback)(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.height = "auto";
+    const { height, capped } = nextHeight(el.scrollHeight, maxHeight);
+    el.style.height = `${height}px`;
+    el.style.overflowY = capped ? "auto" : "hidden";
+  }, [ref, maxHeight]);
+  useIsomorphicLayoutEffect(resize, [resize, value]);
+  (0, import_react.useEffect)(() => {
+    const viewport = window.visualViewport;
+    const target = viewport ?? window;
+    target.addEventListener("resize", resize);
+    return () => target.removeEventListener("resize", resize);
+  }, [resize]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  nextHeight,
+  useAutoGrowTextarea
+});

package/dist/auto-grow.d.cts

@@ -0,0 +1,14 @@
+import { RefObject } from 'react';
+
+interface NextHeight {
+    height: number;
+    capped: boolean;
+}
+declare function nextHeight(scrollHeight: number, maxHeight?: number): NextHeight;
+
+interface UseAutoGrowTextareaOptions {
+    maxHeight?: number;
+}
+declare function useAutoGrowTextarea(ref: RefObject<HTMLTextAreaElement | null>, value: string, { maxHeight }?: UseAutoGrowTextareaOptions): void;
+
+export { type NextHeight, type UseAutoGrowTextareaOptions, nextHeight, useAutoGrowTextarea };

package/dist/auto-grow.d.ts

@@ -0,0 +1,14 @@
+import { RefObject } from 'react';
+
+interface NextHeight {
+    height: number;
+    capped: boolean;
+}
+declare function nextHeight(scrollHeight: number, maxHeight?: number): NextHeight;
+
+interface UseAutoGrowTextareaOptions {
+    maxHeight?: number;
+}
+declare function useAutoGrowTextarea(ref: RefObject<HTMLTextAreaElement | null>, value: string, { maxHeight }?: UseAutoGrowTextareaOptions): void;
+
+export { type NextHeight, type UseAutoGrowTextareaOptions, nextHeight, useAutoGrowTextarea };

package/dist/auto-grow.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  nextHeight,
+  useAutoGrowTextarea
+} from "./chunk-5CA5RIMH.js";
+export {
+  nextHeight,
+  useAutoGrowTextarea
+};

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-5CA5RIMH.js

@@ -0,0 +1,34 @@
+"use client";
+
+// src/auto-grow/next-height.ts
+function nextHeight(scrollHeight, maxHeight) {
+  const content = Math.ceil(scrollHeight);
+  if (maxHeight !== void 0 && content > maxHeight) return { height: maxHeight, capped: true };
+  return { height: content, capped: false };
+}
+
+// src/auto-grow/use-auto-grow-textarea.ts
+import { useCallback, useEffect, useLayoutEffect } from "react";
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function useAutoGrowTextarea(ref, value, { maxHeight } = {}) {
+  const resize = useCallback(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.height = "auto";
+    const { height, capped } = nextHeight(el.scrollHeight, maxHeight);
+    el.style.height = `${height}px`;
+    el.style.overflowY = capped ? "auto" : "hidden";
+  }, [ref, maxHeight]);
+  useIsomorphicLayoutEffect(resize, [resize, value]);
+  useEffect(() => {
+    const viewport = window.visualViewport;
+    const target = viewport ?? window;
+    target.addEventListener("resize", resize);
+    return () => target.removeEventListener("resize", resize);
+  }, [resize]);
+}
+
+export {
+  nextHeight,
+  useAutoGrowTextarea
+};