@mrmeg/expo-ui 0.25.0 → 0.26.0

package/dist/components/iconRegistry.generated.js

@@ -0,0 +1,296 @@
+/* eslint-disable */
+// GENERATED FILE - do not edit. Rebuild with `bun run ui:icons`.
+// Source: icon-names.json (145 icons). Each icon is a
+// per-glyph subpath import so consumers bundle only the names listed there.
+import Archive from "lucide-react-native/icons/archive";
+import ArrowDown from "lucide-react-native/icons/arrow-down";
+import ArrowLeft from "lucide-react-native/icons/arrow-left";
+import ArrowRight from "lucide-react-native/icons/arrow-right";
+import ArrowUp from "lucide-react-native/icons/arrow-up";
+import Award from "lucide-react-native/icons/award";
+import Beer from "lucide-react-native/icons/beer";
+import Bell from "lucide-react-native/icons/bell";
+import BellOff from "lucide-react-native/icons/bell-off";
+import Bold from "lucide-react-native/icons/bold";
+import Bookmark from "lucide-react-native/icons/bookmark";
+import Box from "lucide-react-native/icons/box";
+import Briefcase from "lucide-react-native/icons/briefcase";
+import Calendar from "lucide-react-native/icons/calendar";
+import CalendarCheck from "lucide-react-native/icons/calendar-check";
+import Camera from "lucide-react-native/icons/camera";
+import CameraOff from "lucide-react-native/icons/camera-off";
+import ChartNoAxesColumn from "lucide-react-native/icons/chart-no-axes-column";
+import Check from "lucide-react-native/icons/check";
+import ChevronDown from "lucide-react-native/icons/chevron-down";
+import ChevronLeft from "lucide-react-native/icons/chevron-left";
+import ChevronRight from "lucide-react-native/icons/chevron-right";
+import ChevronUp from "lucide-react-native/icons/chevron-up";
+import CircleAlert from "lucide-react-native/icons/circle-alert";
+import CircleCheckBig from "lucide-react-native/icons/circle-check-big";
+import CirclePlus from "lucide-react-native/icons/circle-plus";
+import CircleQuestionMark from "lucide-react-native/icons/circle-question-mark";
+import CircleStop from "lucide-react-native/icons/circle-stop";
+import CircleX from "lucide-react-native/icons/circle-x";
+import Clock from "lucide-react-native/icons/clock";
+import Cloud from "lucide-react-native/icons/cloud";
+import CloudOff from "lucide-react-native/icons/cloud-off";
+import Code from "lucide-react-native/icons/code";
+import Coffee from "lucide-react-native/icons/coffee";
+import Compass from "lucide-react-native/icons/compass";
+import Copy from "lucide-react-native/icons/copy";
+import CreditCard from "lucide-react-native/icons/credit-card";
+import Crosshair from "lucide-react-native/icons/crosshair";
+import Database from "lucide-react-native/icons/database";
+import DollarSign from "lucide-react-native/icons/dollar-sign";
+import Download from "lucide-react-native/icons/download";
+import Droplet from "lucide-react-native/icons/droplet";
+import EllipsisVertical from "lucide-react-native/icons/ellipsis-vertical";
+import ExternalLink from "lucide-react-native/icons/external-link";
+import Eye from "lucide-react-native/icons/eye";
+import EyeOff from "lucide-react-native/icons/eye-off";
+import FaceSlightlySmiling from "lucide-react-native/icons/face-slightly-smiling";
+import File from "lucide-react-native/icons/file";
+import FileText from "lucide-react-native/icons/file-text";
+import Folder from "lucide-react-native/icons/folder";
+import Gift from "lucide-react-native/icons/gift";
+import GitBranch from "lucide-react-native/icons/git-branch";
+import GitPullRequest from "lucide-react-native/icons/git-pull-request";
+import Globe from "lucide-react-native/icons/globe";
+import Grid3x3 from "lucide-react-native/icons/grid-3x3";
+import Hash from "lucide-react-native/icons/hash";
+import Heart from "lucide-react-native/icons/heart";
+import Hexagon from "lucide-react-native/icons/hexagon";
+import House from "lucide-react-native/icons/house";
+import Image from "lucide-react-native/icons/image";
+import Inbox from "lucide-react-native/icons/inbox";
+import Info from "lucide-react-native/icons/info";
+import Italic from "lucide-react-native/icons/italic";
+import Key from "lucide-react-native/icons/key";
+import Layers from "lucide-react-native/icons/layers";
+import LayoutGrid from "lucide-react-native/icons/layout-grid";
+import Link from "lucide-react-native/icons/link";
+import Link2 from "lucide-react-native/icons/link-2";
+import List from "lucide-react-native/icons/list";
+import Loader from "lucide-react-native/icons/loader";
+import Lock from "lucide-react-native/icons/lock";
+import LockOpen from "lucide-react-native/icons/lock-open";
+import LogIn from "lucide-react-native/icons/log-in";
+import LogOut from "lucide-react-native/icons/log-out";
+import Mail from "lucide-react-native/icons/mail";
+import Map from "lucide-react-native/icons/map";
+import MapPin from "lucide-react-native/icons/map-pin";
+import Maximize from "lucide-react-native/icons/maximize";
+import Maximize2 from "lucide-react-native/icons/maximize-2";
+import Menu from "lucide-react-native/icons/menu";
+import MessageCircle from "lucide-react-native/icons/message-circle";
+import MessageSquare from "lucide-react-native/icons/message-square";
+import Mic from "lucide-react-native/icons/mic";
+import MicOff from "lucide-react-native/icons/mic-off";
+import Minus from "lucide-react-native/icons/minus";
+import Monitor from "lucide-react-native/icons/monitor";
+import Moon from "lucide-react-native/icons/moon";
+import Music from "lucide-react-native/icons/music";
+import Navigation from "lucide-react-native/icons/navigation";
+import Package from "lucide-react-native/icons/package";
+import PanelLeft from "lucide-react-native/icons/panel-left";
+import PanelsTopLeft from "lucide-react-native/icons/panels-top-left";
+import PartyPopper from "lucide-react-native/icons/party-popper";
+import Pen from "lucide-react-native/icons/pen";
+import PenLine from "lucide-react-native/icons/pen-line";
+import Pencil from "lucide-react-native/icons/pencil";
+import Percent from "lucide-react-native/icons/percent";
+import Phone from "lucide-react-native/icons/phone";
+import Play from "lucide-react-native/icons/play";
+import Plus from "lucide-react-native/icons/plus";
+import Printer from "lucide-react-native/icons/printer";
+import Radio from "lucide-react-native/icons/radio";
+import RefreshCw from "lucide-react-native/icons/refresh-cw";
+import Repeat from "lucide-react-native/icons/repeat";
+import RotateCw from "lucide-react-native/icons/rotate-cw";
+import Search from "lucide-react-native/icons/search";
+import Send from "lucide-react-native/icons/send";
+import Server from "lucide-react-native/icons/server";
+import Settings from "lucide-react-native/icons/settings";
+import Share from "lucide-react-native/icons/share";
+import Share2 from "lucide-react-native/icons/share-2";
+import Shield from "lucide-react-native/icons/shield";
+import ShieldOff from "lucide-react-native/icons/shield-off";
+import ShoppingBag from "lucide-react-native/icons/shopping-bag";
+import ShoppingCart from "lucide-react-native/icons/shopping-cart";
+import Shuffle from "lucide-react-native/icons/shuffle";
+import Slash from "lucide-react-native/icons/slash";
+import SlidersHorizontal from "lucide-react-native/icons/sliders-horizontal";
+import SlidersVertical from "lucide-react-native/icons/sliders-vertical";
+import Smartphone from "lucide-react-native/icons/smartphone";
+import Square from "lucide-react-native/icons/square";
+import SquareCheckBig from "lucide-react-native/icons/square-check-big";
+import SquarePen from "lucide-react-native/icons/square-pen";
+import Star from "lucide-react-native/icons/star";
+import Sun from "lucide-react-native/icons/sun";
+import Tag from "lucide-react-native/icons/tag";
+import Terminal from "lucide-react-native/icons/terminal";
+import ThumbsUp from "lucide-react-native/icons/thumbs-up";
+import Trash from "lucide-react-native/icons/trash";
+import TrendingDown from "lucide-react-native/icons/trending-down";
+import TrendingUp from "lucide-react-native/icons/trending-up";
+import TriangleAlert from "lucide-react-native/icons/triangle-alert";
+import Truck from "lucide-react-native/icons/truck";
+import Underline from "lucide-react-native/icons/underline";
+import Upload from "lucide-react-native/icons/upload";
+import User from "lucide-react-native/icons/user";
+import UserCheck from "lucide-react-native/icons/user-check";
+import UserMinus from "lucide-react-native/icons/user-minus";
+import UserPlus from "lucide-react-native/icons/user-plus";
+import Users from "lucide-react-native/icons/users";
+import Video from "lucide-react-native/icons/video";
+import WifiOff from "lucide-react-native/icons/wifi-off";
+import Wrench from "lucide-react-native/icons/wrench";
+import X from "lucide-react-native/icons/x";
+import Zap from "lucide-react-native/icons/zap";
+export const ICONS = {
+    "archive": Archive,
+    "arrow-down": ArrowDown,
+    "arrow-left": ArrowLeft,
+    "arrow-right": ArrowRight,
+    "arrow-up": ArrowUp,
+    "award": Award,
+    "beer": Beer,
+    "bell": Bell,
+    "bell-off": BellOff,
+    "bold": Bold,
+    "bookmark": Bookmark,
+    "box": Box,
+    "briefcase": Briefcase,
+    "calendar": Calendar,
+    "calendar-check": CalendarCheck,
+    "camera": Camera,
+    "camera-off": CameraOff,
+    "chart-no-axes-column": ChartNoAxesColumn,
+    "check": Check,
+    "chevron-down": ChevronDown,
+    "chevron-left": ChevronLeft,
+    "chevron-right": ChevronRight,
+    "chevron-up": ChevronUp,
+    "circle-alert": CircleAlert,
+    "circle-check-big": CircleCheckBig,
+    "circle-plus": CirclePlus,
+    "circle-question-mark": CircleQuestionMark,
+    "circle-stop": CircleStop,
+    "circle-x": CircleX,
+    "clock": Clock,
+    "cloud": Cloud,
+    "cloud-off": CloudOff,
+    "code": Code,
+    "coffee": Coffee,
+    "compass": Compass,
+    "copy": Copy,
+    "credit-card": CreditCard,
+    "crosshair": Crosshair,
+    "database": Database,
+    "dollar-sign": DollarSign,
+    "download": Download,
+    "droplet": Droplet,
+    "ellipsis-vertical": EllipsisVertical,
+    "external-link": ExternalLink,
+    "eye": Eye,
+    "eye-off": EyeOff,
+    "face-slightly-smiling": FaceSlightlySmiling,
+    "file": File,
+    "file-text": FileText,
+    "folder": Folder,
+    "gift": Gift,
+    "git-branch": GitBranch,
+    "git-pull-request": GitPullRequest,
+    "globe": Globe,
+    "grid-3x3": Grid3x3,
+    "hash": Hash,
+    "heart": Heart,
+    "hexagon": Hexagon,
+    "house": House,
+    "image": Image,
+    "inbox": Inbox,
+    "info": Info,
+    "italic": Italic,
+    "key": Key,
+    "layers": Layers,
+    "layout-grid": LayoutGrid,
+    "link": Link,
+    "link-2": Link2,
+    "list": List,
+    "loader": Loader,
+    "lock": Lock,
+    "lock-open": LockOpen,
+    "log-in": LogIn,
+    "log-out": LogOut,
+    "mail": Mail,
+    "map": Map,
+    "map-pin": MapPin,
+    "maximize": Maximize,
+    "maximize-2": Maximize2,
+    "menu": Menu,
+    "message-circle": MessageCircle,
+    "message-square": MessageSquare,
+    "mic": Mic,
+    "mic-off": MicOff,
+    "minus": Minus,
+    "monitor": Monitor,
+    "moon": Moon,
+    "music": Music,
+    "navigation": Navigation,
+    "package": Package,
+    "panel-left": PanelLeft,
+    "panels-top-left": PanelsTopLeft,
+    "party-popper": PartyPopper,
+    "pen": Pen,
+    "pen-line": PenLine,
+    "pencil": Pencil,
+    "percent": Percent,
+    "phone": Phone,
+    "play": Play,
+    "plus": Plus,
+    "printer": Printer,
+    "radio": Radio,
+    "refresh-cw": RefreshCw,
+    "repeat": Repeat,
+    "rotate-cw": RotateCw,
+    "search": Search,
+    "send": Send,
+    "server": Server,
+    "settings": Settings,
+    "share": Share,
+    "share-2": Share2,
+    "shield": Shield,
+    "shield-off": ShieldOff,
+    "shopping-bag": ShoppingBag,
+    "shopping-cart": ShoppingCart,
+    "shuffle": Shuffle,
+    "slash": Slash,
+    "sliders-horizontal": SlidersHorizontal,
+    "sliders-vertical": SlidersVertical,
+    "smartphone": Smartphone,
+    "square": Square,
+    "square-check-big": SquareCheckBig,
+    "square-pen": SquarePen,
+    "star": Star,
+    "sun": Sun,
+    "tag": Tag,
+    "terminal": Terminal,
+    "thumbs-up": ThumbsUp,
+    "trash": Trash,
+    "trending-down": TrendingDown,
+    "trending-up": TrendingUp,
+    "triangle-alert": TriangleAlert,
+    "truck": Truck,
+    "underline": Underline,
+    "upload": Upload,
+    "user": User,
+    "user-check": UserCheck,
+    "user-minus": UserMinus,
+    "user-plus": UserPlus,
+    "users": Users,
+    "video": Video,
+    "wifi-off": WifiOff,
+    "wrench": Wrench,
+    "x": X,
+    "zap": Zap,
+};

