@expo/ui 57.0.13 → 57.0.14

package/src/keyboard/index.tsx

@@ -0,0 +1,243 @@
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  type Ref,
+  type RefObject,
+} from 'react';
+import type { ReactNativeElement } from 'react-native';
+
+import { attachHostController, detachHostController } from './interop';
+import { TextInputState } from './textInputState';
+import { useMergeRefs } from '../utils/useMergeRefs';
+
+/**
+ * React Native decides whether a touch dismissed the keyboard by comparing the
+ * focused instance in `TextInputState` against the `event.target` of the touch.
+ * A hosted field can never be that target — SwiftUI children are virtual and
+ * Compose children carry no React tag — so every touch inside a host resolves to
+ * the host, and the host is what React Native has to be told about.
+ *
+ * Fields drive all of it. The host only lends its native view as the address.
+ */
+
+/** A hosted field, identified by object identity and able to act on itself. */
+type HostedField = {
+  focus: () => void;
+  blur: () => void;
+};
+
+/** One host's fields: which are mounted, which report focus. */
+type HostEntry = {
+  mounted: Set<HostedField>;
+  focused: Set<HostedField>;
+  lastFocused: HostedField | null;
+};
+
+/** The wrapper component that `requireNativeView` returns. */
+type NativeViewWrapper = {
+  getNativeRef?: () => ReactNativeElement | null;
+};
+
+/** The subset of a field's imperative handle a host needs. */
+type TextInputHandle = {
+  focus: () => unknown;
+  blur: () => unknown;
+};
+
+// Weak so a host whose fields never unregister cannot outlive its view tree.
+// Entries are still removed explicitly, since unregistering from React Native
+// matters for correctness, not only for memory.
+const hosts = new WeakMap<ReactNativeElement, HostEntry>();
+
+const HostInstanceContext = createContext<RefObject<NativeViewWrapper | null> | null>(null);
+
+/** Used by `<Host>`. Attach the returned ref to the native host view. */
+export function useTextInputHostRef() {
+  return useRef<NativeViewWrapper | null>(null);
+}
+
+/**
+ * Lends the host's native view to the fields it hosts, at any depth.
+ *
+ * A field inside a nested host uses the inner one, which is also what the hit
+ * test reports. Presented content is the exception: a field inside a `BottomSheet`
+ * or `Popover` is nested in the React tree but not in the host's view, so it
+ * registers a view the touch never lands on.
+ */
+export function TextInputHostProvider({
+  hostRef,
+  children,
+}: {
+  hostRef: RefObject<NativeViewWrapper | null>;
+  children: React.ReactNode;
+}) {
+  return <HostInstanceContext.Provider value={hostRef}>{children}</HostInstanceContext.Provider>;
+}
+
+function addField(instance: ReactNativeElement, field: HostedField) {
+  let entry = hosts.get(instance);
+  if (!entry) {
+    entry = { mounted: new Set(), focused: new Set(), lastFocused: null };
+    hosts.set(instance, entry);
+    TextInputState.registerInput(instance);
+    const hostEntry = entry;
+    attachHostController(instance, {
+      blurFocusedFields: () => hostEntry.focused.forEach((focusedField) => focusedField.blur()),
+      focusLastField: () => hostEntry.lastFocused?.focus(),
+    });
+  }
+  entry.mounted.add(field);
+}
+
+function removeField(instance: ReactNativeElement, field: HostedField) {
+  const entry = hosts.get(instance);
+  if (!entry) {
+    return;
+  }
+  entry.mounted.delete(field);
+  if (entry.lastFocused === field) {
+    entry.lastFocused = null;
+  }
+  // A field can unmount while it still holds focus.
+  if (entry.focused.delete(field) && entry.focused.size === 0) {
+    TextInputState.blurInput(instance);
+  }
+  if (entry.mounted.size === 0) {
+    // Leaving a stale focused instance behind makes `ScrollView` swallow the
+    // first tap of every gesture. `blurInput` no-ops unless it still points here.
+    TextInputState.blurInput(instance);
+    TextInputState.unregisterInput(instance);
+    detachHostController(instance);
+    hosts.delete(instance);
+  }
+}
+
+function setFieldFocused(instance: ReactNativeElement, field: HostedField, focused: boolean) {
+  const entry = hosts.get(instance);
+  if (!entry) {
+    return;
+  }
+  if (focused) {
+    entry.focused.add(field);
+    entry.lastFocused = field;
+  } else {
+    entry.focused.delete(field);
+  }
+  // Two fields swapping focus emit independent events that can arrive in either
+  // order, so the host stays focused while any of its fields is.
+  if (entry.focused.size > 0) {
+    TextInputState.focusInput(instance);
+  } else {
+    TextInputState.blurInput(instance);
+  }
+}
+
+/**
+ * Used by hosted text fields. Joins React Native's keyboard coordination through
+ * the surrounding host, and returns the ref to attach to the native view plus
+ * the focus handler to wire to its focus event. The app's own ref and callback
+ * keep working.
+ */
+export function useHostedTextInput<T extends TextInputHandle>(
+  ref: Ref<T> | undefined,
+  onFocusChange: ((focused: boolean) => void) | undefined,
+  options?: {
+    /**
+     * Blur the field when it unmounts. SwiftUI only: `blur` there affects just this field, while
+     * the Compose handler clears focus for whichever component currently holds it in the host.
+     */
+    blurOnUnmount?: boolean;
+  }
+) {
+  const hostRef = useContext(HostInstanceContext);
+  const nativeRef = useRef<T | null>(null);
+  const hostInstance = useRef<ReactNativeElement | null>(null);
+  // An `autoFocus` field can report focus before its registration effect runs.
+  const focusBeforeRegistered = useRef<boolean | null>(null);
+  // Last focus state this field reported, so unmount only blurs a field that holds focus.
+  const isFocused = useRef(false);
+
+  // Identifies this field to its host, and lets the host act on it.
+  const field = useMemo<HostedField>(
+    () => ({
+      focus: () => callHandle(nativeRef.current, 'focus'),
+      blur: () => callHandle(nativeRef.current, 'blur'),
+    }),
+    []
+  );
+
+  // Blur before React removes the field's native views: a field left first responder while its
+  // row is deleted makes UIKit assert ("refused to resign"), and every native teardown hook runs
+  // too late to clear SwiftUI's `@FocusState`. https://github.com/expo/expo/issues/49348
+  const blurOnUnmount = options?.blurOnUnmount ?? false;
+  useLayoutEffect(() => {
+    if (!blurOnUnmount) {
+      return;
+    }
+    return () => {
+      if (isFocused.current) {
+        callHandle(nativeRef.current, 'blur');
+      }
+    };
+  }, [blurOnUnmount]);
+
+  useEffect(() => {
+    // Resolved here rather than during render: the host's ref is attached by the
+    // time a hosted field's effects run.
+    const instance = hostRef?.current?.getNativeRef?.() ?? null;
+    hostInstance.current = instance;
+    if (!instance) {
+      return;
+    }
+    addField(instance, field);
+    if (focusBeforeRegistered.current != null) {
+      setFieldFocused(instance, field, focusBeforeRegistered.current);
+      focusBeforeRegistered.current = null;
+    }
+    return () => {
+      removeField(instance, field);
+      hostInstance.current = null;
+    };
+  }, [hostRef, field]);
+
+  return {
+    ref: useMergeRefs(ref, nativeRef),
+    onFocusChange: useCallback(
+      (focused: boolean) => {
+        isFocused.current = focused;
+        if (hostInstance.current) {
+          setFieldFocused(hostInstance.current, field, focused);
+        } else {
+          focusBeforeRegistered.current = focused;
+        }
+        onFocusChange?.(focused);
+      },
+      [field, onFocusChange]
+    ),
+  };
+}
+
+/**
+ * Calls one of the field's imperative view functions. They are async functions,
+ * so a rejection would otherwise surface as an unhandled rejection inside React
+ * Native's touch handling.
+ */
+function callHandle(handle: TextInputHandle | null, method: 'focus' | 'blur') {
+  const call = handle?.[method];
+  if (typeof call !== 'function') {
+    return;
+  }
+  try {
+    const result = call.call(handle);
+    if (result && typeof (result as Promise<unknown>).catch === 'function') {
+      (result as Promise<unknown>).catch(() => {});
+    }
+  } catch {
+    // A field whose native view has gone cannot be focused or blurred.
+  }
+}

