react-native-external-keyboard 0.9.1 → 0.11.1

package/lib/typescript/src/types/baseKeyboardView.types.d.ts

@@ -0,0 +1,119 @@
+import type { ViewProps, ColorValue } from 'react-native';
+import type { OnFocusChangeFn } from './focus.types';
+import type { OnKeyPressFn } from './keyPress.types';
+import type { FocusOrderProps, LockFocusType } from './focusOrder.types';
+/** Focus props shared by every keyboard-focusable component. */
+export type CommonFocusProps = {
+    /** Whether the component can receive keyboard focus. Defaults to `true`. */
+    focusable?: boolean;
+    /**
+     * Enables the halo highlight ring drawn around the component on focus.
+     *
+     * @platform ios
+     */
+    haloEffect?: boolean;
+    /**
+     * Keeps a disabled halo (`haloEffect={false}`) suppressed on views that have
+     * a `borderRadius`. UIKit re-arms the halo from the view's
+     * `layer.cornerRadius` (set by RN from `borderRadius`) on every layout pass,
+     * so the halo can reappear after being disabled; this watches layout changes
+     * and resets the focus effect each pass. Only takes effect when
+     * `haloEffect={false}`. Alternatively, move `borderRadius` to `containerStyle`
+     * so the focused view itself stays square.
+     *
+     * @platform ios
+     */
+    roundedHaloFix?: boolean;
+    /** Color used to tint the component on focus. */
+    tintColor?: ColorValue;
+    /**
+     * iOS `focusGroupIdentifier` — the identifier of the focus group this view belongs to.
+     *
+     * @platform ios
+     */
+    groupIdentifier?: string;
+    /** Directions in which focus movement is locked. See {@link LockFocusType}. */
+    lockFocus?: LockFocusType[];
+    /**
+     * Enables Android's default focus highlight for the focused native view.
+     *
+     * @platform android
+     * @default true
+     */
+    defaultFocusHighlightEnabled?: boolean;
+    /**
+     * Cross-platform focus highlight mode. `'none'` disables the focus highlight
+     * entirely — the iOS halo and the Android default highlight — equivalent to
+     * `haloEffect={false}` / `defaultFocusHighlightEnabled={false}`. `'default'`
+     * (the default) keeps the platform highlight.
+     *
+     * @default 'default'
+     */
+    tintType?: 'default' | 'none';
+};
+export type BaseFocusViewProps = {
+    /** Treats the view as a transparent focus wrapper rather than a focusable target itself. */
+    focusableWrapper?: boolean;
+    /** Called when the component gains or loses keyboard focus. */
+    onFocusChange?: OnFocusChangeFn;
+    /** Handler for the physical key-up event. */
+    onKeyUpPress?: OnKeyPressFn;
+    /** Handler for the physical key-down event. */
+    onKeyDownPress?: OnKeyPressFn;
+    /**
+     * Handler for long-press events triggered by the context-menu command.
+     *
+     * @platform ios
+     */
+    onContextMenuPress?: () => void;
+    /**
+     * Bubbling variant of {@link BaseFocusViewProps.onContextMenuPress} — fires for
+     * context-menu presses that bubble up from descendants.
+     *
+     * @platform ios
+     */
+    onBubbledContextMenuPress?: () => void;
+    /** Whether the component should automatically gain focus on mount. */
+    autoFocus?: boolean;
+    /** Called when the component gains keyboard focus. */
+    onFocus?: () => void;
+    /** Called when the component loses keyboard focus. */
+    onBlur?: () => void;
+    /**
+     * Corner radius of the halo ring, in points.
+     *
+     * @platform ios
+     */
+    haloCornerRadius?: number;
+    /**
+     * Horizontal expansion of the halo ring beyond the view bounds, in points.
+     *
+     * @platform ios
+     */
+    haloExpendX?: number;
+    /**
+     * Vertical expansion of the halo ring beyond the view bounds, in points.
+     *
+     * @platform ios
+     */
+    haloExpendY?: number;
+    /** Enables the context-menu interaction on the view. */
+    enableContextMenu?: boolean;
+    /** Enables moving screen reader focus to this component automatically. */
+    screenAutoA11yFocus?: boolean;
+    /**
+     * Delay before screen reader auto-focus is applied. On Android focus can only be
+     * applied after render, which may take 300–500 ms.
+     *
+     * @platform android
+     * @default 300
+     */
+    screenAutoA11yFocusDelay?: number;
+    /**
+     * @deprecated No longer has any effect — kept only for backwards compatibility.
+     */
+    enableA11yFocus?: boolean;
+} & CommonFocusProps & FocusOrderProps;
+/** Props for `BaseKeyboardView` — standard `ViewProps` plus all focus props. */
+export type BaseKeyboardViewProps = ViewProps & BaseFocusViewProps;
+//# sourceMappingURL=baseKeyboardView.types.d.ts.map