package/dist/components/keyboardDismiss.js

@@ -1,34 +1,38 @@
 /**
  * Tap-away keyboard dismissal that never steals a touch.
  *
- * React Native's own `keyboardShouldPersistTaps="handled"` is the model: let the
- * deepest interactive view win the responder negotiation, and blur on *release*
- * only when nothing else took the tap and the finger did not scroll. RN cannot
- * apply that to the native `@expo/ui` field (it is invisible to
- * `TextInputState`), so this module re-creates the same decision with two
- * signals that need no rectangles and no responder ownership:
+ * Let the deepest interactive view win the responder negotiation, and blur on
+ * release only for an unclaimed, single-finger tap within the travel slop.
+ * Hosted `@expo/ui` inputs register with RN's `TextInputState`. A ScrollView
+ * using `keyboardShouldPersistTaps="handled"` can therefore claim dead space
+ * and blur on release if it observed no scroll, even after substantial travel.
+ * `DismissKeyboard`'s ScrollView uses `always` so this boundary owns tap dismissal
+ * with an explicit travel policy, independent of whether content can scroll.
+ * Two signals need no rectangles and no responder ownership:
  *
  *  1. `onStartShouldSetResponder` in the *bubble* phase is only ever called on a
- *     view when no descendant claimed the touch. Pressables, RN TextInputs and
- *     scroll views all claim, so being asked at all means "this tap is on dead
- *     space or on a native view that does not participate".
+ *     view when no descendant claimed the touch. Pressables and RN TextInputs
+ *     claim, as can scroll views depending on their tap policy. Being asked
+ *     means no descendant took responder ownership, not necessarily dead space.
  *  2. The package `TextInput` tags touches that begin on its surface
  *     (`markTextInputTouchStart`). Its bubble handler runs before any enclosing
  *     boundary's, so the boundary can tell a tap on *any* native field — focused
  *     or not — from dead space, and leave focus handoff, double-tap selection
  *     and the eye toggle to the platform.
  *
- * The boundary always answers `false`, so no JS responder is ever set: native
- * controls (SwiftUI/Compose fields, sliders) keep receiving every touch phase
+ * The boundary always answers `false`, so it never becomes the JS responder.
+ * Native controls (SwiftUI/Compose fields, sliders) keep receiving every touch phase
  * on both platforms, and scroll views take over drags exactly as before.
  * Dismissal happens in `onTouchEnd`, a plain bubbling event that fires whether
- * or not anyone became the responder; a drag past the slop or a cancel drops it.
+ * or not anyone became the responder. Moves cancel permanently once past the
+ * slop; release coordinates also enforce it when move delivery was missed.
+ * Cancellation and multitouch drop the tap without rearming another finger.
  */
 import { useMemo, useRef } from "react";
 import { Platform } from "react-native";
 import { KeyboardController, useKeyboardState } from "./keyboardController";
 import { dismissKeyboardFocusedInput, hasKeyboardFocusedInput } from "./keyboardFocusRegistry.js";