package/src/keyboard/interop.ts

@@ -0,0 +1,99 @@
+import { TextInput } from 'react-native';
+
+import { TextInputState } from './textInputState';
+
+/**
+ * How a `<Host>` acts on the field that holds focus, once React Native asks the
+ * host to blur or focus.
+ */
+export type HostedFocusController = {
+  blurFocusedFields: () => void;
+  /** Refocuses the field that held focus last, if it is still there. */
+  focusLastField: () => void;
+};
+
+type FocusEntryPoints = {
+  blurTextInput: (instance: any) => void;
+  focusTextInput: (instance: any) => void;
+};
+
+// Weak so a host that unmounts without detaching cannot keep its instance alive.
+const controllers = new WeakMap<object, HostedFocusController>();
+let installed = false;
+
+/**
+ * Starts routing React Native's blur and focus requests for this host to its
+ * hosted fields.
+ */
+export function attachHostController(instance: object, controller: HostedFocusController) {
+  controllers.set(instance, controller);
+  install();
+}
+
+export function detachHostController(instance: object) {
+  controllers.delete(instance);
+}
+
+/**
+ * React Native blurs the focused input by dispatching a native `blur` view
+ * command to it. A hosted SwiftUI or Compose field cannot receive one: it has no
+ * host component of its own, so the command would land on the `<Host>` and stop
+ * there. Taking over the two entry points instead lets the host forward the
+ * request to the field that actually holds focus, through the same imperative
+ * methods `ref.blur()` and `ref.focus()` already use.
+ *
+ * Inputs React Native owns are passed through untouched, and the takeover only
+ * happens once a hosted text field exists.
+ *
+ * Re-evaluating this module, which only Fast Refresh does, adds one more wrapper
+ * in front of the previous one. That stays correct: a host this copy does not know
+ * falls through to the wrapper before it.
+ */
+function install() {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  takeOver(TextInputState);
+  // `TextInput.State` holds its own copies of these two functions, so it needs
+  // the same treatment to stay consistent with the module it copied them from.
+  takeOver(TextInput?.State as unknown as FocusEntryPoints);
+}
+
+function takeOver(target: FocusEntryPoints | undefined) {
+  // If React Native ever reshapes these, hosted fields quietly stop taking part
+  // rather than breaking the app.
+  if (typeof target?.blurTextInput !== 'function' || typeof target?.focusTextInput !== 'function') {
+    return;
+  }
+
+  const blurTextInput = target.blurTextInput;
+  const focusTextInput = target.focusTextInput;
+
+  target.blurTextInput = (instance: any) => {
+    const controller = instance ? controllers.get(instance) : undefined;
+    if (!controller) {
+      blurTextInput(instance);
+      return;
+    }
+    // Same guard as React Native: blurring an input that does not hold focus is a
+    // no-op, so a host never blurs its fields on behalf of a different input.
+    if (TextInputState.currentlyFocusedInput() !== instance) {
+      return;
+    }
+    TextInputState.blurInput(instance);
+    controller.blurFocusedFields();
+  };
+
+  target.focusTextInput = (instance: any) => {
+    const controller = instance ? controllers.get(instance) : undefined;
+    if (!controller) {
+      focusTextInput(instance);
+      return;
+    }
+    // No `focusInput` here: the field's own focus event sets the focused instance
+    // once focus actually lands, so React Native is never told about focus that
+    // did not happen.
+    controller.focusLastField();
+  };
+}