package/lib/typescript/src/types/baseKeyboardView.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseKeyboardView.types.d.ts","sourceRoot":"","sources":["../../../../src/types/baseKeyboardView.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEzE,gEAAgE;AAChE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iDAAiD;IACjD,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,4FAA4F;IAC5F,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,+DAA+D;IAC/D,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,6CAA6C;IAC7C,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,+CAA+C;IAC/C,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;IAChC;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,MAAM,IAAI,CAAC;IACvC,sEAAsE;IACtE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wDAAwD;IACxD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;OAMG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GAAG,gBAAgB,GAClB,eAAe,CAAC;AAElB,gFAAgF;AAChF,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,kBAAkB,CAAC"}

package/lib/typescript/src/types/focus.types.d.ts

@@ -0,0 +1,44 @@
+import type { ElementRef } from 'react';
+import type { HostComponent, NativeSyntheticEvent } from 'react-native';
+/**
+ * The host view ref instance (`measure`, `measureInWindow`, `setNativeProps`, …).
+ *
+ * RN exposes this as `HostInstance` from 0.77 onward; we derive it from
+ * `HostComponent` so the type also resolves on older RN (e.g. 0.76).
+ */
+type HostInstance = ElementRef<HostComponent<unknown>>;
+/**
+ * Handler invoked when a view gains or loses keyboard focus.
+ *
+ * @param isFocused `true` on focus, `false` on blur.
+ * @param tag Native view tag of the affected element, when available.
+ */
+export type OnFocusChangeFn = (isFocused: boolean, tag?: number) => void;
+/** Imperative focus handle exposed via `ref` on keyboard-focusable components. */
+export type KeyboardFocusHandle = {
+    /** Moves both physical-keyboard and screen-reader focus to this element. */
+    focus: () => void;
+    /** Moves physical-keyboard focus to this element. */
+    keyboardFocus: () => void;
+    /** Moves screen reader (VoiceOver / TalkBack) focus to this element. */
+    screenReaderFocus: () => void;
+};
+/**
+ * The underlying native view instance augmented with the imperative
+ * {@link KeyboardFocusHandle}. Uses RN's `HostInstance` (the host view ref —
+ * `measure`, `measureInWindow`, `setNativeProps`, …) rather than the `View`
+ * component type, so it resolves correctly under both the legacy and strict
+ * (`react-native-strict-api`) RN type sets.
+ */
+export type KeyboardFocus = HostInstance & KeyboardFocusHandle;
+/** Alias of {@link KeyboardFocus}. */
+export type BaseKeyboardViewType = KeyboardFocus;
+/** Native event payload emitted by the view's focus-change callback. */
+export type KeyboardFocusEvent = NativeSyntheticEvent<{
+    isFocused: boolean;
+    target?: number;
+}>;
+/** Handler receiving the raw {@link KeyboardFocusEvent} from the native view. */
+export type NativeFocusChangeHandler = (e: KeyboardFocusEvent) => void;
+export {};
+//# sourceMappingURL=focus.types.d.ts.map

package/lib/typescript/src/types/focus.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus.types.d.ts","sourceRoot":"","sources":["../../../../src/types/focus.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAExE;;;;;GAKG;AACH,KAAK,YAAY,GAAG,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAEzE,kFAAkF;AAClF,MAAM,MAAM,mBAAmB,GAAG;IAChC,4EAA4E;IAC5E,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,qDAAqD;IACrD,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,IAAI,CAAC;CAC/B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,mBAAmB,CAAC;AAE/D,sCAAsC;AACtC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC;AAEjD,wEAAwE;AACxE,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;IACpD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH,iFAAiF;AACjF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,EAAE,kBAAkB,KAAK,IAAI,CAAC"}