-/** Finger travel (pt) after which a touch counts as a scroll, not a tap. */
+/** Maximum displacement per axis (RN logical units) for a tap, scrollable or not. */
 const MOVE_SLOP = 10;
 function keyOf(event) {
     const { identifier, timestamp } = event.nativeEvent;
@@ -42,6 +46,10 @@ function isSameEvent(key, event) {
 }
 let textInputTouch = null;
 let claimedTouch = null;
+// An ancestor can observe a second finger outside an inner boundary/surface.
+// Invalidate already-armed taps there too, even if that finger lifts first and
+// the inner view only receives its original finger's final touches=[] event.
+let multiTouchVersion = 0;
 /**
  * `onStartShouldSetResponder` for a native text-field surface: decline the
  * responder (the native field keeps every touch phase) but tag the touch so an
@@ -72,6 +80,77 @@ function movedPastSlop(tap, event) {
     return (Math.abs(event.nativeEvent.pageX - tap.pageX) > MOVE_SLOP ||
         Math.abs(event.nativeEvent.pageY - tap.pageY) > MOVE_SLOP);
 }
+/** Shared single-finger travel policy for tap-away dismissal and surface focus. */
+function createTapTracker() {
+    let pending = null;
+    let armedVersion = multiTouchVersion;
+    let lastStart = null;
+    const active = new Set();
+    function readTouches(event) {
+        const { touches } = event.nativeEvent;
+        if (touches == null)
+            return false;
+        active.clear();
+        touches.forEach(({ identifier }) => active.add(identifier));
+        return true;
+    }
+    return {
+        start(event) {
+            // Negotiation precedes the plain bubbling touch-start for the same event.
+            // Observe it once; a child-claimed start reaches only onTouchStart, which
+            // clears any stale pending tap but never arms one.
+            if (isSameEvent(lastStart, event))
+                return false;
+            lastStart = keyOf(event);
+            pending = null;
+            // RN's array is authoritative, including after a missed end. The set is
+            // also a fallback for callers/tests omitting arrays, retaining other down
+            // fingers even after movement has cancelled the pending tap.
+            if (!readTouches(event))
+                active.add(event.nativeEvent.identifier);
+            if (active.size > 1 || (event.nativeEvent.changedTouches?.length ?? 1) > 1) {
+                multiTouchVersion += 1;
+                return false;
+            }
+            return active.size === 1;
+        },
+        arm(event) {
+            pending = { ...keyOf(event), pageX: event.nativeEvent.pageX, pageY: event.nativeEvent.pageY };
+            armedVersion = multiTouchVersion;
+        },
+        move(event) {
+            readTouches(event);
+            if (active.size > 1 || (event.nativeEvent.changedTouches?.length ?? 1) > 1) {
+                multiTouchVersion += 1;
+                pending = null;
+            }
+            else if (isSameTouch(pending, event) && movedPastSlop(pending, event)) {
+                pending = null;
+            }
+        },
+        end(event) {
+            const tap = pending;
+            pending = null;
+            // On touch end, touches contains the REMAINING fingers (empty on the last
+            // release); changedTouches contains those that ended. Never treat the
+            // final empty array as an invalid single-finger tap.
+            if (!readTouches(event)) {
+                active.delete(event.nativeEvent.identifier);
+                event.nativeEvent.changedTouches?.forEach(({ identifier }) => active.delete(identifier));
+            }
+            if (active.size === 0)
+                lastStart = null;
+            if (active.size > 0 || (event.nativeEvent.changedTouches?.length ?? 1) > 1) {
+                multiTouchVersion += 1;
+            }
+            return (armedVersion === multiTouchVersion &&
+                active.size === 0 &&
+                (event.nativeEvent.changedTouches?.length ?? 1) <= 1 &&
+                isSameTouch(tap, event) &&
+                !movedPastSlop(tap, event));
+        },
+    };
+}
 /**
  * View props for the painted surface around a native (`@expo/ui`) text field.
  *
@@ -87,31 +166,30 @@ function movedPastSlop(tap, event) {
 export function useTextInputSurfaceResponder(focus) {
     const focusRef = useRef(focus);
     focusRef.current = focus;
-    const tap = useRef(null);
-    return useMemo(() => ({
-        onStartShouldSetResponder: (event) => {
-            markTextInputTouchStart(event);
-            tap.current = { ...keyOf(event), pageX: event.nativeEvent.pageX, pageY: event.nativeEvent.pageY };
-            return false;
-        },
-        onTouchStart: (event) => {
-            if (tap.current && !isSameEvent(tap.current, event))
-                tap.current = null;
-        },
-        onTouchMove: (event) => {
-            if (isSameTouch(tap.current, event) && movedPastSlop(tap.current, event))
-                tap.current = null;
-        },
-        onTouchEnd: (event) => {
-            if (!isSameTouch(tap.current, event))
-                return;
-            tap.current = null;
-            focusRef.current();
-        },
-        onTouchCancel: () => {
-            tap.current = null;
-        },
-    }), []);
+    return useMemo(() => {
+        const tap = createTapTracker();
+        return {
+            onStartShouldSetResponder: (event) => {
+                markTextInputTouchStart(event);
+                if (tap.start(event))
+                    tap.arm(event);
+                return false;
+            },
+            onTouchStart: (event) => {
+                tap.start(event);
+            },
+            onTouchMove: (event) => {
+                tap.move(event);
+            },
+            onTouchEnd: (event) => {
+                if (tap.end(event))
+                    focusRef.current();
+            },
+            onTouchCancel: (event) => {
+                tap.end(event);
+            },
+        };
+    }, []);
 }
 /**
  * View props for a tap-away keyboard-dismiss boundary. Spread onto the wrapper
@@ -123,13 +201,14 @@ export function useKeyboardDismissResponder() {
     const isVisible = useKeyboardState((state) => state.isVisible);
     const isVisibleRef = useRef(isVisible);
     isVisibleRef.current = isVisible;
-    const pending = useRef(null);
     return useMemo(() => {
         if (Platform.OS === "web")
             return {};
+        const tap = createTapTracker();
         return {
             onStartShouldSetResponder: (event) => {
-                pending.current = null;
+                if (!tap.start(event))
+                    return false;
                 // `hasKeyboardFocusedInput` covers the window where a field has focus but
                 // keyboard-controller has not reported the keyboard yet (or a hardware
                 // keyboard is attached and there is no software keyboard to observe).
@@ -141,29 +220,21 @@ export function useKeyboardDismissResponder() {
                 if (isSameEvent(claimedTouch, event))
                     return false;
                 claimedTouch = keyOf(event);
-                pending.current = { ...claimedTouch, pageX: event.nativeEvent.pageX, pageY: event.nativeEvent.pageY };
+                tap.arm(event);
                 return false;
             },
             onTouchStart: (event) => {
-                // Bubbling touch events run after the negotiation for the same native
-                // event, so a fresh pending tap matches here; anything else is stale
-                // (e.g. a touch whose end never reached this view).
-                if (pending.current && !isSameEvent(pending.current, event))
-                    pending.current = null;
+                tap.start(event);
             },
             onTouchMove: (event) => {
-                if (isSameTouch(pending.current, event) && movedPastSlop(pending.current, event)) {
-                    pending.current = null;
-                }
+                tap.move(event);
             },
             onTouchEnd: (event) => {
-                if (!isSameTouch(pending.current, event))
-                    return;
-                pending.current = null;
-                dismissKeyboard();
+                if (tap.end(event))
+                    dismissKeyboard();
             },
-            onTouchCancel: () => {
-                pending.current = null;
+            onTouchCancel: (event) => {
+                tap.end(event);
             },
         };
     }, []);

package/dist/components/keyboardFocusRegistry.d.ts

@@ -1,10 +1,13 @@
 /**
  * Registry of the currently focused native (`@expo/ui`) text field.
  *
- * React Native's `TextInputState` never learns about SwiftUI / Compose fields,
- * so `Keyboard.dismiss()` cannot blur them. The package `TextInput` registers a
- * blur handle here on focus; tap-away dismissal (`keyboardDismiss.ts`) and the
- * `BottomSheet` overlay resign the field through it.
+ * Hosted `@expo/ui` inputs also register with React Native's `TextInputState`.
+ * This package registry supplies a window-independent native blur handle and
+ * focus presence even when keyboard-controller cannot observe the keyboard
+ * (for example, in an isolated native sheet window). The package `TextInput`
+ * registers on focus; tap-away dismissal (`keyboardDismiss.ts`, mounted by
+ * `DismissKeyboard` and `BottomSheet.Content`) resigns the field through that
+ * handle.
  */
 export type KeyboardFocusedInputToken = object;
 /**
@@ -21,5 +24,12 @@ export declare function hasKeyboardFocusedInput(): boolean;
 /**
  * Resign the currently-focused native field, dismissing its keyboard. Returns
  * `true` if a field was focused and a blur handle was available.
+ *
+ * Presence is cleared here, in the same call, rather than left to the field's
+ * later `onBlur`: consumers call `dismissKeyboard()` from submit handlers and
+ * the native blur callback is not guaranteed to arrive (isolated sheet window,
+ * iOS secure/plain handoff), which used to leave a stale registration behind.
+ * The clear is token-guarded, so a field that takes focus synchronously during
+ * `blur()` keeps its registration; the field's own later clear is idempotent.
  */
 export declare function dismissKeyboardFocusedInput(): boolean;

package/dist/components/keyboardFocusRegistry.js

@@ -38,11 +38,19 @@ export function hasKeyboardFocusedInput() {
 /**
  * Resign the currently-focused native field, dismissing its keyboard. Returns
  * `true` if a field was focused and a blur handle was available.
+ *
+ * Presence is cleared here, in the same call, rather than left to the field's
+ * later `onBlur`: consumers call `dismissKeyboard()` from submit handlers and
+ * the native blur callback is not guaranteed to arrive (isolated sheet window,
+ * iOS secure/plain handoff), which used to leave a stale registration behind.
+ * The clear is token-guarded, so a field that takes focus synchronously during
+ * `blur()` keeps its registration; the field's own later clear is idempotent.
  */
 export function dismissKeyboardFocusedInput() {
-    if (focusedInput) {
-        focusedInput.blur();
-        return true;
-    }
-    return false;
+    const entry = focusedInput;
+    if (!entry)
+        return false;
+    entry.blur();
+    clearKeyboardFocusedInput(entry.token);
+    return true;
 }

package/dist/components/nativeTextField.android.d.ts

@@ -0,0 +1,3 @@
+import type { TextInputProps } from "@expo/ui";
+export type NativeTextFieldProps = TextInputProps;
+export declare function NativeTextField({ ref, value, onChangeText, placeholder, autoFocus, editable: editableProp, multiline, keyboardType: keyboardTypeProp, autoCapitalize, autoCorrect, returnKeyType: returnKeyTypeProp, onSubmitEditing, onFocus, onBlur, cursorColor, textAlign, readOnly, inputMode, enterKeyHint, defaultValue, numberOfLines: numberOfLinesProp, rows, testID, placeholderTextColor, textStyle, style, secureTextEntry, autoComplete, onContentSizeChange, maxLength, caretHidden, selectionColor, selectionHandleColor, selection, onSelectionChange, selectTextOnFocus, modifiers: userModifiers, }: NativeTextFieldProps): import("react").JSX.Element;