package/src/keyboard/textInputState.ts

@@ -0,0 +1,2 @@
+/// <reference path="../ts-declarations/react-native-text-input-state.d.ts" />
+export { default as TextInputState } from 'react-native/Libraries/Components/TextInput/TextInputState';

package/src/keyboard/textInputState.web.ts

@@ -0,0 +1,16 @@
+// React Native for web has no `TextInputState`: the browser owns focus. This file
+// is also what keeps the deep import in `textInputState.ts` out of the web bundle.
+// `@expo/ui/swift-ui` and `@expo/ui/jetpack-compose` have no web entry point, so a
+// cross-platform file importing either one puts this module in the web graph, and
+// without this variant the whole bundle fails to resolve rather than reaching the
+// `UnavailabilityError` those entry points already throw on web.
+export const TextInputState = {
+  currentlyFocusedInput: () => null,
+  focusInput: () => {},
+  blurInput: () => {},
+  registerInput: () => {},
+  unregisterInput: () => {},
+  isTextInput: () => false,
+  focusTextInput: () => {},
+  blurTextInput: () => {},
+};

package/src/swift-ui/Background/index.tsx

@@ -0,0 +1,38 @@
+import { requireNativeView } from 'expo';
+
+import { Slot } from '../SlotView';
+import { createViewModifierEventListener } from '../modifiers/utils';
+import { type Alignment, type CommonViewModifierProps } from '../types';
+
+export interface BackgroundProps extends CommonViewModifierProps {
+  children: React.ReactNode;
+  /**
+   * The alignment of the background content relative to the base content.
+   * @default 'center'
+   */
+  alignment?: Alignment;
+}
+
+const BackgroundNativeView: React.ComponentType<BackgroundProps> = requireNativeView(
+  'ExpoUI',
+  'BackgroundView'
+);
+
+function BackgroundContent(props: { children: React.ReactNode }) {
+  return <Slot name="content">{props.children}</Slot>;
+}
+
+Background.Content = BackgroundContent;
+
+export function Background(props: BackgroundProps) {
+  const { modifiers, children, ...restProps } = props;
+
+  return (
+    <BackgroundNativeView
+      {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
+      modifiers={modifiers}
+      {...restProps}>
+      {children}
+    </BackgroundNativeView>
+  );
+}

package/src/swift-ui/BottomSheet/index.tsx

@@ -2,6 +2,7 @@ import { requireNativeView } from 'expo';
 import { useState, type ComponentType, type ReactNode } from 'react';
 import { type NativeSyntheticEvent } from 'react-native';
 
+import { PresentedContent } from '../../PresentedContentContext';
 import { Slot } from '../SlotView';
 import { createViewModifierEventListener } from '../modifiers/utils';
 import { type CommonViewModifierProps } from '../types';
@@ -76,7 +77,9 @@ function BottomSheet(props: BottomSheetProps) {
         onDismiss?.();
       }}>
       {anchor != null ? <Slot name="anchor">{anchor}</Slot> : null}