package/lib/typescript/src/types/focusOrder.types.d.ts

@@ -0,0 +1,57 @@
+import type { Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+/**
+ * Directions in which keyboard focus movement can be locked via {@link CommonFocusProps.lockFocus}.
+ *
+ * - `Up` / `Down` / `Left` / `Right` — block directional (arrow / DPad) movement.
+ * - `Forward` / `Backward` — block `Tab` and `Shift + Tab` movement.
+ * - `First` / `Last` — block jumping to the first / last focusable element.
+ */
+export declare enum LockFocusEnum {
+    Up = "up",
+    Down = "down",
+    Right = "right",
+    Left = "left",
+    Forward = "forward",
+    Backward = "backward",
+    First = "first",
+    Last = "last"
+}
+/** String-literal form of {@link LockFocusEnum} — `'up' | 'down' | 'left' | …`. */
+export type LockFocusType = `${LockFocusEnum}`;
+/**
+ * Link-based focus ordering props. Each `order*` target names the {@link FocusOrderProps.orderId orderId}
+ * of the element that should receive focus when moving in that direction.
+ *
+ * > `orderId` values are global. In repeated content (lists, cards) duplicate IDs cause
+ * > incorrect focus jumps — namespace them with `orderPrefix` or a `KeyboardOrderFocusGroup`.
+ */
+export type FocusOrderProps = {
+    /** Unique ID used as the link target for other elements' `order*` props. */
+    orderId?: string;
+    /** ID of the target focused when navigating left. */
+    orderLeft?: string;
+    /** ID of the target focused when navigating right. */
+    orderRight?: string;
+    /** ID of the target focused when navigating upward. */
+    orderUp?: string;
+    /** ID of the target focused when navigating downward. */
+    orderDown?: string;
+    /** ID of the target focused on forward navigation (`Tab`). */
+    orderForward?: string;
+    /** ID of the target focused on backward navigation (`Shift + Tab`). */
+    orderBackward?: string;
+    /** ID of the target focused when jumping to the first element. `null` clears the link. */
+    orderFirst?: string | null;
+    /** ID of the target focused when jumping to the last element. `null` clears the link. */
+    orderLast?: string | null;
+    /** Name of the group for index-based focus ordering. Pair with {@link FocusOrderProps.orderIndex orderIndex}. */
+    orderGroup?: string;
+    /** Position of this element within its {@link FocusOrderProps.orderGroup orderGroup}; lower indices are focused first. */
+    orderIndex?: Int32;
+    /**
+     * Prefix prepended to this component's `orderId` and all `order*` target IDs.
+     * Use it to namespace IDs in repeated components (lists, cards) so global IDs stay unique.
+     */
+    orderPrefix?: string;
+};
+//# sourceMappingURL=focusOrder.types.d.ts.map

package/lib/typescript/src/types/focusOrder.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusOrder.types.d.ts","sourceRoot":"","sources":["../../../../src/types/focusOrder.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2CAA2C,CAAC;AAEvE;;;;;;GAMG;AACH,oBAAY,aAAa;IACvB,EAAE,OAAO;IACT,IAAI,SAAS;IACb,KAAK,UAAU;IACf,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,IAAI,SAAS;CACd;AAED,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG,GAAG,aAAa,EAAE,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iHAAiH;IACjH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0HAA0H;IAC1H,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC"}

package/lib/typescript/src/types/focusStyle.types.d.ts

@@ -0,0 +1,11 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+/** State argument passed to a {@link FocusStyle} callback. */
+export type FocusStateCallbackType = {
+    readonly focused: boolean;
+};
+/**
+ * A style applied based on focus state. Either a static style, or a callback that
+ * receives `{ focused }` and returns the style to apply for the current state.
+ */
+export type FocusStyle = StyleProp<ViewStyle> | ((state: FocusStateCallbackType) => StyleProp<ViewStyle>) | undefined;
+//# sourceMappingURL=focusStyle.types.d.ts.map

package/lib/typescript/src/types/focusStyle.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focusStyle.types.d.ts","sourceRoot":"","sources":["../../../../src/types/focusStyle.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzD,8DAA8D;AAC9D,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,CAAC,SAAS,CAAC,GACpB,CAAC,CAAC,KAAK,EAAE,sBAAsB,KAAK,SAAS,CAAC,SAAS,CAAC,CAAC,GACzD,SAAS,CAAC"}

package/lib/typescript/src/types/index.d.ts

@@ -1,3 +1,12 @@
-export type { KeyboardFocusViewProps, OnFocusChangeFn, } from './KeyboardFocusView.types';
-export type { FocusStateCallbackType, FocusStyle } from './FocusStyle';
+export type { FocusViewProps, KeyboardFocusViewProps, } from './KeyboardFocusView.types';
+export type { KeyboardFocusLockProps } from './KeyboardFocusLock.types';
+export { LockComponentType } from './KeyboardFocusLock.types';
+export type { OnFocusChangeFn, KeyboardFocus, BaseKeyboardViewType, KeyboardFocusEvent, NativeFocusChangeHandler, } from './focus.types';
+export type { OnKeyPress, OnKeyPressFn } from './keyPress.types';
+export type { FocusOrderProps, LockFocusType } from './focusOrder.types';
+export { LockFocusEnum } from './focusOrder.types';
+export type { BaseFocusViewProps, BaseKeyboardViewProps, } from './baseKeyboardView.types';
+export type { FocusStateCallbackType, FocusStyle } from './focusStyle.types';
+export type { ExtraKeyboardProps, KeyboardInputProps, KeyboardInputPropsDeclaration, } from './keyboardInput.types';
+export type { WithKeyboardFocusProps, WithKeyboardFocusPropsWithRef, KeyboardFocusableComponent, KeyboardFocusableComponentDeclaration, WithKeyboardProps, KeyboardPressType, ChildrenRenderState, } from './withKeyboardFocus.types';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,sBAAsB,EACtB,eAAe,GAChB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,cAAc,EACd,sBAAsB,GACvB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,YAAY,EACV,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACjE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7E,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,6BAA6B,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,sBAAsB,EACtB,6BAA6B,EAC7B,0BAA0B,EAC1B,qCAAqC,EACrC,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC"}

package/lib/typescript/src/types/keyPress.types.d.ts

@@ -0,0 +1,7 @@
+import type { NativeSyntheticEvent } from 'react-native';
+import type { KeyPress } from '../nativeSpec/ExternalKeyboardViewNativeComponent';
+/** Native event payload for a physical key press (key down / key up). */
+export type OnKeyPress = NativeSyntheticEvent<KeyPress>;
+/** Handler receiving a physical {@link OnKeyPress} event. */
+export type OnKeyPressFn = (e: OnKeyPress) => void;
+//# sourceMappingURL=keyPress.types.d.ts.map

package/lib/typescript/src/types/keyPress.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPress.types.d.ts","sourceRoot":"","sources":["../../../../src/types/keyPress.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mDAAmD,CAAC;AAElF,yEAAyE;AACzE,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;AAExD,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,CAAC"}

package/lib/typescript/src/types/keyboardInput.types.d.ts

@@ -0,0 +1,53 @@
+import { type TextInputProps, type StyleProp, type ViewStyle } from 'react-native';
+import type { FocusStyle } from './focusStyle.types';
+import type { FocusOrderProps } from './focusOrder.types';
+import type { CommonFocusProps } from './baseKeyboardView.types';
+/** Keyboard-focus props added on top of React Native's `TextInputProps`. */
+export type ExtraKeyboardProps = {
+    /**
+     * How the input acquires focus.
+     *
+     * - `'default'` — platform default (Android focuses the input; iOS requires a press).
+     * - `'press'` — press the spacebar to focus the input.
+     * - `'auto'` — focus automatically; keyboard focus targets the input.
+     */
+    focusType?: 'default' | 'press' | 'auto';
+    /**
+     * How the input blurs when keyboard focus moves away.
+     *
+     * - `'default'` — keep typing allowed while focus is on another component.
+     * - `'disable'` — blur the input when focus moves away.
+     * - `'auto'` — platform-managed blur behavior.
+     *
+     * @platform ios
+     */
+    blurType?: 'default' | 'disable' | 'auto';
+    /** Style for the container wrapping the input. */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Called when the input gains or loses keyboard focus. */
+    onFocusChange?: (isFocused: boolean) => void;
+    /** Style applied to the inner `TextInput` while focused. */
+    focusStyle?: FocusStyle;
+    /** Style applied to the container while focused. */
+    containerFocusStyle?: FocusStyle;
+    /** Behavior of the submit / return key. */
+    submitBehavior?: string;
+} & CommonFocusProps & FocusOrderProps;
+/**
+ * `TextInput` props that differ across React Native versions and so are loosened
+ * to also accept `null` for backward/forward compatibility.
+ */
+type IgnoreForCompatibility = 'rejectResponderTermination' | 'selectionHandleColor' | 'cursorColor' | 'maxFontSizeMultiplier';
+type CompatibleInputProp<TextInputPropsType extends object, CompatibilityProp extends IgnoreForCompatibility> = CompatibilityProp extends keyof TextInputPropsType ? TextInputPropsType[CompatibilityProp] : CompatibilityProp extends keyof TextInputProps ? TextInputProps[CompatibilityProp] : never;
+type ReactNativeInputCompatibility<TextInputPropsType extends object = TextInputProps> = Omit<TextInputPropsType, IgnoreForCompatibility> & {
+    [CompatibilityProp in IgnoreForCompatibility]?: CompatibleInputProp<TextInputPropsType, CompatibilityProp> | null;
+};
+/**
+ * Generic form of {@link KeyboardInputProps}. Combines a (version-compatible)
+ * `TextInputProps` shape with the library's {@link ExtraKeyboardProps}.
+ */
+export type KeyboardInputPropsDeclaration<TextInputPropsType extends object = TextInputProps> = ReactNativeInputCompatibility<TextInputPropsType> & ExtraKeyboardProps;
+/** Props for `KeyboardExtendedInput` — RN `TextInputProps` plus keyboard-focus props. */
+export type KeyboardInputProps = KeyboardInputPropsDeclaration<TextInputProps>;
+export {};
+//# sourceMappingURL=keyboardInput.types.d.ts.map

package/lib/typescript/src/types/keyboardInput.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboardInput.types.d.ts","sourceRoot":"","sources":["../../../../src/types/keyboardInput.types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IACzC;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,kDAAkD;IAClD,cAAc,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACtC,2DAA2D;IAC3D,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,4DAA4D;IAC5D,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,oDAAoD;IACpD,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC,2CAA2C;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,gBAAgB,GAClB,eAAe,CAAC;AAElB;;;GAGG;AACH,KAAK,sBAAsB,GACvB,4BAA4B,GAC5B,sBAAsB,GACtB,aAAa,GACb,uBAAuB,CAAC;AAE5B,KAAK,mBAAmB,CACtB,kBAAkB,SAAS,MAAM,EACjC,iBAAiB,SAAS,sBAAsB,IAC9C,iBAAiB,SAAS,MAAM,kBAAkB,GAClD,kBAAkB,CAAC,iBAAiB,CAAC,GACrC,iBAAiB,SAAS,MAAM,cAAc,GAC9C,cAAc,CAAC,iBAAiB,CAAC,GACjC,KAAK,CAAC;AAEV,KAAK,6BAA6B,CAChC,kBAAkB,SAAS,MAAM,GAAG,cAAc,IAChD,IAAI,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,GAAG;KACpD,iBAAiB,IAAI,sBAAsB,CAAC,CAAC,EAAE,mBAAmB,CACjE,kBAAkB,EAClB,iBAAiB,CAClB,GAAG,IAAI;CACT,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,6BAA6B,CACvC,kBAAkB,SAAS,MAAM,GAAG,cAAc,IAChD,6BAA6B,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,CAAC;AAE3E,yFAAyF;AACzF,MAAM,MAAM,kBAAkB,GAAG,6BAA6B,CAAC,cAAc,CAAC,CAAC"}

package/lib/typescript/src/types/withKeyboardFocus.types.d.ts

@@ -0,0 +1,109 @@
+import type { PressableProps, View, ViewProps } from 'react-native';
+import type { FocusStyle } from './focusStyle.types';
+import type { KeyboardFocus } from './focus.types';
+import type { OnKeyPress } from './keyPress.types';
+import type { FocusViewProps } from './KeyboardFocusView.types';
+import type { RefAttributes } from 'react';
+/** Fallback press handler used when the wrapped component declares no matching prop. */
+type KeyboardPressHandler = (e?: OnKeyPress) => void;
+/**
+ * Resolves a press-handler prop type: reuses the wrapped component's own signature
+ * if it declares `PropName`, otherwise falls back to {@link KeyboardPressHandler}.
+ */
+type PressHandlerProp<ComponentProps extends object, PropName extends 'onPress' | 'onLongPress' | 'onPressIn' | 'onPressOut'> = PropName extends keyof ComponentProps ? ComponentProps[PropName] : KeyboardPressHandler;
+/** Picks the wrapped component's prop type for `PropName`, or `unknown` if absent. */
+type PickProp<ComponentProps extends object, PropName extends string> = PropName extends keyof ComponentProps ? ComponentProps[PropName] : unknown;
+/** A component constructor that {@link WithKeyboardFocusProps} can enhance. */
+export type KeyboardFocusableComponent<ComponentProps extends object> = React.JSXElementConstructor<ComponentProps>;
+/**
+ * Press and focus callbacks layered onto the wrapped component. Press handlers reuse
+ * the wrapped component's own signatures where possible; `onComponent{Focus,Blur}`
+ * forward to the wrapped component's native `onFocus` / `onBlur`.
+ */
+export type KeyboardPressType<ComponentProps extends object> = {
+    /** Called on press (touch or physical key). */
+    onPress?: PressHandlerProp<ComponentProps, 'onPress'>;
+    /** Called on long press (touch or physical key). */
+    onLongPress?: PressHandlerProp<ComponentProps, 'onLongPress'>;
+    /** Called when a press begins. */
+    onPressIn?: PressHandlerProp<ComponentProps, 'onPressIn'>;
+    /** Called when a press ends. */
+    onPressOut?: PressHandlerProp<ComponentProps, 'onPressOut'>;
+    /** Forwarded to the wrapped component's own `onFocus`. */
+    onComponentFocus?: PickProp<ComponentProps, 'onFocus'>;
+    /** Forwarded to the wrapped component's own `onBlur`. */
+    onComponentBlur?: PickProp<ComponentProps, 'onBlur'>;
+};
+/** Extracts the state argument from a component's children render prop, or `never`. */
+type ExtractRenderPropState<T> = T extends (state: infer S) => any ? S : never;
+/** The render-prop state of the wrapped component's `children`, or `never` if it has none. */
+export type ChildrenRenderState<CP extends object> = 'children' extends keyof CP ? ExtractRenderPropState<NonNullable<CP['children']>> : never;
+/**
+ * `renderContent` signature — receives the wrapped component's own render-prop state
+ * merged with `{ focused }`. Resolves to `never` when the component has no render-prop children.
+ */
+type RenderContentProp<CP extends object> = ChildrenRenderState<CP> extends never ? never : (state: ChildrenRenderState<CP> & {
+    focused: boolean;
+}) => React.ReactNode;
+/**
+ * `renderFocusable` signature — receives only `{ focused }`. Use it on components
+ * (e.g. `TouchableOpacity`) that don't expose a render-prop `children`.
+ */
+type RenderFocusableProp = (state: {
+    focused: boolean;
+}) => React.ReactNode;
+type RenderSlot<CP extends object> = {
+    renderContent?: RenderContentProp<CP>;
+    renderFocusable?: RenderFocusableProp;
+};
+type WithKeyboardBaseProps<ViewType, ViewStyleType> = {
+    /**
+     * Enables the `pressed` style handler for custom components. Always effectively
+     * `true` for the standard `Pressable`.
+     *
+     * @default false
+     */
+    withPressedStyle?: boolean;
+    /**
+     * Android only. Physical-keyboard activation (Enter / Space / DPad-center)
+     * does not flow through the touch responder, so the wrapped component's
+     * `pressed` state stays `false` for keyboard presses. When enabled, the
+     * press is tracked from the key down/up events and merged into the `pressed`
+     * value passed to `renderContent` and to the `style({ pressed })` function.
+     * No-op on iOS, where native focus already drives `pressed`.
+     */
+    androidKeyboardPressState?: boolean;
+    /** Style for the container wrapping the component. */
+    containerStyle?: ViewStyleType | ViewProps['style'];
+    /** Style applied to the container while focused. */
+    containerFocusStyle?: FocusStyle;
+    /** Ref to the wrapped component instance. */
+    componentRef?: React.RefObject<ViewType>;
+    /** Style for the wrapped component. */
+    style?: PressableProps['style'];
+    /** Called when the component loses keyboard focus. */
+    onBlur?: (() => void) | null;
+    /** Called when the component gains keyboard focus. */
+    onFocus?: (() => void) | null;
+};
+/**
+ * The keyboard-focus-specific props added by {@link WithKeyboardFocusProps}: container
+ * styling, refs, focus callbacks, and the mutually-exclusive `renderContent` /
+ * `renderFocusable` slot.
+ */
+export type WithKeyboardProps<ViewType = View, ViewStyleType = unknown, ComponentProps extends object = {}> = WithKeyboardBaseProps<ViewType, ViewStyleType> & RenderSlot<ComponentProps>;
+type KeyboardFocusBaseProps = Omit<FocusViewProps, 'onPress' | 'onLongPress' | 'onBlur' | 'onFocus'>;
+type MergeProps<BaseProps extends object, OverrideProps extends object> = Omit<BaseProps, keyof OverrideProps> & OverrideProps;
+type KeyboardFocusOverrideProps<ComponentProps extends object, ViewStyleType, ViewType = View> = KeyboardPressType<ComponentProps> & KeyboardFocusBaseProps & WithKeyboardProps<ViewType, ViewStyleType, ComponentProps>;
+/**
+ * Full prop type for a `withKeyboardFocus`-wrapped component: the wrapped component's
+ * own props, with the library's press/focus/order props merged in (library props win
+ * on conflict).
+ */
+export type WithKeyboardFocusProps<ComponentProps extends object, ViewStyleType, ViewType = View> = MergeProps<ComponentProps, KeyboardFocusOverrideProps<ComponentProps, ViewStyleType, ViewType>>;
+/** {@link WithKeyboardFocusProps} plus a `ref` exposing the {@link KeyboardFocus} handle. */
+export type WithKeyboardFocusPropsWithRef<ComponentProps extends object, ViewStyleType, ViewType = View> = WithKeyboardFocusProps<ComponentProps, ViewStyleType, ViewType> & RefAttributes<KeyboardFocus>;
+/** Type of the component returned by `withKeyboardFocus`. */
+export type KeyboardFocusableComponentDeclaration<ComponentProps extends object, ViewStyleType, ViewType = View> = React.JSXElementConstructor<WithKeyboardFocusPropsWithRef<ComponentProps, ViewStyleType, ViewType>>;
+export {};
+//# sourceMappingURL=withKeyboardFocus.types.d.ts.map

package/lib/typescript/src/types/withKeyboardFocus.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withKeyboardFocus.types.d.ts","sourceRoot":"","sources":["../../../../src/types/withKeyboardFocus.types.ts"],"names":[],"mappings":"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"}

package/lib/typescript/src/utils/mapLockFocus.d.ts

@@ -0,0 +1,3 @@
+import { type LockFocusType } from '../types';
+export declare const mapLockFocus: (values: LockFocusType[] | undefined) => number;
+//# sourceMappingURL=mapLockFocus.d.ts.map

package/lib/typescript/src/utils/mapLockFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapLockFocus.d.ts","sourceRoot":"","sources":["../../../../src/utils/mapLockFocus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AA0B7D,eAAO,MAAM,YAAY,GAAI,QAAQ,aAAa,EAAE,GAAG,SAAS,KAAG,MAIlE,CAAC"}