-      {isMounted ? children : null}
+      {/* Only the sheet's content is presented in its own view controller. The anchor renders in
+          place, in the React Native surface, so it stays outside `PresentedContent`. */}
+      {isMounted ? <PresentedContent>{children}</PresentedContent> : null}
     </BottomSheetNativeView>
   );
 }

package/src/swift-ui/Host/index.tsx

@@ -1,6 +1,9 @@
 import { requireNativeView } from 'expo';
+import type { Ref } from 'react';
 import { I18nManager, type ColorValue, type StyleProp, type ViewStyle } from 'react-native';
 
+import { TextInputHostProvider, useTextInputHostRef } from '../../keyboard';
+import { useMergeRefs } from '../../utils/useMergeRefs';
 import { createViewModifierEventListener } from '../modifiers/utils';
 import { type CommonViewModifierProps } from '../types';
 
@@ -54,10 +57,16 @@ export interface HostProps extends CommonViewModifierProps {
   children: React.ReactNode;
   style?: StyleProp<ViewStyle>;
   pointerEvents?: 'box-none' | 'none' | 'box-only' | 'auto';
+  /** @hidden */
+  ref?: Ref<any>;
 }
 
 const HostNativeView: React.ComponentType<
-  HostProps & { matchContentsVertical?: boolean; matchContentsHorizontal?: boolean }
+  HostProps & {
+    matchContentsVertical?: boolean;
+    matchContentsHorizontal?: boolean;
+    ref?: Ref<any>;
+  }
 > = requireNativeView('ExpoUI', 'HostView');
 
 /**
@@ -71,26 +80,32 @@ export function Host(props: HostProps) {
     modifiers,
     layoutDirection,
     seedColor,
+    ref,
     ...restProps
   } = props;
+  const hostRef = useTextInputHostRef();
+  const mergedRef = useMergeRefs(ref, hostRef);
 
   return (
-    <HostNativeView
-      modifiers={modifiers}
-      {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
-      matchContentsVertical={
-        typeof matchContents === 'object' ? matchContents.vertical : matchContents
-      }
-      matchContentsHorizontal={
-        typeof matchContents === 'object' ? matchContents.horizontal : matchContents
-      }
-      onLayoutContent={onLayoutContent}
-      layoutDirection={
-        layoutDirection ?? (I18nManager.getConstants().isRTL ? 'rightToLeft' : 'leftToRight')
-      }
-      ignoreSafeArea={ignoreSafeArea}
-      seedColor={seedColor}
-      {...restProps}
-    />
+    <TextInputHostProvider hostRef={hostRef}>
+      <HostNativeView
+        modifiers={modifiers}
+        {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
+        matchContentsVertical={
+          typeof matchContents === 'object' ? matchContents.vertical : matchContents
+        }
+        matchContentsHorizontal={
+          typeof matchContents === 'object' ? matchContents.horizontal : matchContents
+        }
+        onLayoutContent={onLayoutContent}
+        layoutDirection={
+          layoutDirection ?? (I18nManager.getConstants().isRTL ? 'rightToLeft' : 'leftToRight')
+        }
+        ignoreSafeArea={ignoreSafeArea}
+        seedColor={seedColor}
+        {...restProps}
+        ref={mergedRef}
+      />
+    </TextInputHostProvider>
   );
 }

package/src/swift-ui/Popover/index.tsx

@@ -1,6 +1,7 @@
 import { requireNativeView } from 'expo';
 import type { NativeSyntheticEvent } from 'react-native';
 
+import { PresentedContent } from '../../PresentedContentContext';
 import { Slot } from '../SlotView';
 import { createViewModifierEventListener } from '../modifiers/utils';
 import type { CommonViewModifierProps } from '../types';
@@ -40,7 +41,12 @@ function PopoverTrigger(props: { children: React.ReactNode }) {
 }
 
 function PopoverContent(props: { children: React.ReactNode }) {
-  return <Slot name="popover">{props.children}</Slot>;
+  // Presented in its own view controller; the trigger renders in place, so only this side is wrapped.
+  return (
+    <Slot name="popover">
+      <PresentedContent>{props.children}</PresentedContent>
+    </Slot>
+  );
 }
 
 Popover.Trigger = PopoverTrigger;

package/src/swift-ui/RNHostView.tsx

@@ -1,10 +1,13 @@
 import { requireNativeView } from 'expo';
 
+import { PresentedContentContext, useIsPresentedInOwnWindow } from '../PresentedContentContext';
+
 const RNHostNativeView: React.ComponentType<any> = requireNativeView('ExpoUI', 'RNHostView');
 
 export interface RNHostViewProps {
   /**
-   * When `true`, the RNHost will update its size in the React Native view tree to match the children's size.
+   * When `true`, the RNHost will update its size in the React Native view tree to match the
+   * children's size.
    * When `false`, the RNHost will use the size of the parent SwiftUI View.
    * Can be only set once on mount.
    * @default false
@@ -17,12 +20,23 @@ export interface RNHostViewProps {
 }
 
 export function RNHostView(props: RNHostViewProps) {
+  // A sheet or popover presents its content in its own view controller, where the React Native
+  // surface root is not an ancestor and so touch dispatches don't work.
+  // Hosted content there owns its touches and is the origin it is measured from; native reads
+  // this one prop for both.
+  const layoutRoot = useIsPresentedInOwnWindow();
+
   return (
     <RNHostNativeView
       {...props}
+      layoutRoot={layoutRoot}
       // `matchContents` can only be used once on mount
       // So we force unmount when it changes to prevent unexpected layout
-      key={props.matchContents ? 'matchContents' : 'noMatchContents'}
-    />
+      key={props.matchContents ? 'matchContents' : 'noMatchContents'}>
+      {/* Reset context here so only nearest RNHostView becomes the layout root for its children, and not any other RNHostView above it in the tree. */}
+      <PresentedContentContext.Provider value={false}>
+        {props.children}
+      </PresentedContentContext.Provider>
+    </RNHostNativeView>
   );
 }

package/src/swift-ui/SecureField/index.tsx

@@ -2,6 +2,7 @@ import { requireNativeView } from 'expo';
 import type { Ref } from 'react';
 
 import { getStateId, type ObservableState, useWorkletProp, worklets } from '../../State';
+import { useHostedTextInput } from '../../keyboard';
 import type { ViewEvent } from '../../types';
 import { Slot } from '../SlotView';
 import { createViewModifierEventListener } from '../modifiers/utils';
@@ -74,14 +75,19 @@ function Placeholder({ children }: { children: React.ReactNode }) {
  * Renders a SwiftUI `SecureField` for password input.
  */
 export function SecureField(props: SecureFieldProps) {
-  const { text, onTextChange, onFocusChange, modifiers, ...restProps } = props;
+  const { text, onTextChange, onFocusChange, modifiers, ref, ...restProps } = props;
 
   const isWorklet = !!onTextChange && !!worklets?.isWorkletFunction?.(onTextChange);
   const workletCallback = useWorkletProp(isWorklet ? onTextChange : undefined, 'onTextChange');
+  // `blurOnUnmount`: a field left first responder while its row is removed makes UIKit
+  // assert ("refused to resign"); native teardown hooks run too late to clear SwiftUI's
+  // `@FocusState`. https://github.com/expo/expo/issues/49348
+  const hosted = useHostedTextInput<SecureFieldRef>(ref, onFocusChange, { blurOnUnmount: true });
 
   return (
     <SecureFieldNativeView
       {...restProps}
+      ref={hosted.ref}
       modifiers={modifiers}
       {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
       text={getStateId(text)}
@@ -89,7 +95,7 @@ export function SecureField(props: SecureFieldProps) {
       onTextChange={
         !isWorklet && onTextChange ? (event) => onTextChange(event.nativeEvent.value) : undefined
       }
-      onFocusChange={onFocusChange ? (event) => onFocusChange(event.nativeEvent.value) : undefined}
+      onFocusChange={(event) => hosted.onFocusChange(event.nativeEvent.value)}
     />
   );
 }

package/src/swift-ui/TextField/index.tsx

@@ -2,6 +2,7 @@ import { requireNativeView } from 'expo';
 import type { Ref } from 'react';
 
 import { getStateId, type ObservableState, useWorkletProp, worklets } from '../../State';
+import { useHostedTextInput } from '../../keyboard';
 import type { ViewEvent } from '../../types';
 import { Slot } from '../SlotView';
 import { createViewModifierEventListener } from '../modifiers/utils';
@@ -114,15 +115,21 @@ export function TextField(props: TextFieldProps) {
     onFocusChange,
     onSelectionChange,
     modifiers,
+    ref,
     ...restProps
   } = props;
 
   const isWorklet = !!onTextChange && !!worklets?.isWorkletFunction?.(onTextChange);
   const workletCallback = useWorkletProp(isWorklet ? onTextChange : undefined, 'onTextChange');
+  // `blurOnUnmount`: a field left first responder while its row is removed makes UIKit
+  // assert ("refused to resign"); native teardown hooks run too late to clear SwiftUI's
+  // `@FocusState`. https://github.com/expo/expo/issues/49348
+  const hosted = useHostedTextInput<TextFieldRef>(ref, onFocusChange, { blurOnUnmount: true });
 
   return (
     <TextFieldNativeView
       {...restProps}
+      ref={hosted.ref}
       modifiers={modifiers}
       {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
       text={getStateId(text)}
@@ -131,7 +138,7 @@ export function TextField(props: TextFieldProps) {
       onTextChange={
         !isWorklet && onTextChange ? (event) => onTextChange(event.nativeEvent.value) : undefined
       }
-      onFocusChange={onFocusChange ? (event) => onFocusChange(event.nativeEvent.value) : undefined}
+      onFocusChange={(event) => hosted.onFocusChange(event.nativeEvent.value)}
       onSelectionChange={
         onSelectionChange
           ? (event) =>

package/src/swift-ui/index.tsx

@@ -52,6 +52,7 @@ export * from './ScrollView';
 export * from './Shapes';
 export * from './Mask';
 export * from './Overlay';
+export * from './Background';
 export * from './Popover';
 export * from './Grid';
 export * from './RNHostView';

package/src/ts-declarations/react-native-text-input-state.d.ts

@@ -0,0 +1,26 @@
+declare module 'react-native/Libraries/Components/TextInput/TextInputState' {
+  import type { ReactNativeElement } from 'react-native';
+
+  /**
+   * React Native's registry of focusable text inputs. `ScrollView` reads it to
+   * decide whether a touch landed on the focused input, and `Keyboard.dismiss()`
+   * blurs whatever it points at. `TextInput.State` re-exports only a read-only
+   * subset publicly, so participating in the registry requires this module.
+   */
+  const TextInputState: {
+    currentlyFocusedInput(): ReactNativeElement | null;
+    /** Marks an instance as focused. Does not dispatch a native focus command. */
+    focusInput(instance: ReactNativeElement | null): void;
+    /** Clears the focused instance, but only if it is the one passed in. */
+    blurInput(instance: ReactNativeElement | null): void;
+    registerInput(instance: ReactNativeElement): void;
+    unregisterInput(instance: ReactNativeElement): void;
+    isTextInput(instance: ReactNativeElement): boolean;
+    /** Marks an instance as focused, then dispatches a native `focus` command. */
+    focusTextInput(instance: ReactNativeElement | null): void;
+    /** Clears the focused instance, then dispatches a native `blur` command. */
+    blurTextInput(instance: ReactNativeElement | null): void;
+  };
+
+  export default TextInputState;
+}