react-native-keyboard-toolkit 0.0.0-stage → 1.0.1

package/dist/components/KeyboardToolbar.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardToolbar = KeyboardToolbar;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const useKeyboardState_1 = require("../hooks/useKeyboardState");
+function findFocusedInputIndex(inputRefs) {
+    return inputRefs.findIndex(ref => ref.current?.isFocused() === true);
+}
+function isMountedInputAt(inputRefs, index) {
+    return (index >= 0 && index < inputRefs.length && inputRefs[index]?.current != null);
+}
+function hasMountedInputBefore(inputRefs, index) {
+    return inputRefs.some((input, inputIndex) => inputIndex < index && input.current != null);
+}
+function hasMountedInputAfter(inputRefs, index) {
+    return inputRefs.some((input, inputIndex) => inputIndex > index && input.current != null);
+}
+/** An optional in-layout toolbar for input navigation and keyboard dismissal. */
+function KeyboardToolbar({ inputRefs = [], focusedInputIndex, onFocusedInputChange, onDone, doneText = 'Done', children, alwaysVisible = false, style, ...props }) {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const [trackedIndex, setTrackedIndex] = (0, react_1.useState)(-1);
+    const lastReportedIndex = (0, react_1.useRef)(-1);
+    const trackFocus = (0, react_1.useCallback)(() => {
+        const index = findFocusedInputIndex(inputRefs);
+        setTrackedIndex(current => (current === index ? current : index));
+        if (lastReportedIndex.current !== index) {
+            lastReportedIndex.current = index;
+            onFocusedInputChange?.(index);
+        }
+    }, [inputRefs, onFocusedInputChange]);
+    (0, react_1.useEffect)(() => {
+        trackFocus();
+        if (!keyboard.isVisible && !alwaysVisible) {
+            return;
+        }
+        const interval = setInterval(trackFocus, 100);
+        return () => clearInterval(interval);
+    }, [alwaysVisible, keyboard.isVisible, trackFocus]);
+    if (!alwaysVisible && !keyboard.isVisible) {
+        return null;
+    }
+    const actualFocusedIndex = findFocusedInputIndex(inputRefs);
+    const currentIndex = actualFocusedIndex >= 0
+        ? actualFocusedIndex
+        : isMountedInputAt(inputRefs, trackedIndex)
+            ? trackedIndex
+            : isMountedInputAt(inputRefs, focusedInputIndex ?? -1)
+                ? focusedInputIndex
+                : -1;
+    const canNavigateBackward = currentIndex >= 0 && hasMountedInputBefore(inputRefs, currentIndex);
+    const canNavigateForward = currentIndex >= 0 && hasMountedInputAfter(inputRefs, currentIndex);
+    const focusInDirection = (direction) => {
+        const actualIndex = findFocusedInputIndex(inputRefs);
+        const origin = actualIndex >= 0 ? actualIndex : currentIndex;
+        if (origin < 0) {
+            return;
+        }
+        for (let index = origin + direction; index >= 0 && index < inputRefs.length; index += direction) {
+            const target = inputRefs[index]?.current;
+            if (target) {
+                target.focus();
+                lastReportedIndex.current = index;
+                setTrackedIndex(index);
+                onFocusedInputChange?.(index);
+                return;
+            }
+        }
+    };
+    const done = () => {
+        const focusedInput = react_native_1.TextInput.State.currentlyFocusedInput?.();
+        if (focusedInput) {
+            react_native_1.TextInput.State.blurTextInput(focusedInput);
+        }
+        react_native_1.Keyboard.dismiss();
+        onDone?.();
+    };
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { ...props, style: [styles.toolbar, style], children: children ?? ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(react_native_1.Pressable, { accessibilityRole: "button", accessibilityLabel: "Previous input", disabled: !canNavigateBackward, onPress: () => focusInDirection(-1), style: styles.action, children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: canNavigateBackward ? styles.label : styles.disabled, children: "Previous" }) }), (0, jsx_runtime_1.jsx)(react_native_1.Pressable, { accessibilityRole: "button", accessibilityLabel: "Next input", disabled: !canNavigateForward, onPress: () => focusInDirection(1), style: styles.action, children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: canNavigateForward ? styles.label : styles.disabled, children: "Next" }) }), (0, jsx_runtime_1.jsx)(react_native_1.View, { style: styles.spacer }), (0, jsx_runtime_1.jsx)(react_native_1.Pressable, { accessibilityRole: "button", accessibilityLabel: "Done", onPress: done, style: styles.action, children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: styles.label, children: doneText }) })] })) }));
+}
+const styles = react_native_1.StyleSheet.create({
+    toolbar: {
+        alignItems: 'center',
+        backgroundColor: '#f6f7f9',
+        borderTopColor: '#d8dce2',
+        borderTopWidth: react_native_1.StyleSheet.hairlineWidth,
+        flexDirection: 'row',
+        minHeight: 48,
+        paddingHorizontal: 12,
+    },
+    action: {
+        minHeight: 44,
+        justifyContent: 'center',
+        paddingHorizontal: 10,
+    },
+    label: {
+        color: '#155eef',
+        fontSize: 15,
+        fontWeight: '600',
+    },
+    disabled: {
+        color: '#98a2b3',
+        fontSize: 15,
+    },
+    spacer: {
+        flex: 1,
+    },
+});
+exports.default = KeyboardToolbar;

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export { KeyboardAwareScrollView } from './KeyboardAwareScrollView';
+export { KeyboardAwareView } from './KeyboardAwareView';
+export { KeyboardToolbar } from './KeyboardToolbar';
+export { KeyboardDismissButton } from './KeyboardDismissButton';

package/dist/components/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardDismissButton = exports.KeyboardToolbar = exports.KeyboardAwareView = exports.KeyboardAwareScrollView = void 0;
+var KeyboardAwareScrollView_1 = require("./KeyboardAwareScrollView");
+Object.defineProperty(exports, "KeyboardAwareScrollView", { enumerable: true, get: function () { return KeyboardAwareScrollView_1.KeyboardAwareScrollView; } });
+var KeyboardAwareView_1 = require("./KeyboardAwareView");
+Object.defineProperty(exports, "KeyboardAwareView", { enumerable: true, get: function () { return KeyboardAwareView_1.KeyboardAwareView; } });
+var KeyboardToolbar_1 = require("./KeyboardToolbar");
+Object.defineProperty(exports, "KeyboardToolbar", { enumerable: true, get: function () { return KeyboardToolbar_1.KeyboardToolbar; } });
+var KeyboardDismissButton_1 = require("./KeyboardDismissButton");
+Object.defineProperty(exports, "KeyboardDismissButton", { enumerable: true, get: function () { return KeyboardDismissButton_1.KeyboardDismissButton; } });

package/dist/context/KeyboardContext.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { KeyboardProviderProps } from '../types';
+/** Optional provider for development diagnostics; keyboard subscriptions are shared globally. */
+export declare function KeyboardProvider({ children, debug, }: KeyboardProviderProps): React.JSX.Element;
+/** Read whether development diagnostics are enabled on the nearest provider. */
+export declare function useKeyboardDebug(): boolean;

package/dist/context/KeyboardContext.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardProvider = KeyboardProvider;
+exports.useKeyboardDebug = useKeyboardDebug;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const useKeyboardState_1 = require("../hooks/useKeyboardState");
+const DebugContext = (0, react_1.createContext)(false);
+/** Optional provider for development diagnostics; keyboard subscriptions are shared globally. */
+function KeyboardProvider({ children, debug = false, }) {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const previous = (0, react_1.useRef)(keyboard);
+    (0, react_1.useEffect)(() => {
+        if (debug &&
+            __DEV__ &&
+            (previous.current.isVisible !== keyboard.isVisible ||
+                previous.current.height !== keyboard.height)) {
+            console.debug('[keyboard-toolkit]', keyboard);
+        }
+        previous.current = keyboard;
+    }, [debug, keyboard]);
+    return ((0, jsx_runtime_1.jsx)(DebugContext.Provider, { value: debug, children: children }));
+}
+/** Read whether development diagnostics are enabled on the nearest provider. */
+function useKeyboardDebug() {
+    return (0, react_1.useContext)(DebugContext);
+}

package/dist/context/index.d.ts

@@ -0,0 +1 @@
+export { KeyboardProvider } from './KeyboardContext';

package/dist/context/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardProvider = void 0;
+var KeyboardContext_1 = require("./KeyboardContext");
+Object.defineProperty(exports, "KeyboardProvider", { enumerable: true, get: function () { return KeyboardContext_1.KeyboardProvider; } });

package/dist/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useKeyboard } from './useKeyboard';
+export { useKeyboardState } from './useKeyboardState';
+export { useKeyboardAnimation } from './useKeyboardAnimation';
+export { useFocusedInput } from './useFocusedInput';

package/dist/hooks/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusedInput = exports.useKeyboardAnimation = exports.useKeyboardState = exports.useKeyboard = void 0;
+var useKeyboard_1 = require("./useKeyboard");
+Object.defineProperty(exports, "useKeyboard", { enumerable: true, get: function () { return useKeyboard_1.useKeyboard; } });
+var useKeyboardState_1 = require("./useKeyboardState");
+Object.defineProperty(exports, "useKeyboardState", { enumerable: true, get: function () { return useKeyboardState_1.useKeyboardState; } });
+var useKeyboardAnimation_1 = require("./useKeyboardAnimation");
+Object.defineProperty(exports, "useKeyboardAnimation", { enumerable: true, get: function () { return useKeyboardAnimation_1.useKeyboardAnimation; } });
+var useFocusedInput_1 = require("./useFocusedInput");
+Object.defineProperty(exports, "useFocusedInput", { enumerable: true, get: function () { return useFocusedInput_1.useFocusedInput; } });

package/dist/hooks/useFocusedInput.d.ts

@@ -0,0 +1,6 @@
+import type { FocusedInputLayout } from '../types';
+/** Measure the focused TextInput when the keyboard opens; call `refresh` after layout changes. */
+export declare function useFocusedInput(): {
+    focusedInput: FocusedInputLayout | null;
+    refresh: () => Promise<FocusedInputLayout | null>;
+};

package/dist/hooks/useFocusedInput.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusedInput = useFocusedInput;
+const react_1 = require("react");
+const focusManager_1 = require("../utils/focusManager");
+const useKeyboardState_1 = require("./useKeyboardState");
+/** Measure the focused TextInput when the keyboard opens; call `refresh` after layout changes. */
+function useFocusedInput() {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const [focusedInput, setFocusedInput] = (0, react_1.useState)(null);
+    const measureSequence = (0, react_1.useRef)(0);
+    const refresh = (0, react_1.useCallback)(async () => {
+        const sequence = ++measureSequence.current;
+        const layout = await (0, focusManager_1.measureFocusedInput)((0, focusManager_1.getFocusedInput)());
+        if (sequence === measureSequence.current) {
+            setFocusedInput(current => {
+                if (current?.x === layout?.x &&
+                    current?.y === layout?.y &&
+                    current?.width === layout?.width &&
+                    current?.height === layout?.height) {
+                    return current;
+                }
+                return layout;
+            });
+        }
+        return layout;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!keyboard.isVisible) {
+            measureSequence.current += 1;
+            setFocusedInput(null);
+            return;
+        }
+        refresh();
+        const interval = setInterval(refresh, 120);
+        return () => {
+            measureSequence.current += 1;
+            clearInterval(interval);
+        };
+    }, [keyboard.isVisible, keyboard.height, refresh]);
+    return { focusedInput, refresh };
+}

package/dist/hooks/useKeyboard.d.ts

@@ -0,0 +1 @@
+export { useKeyboardState as useKeyboard } from './useKeyboardState';

package/dist/hooks/useKeyboard.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyboard = void 0;
+var useKeyboardState_1 = require("./useKeyboardState");
+Object.defineProperty(exports, "useKeyboard", { enumerable: true, get: function () { return useKeyboardState_1.useKeyboardState; } });

package/dist/hooks/useKeyboardAnimation.d.ts

@@ -0,0 +1,6 @@
+import { Animated } from 'react-native';
+/** Provides an animated 0-to-1 visibility value and the native event duration. */
+export declare function useKeyboardAnimation(): {
+    progress: Animated.Value;
+    animationDuration: number;
+};

package/dist/hooks/useKeyboardAnimation.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyboardAnimation = useKeyboardAnimation;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const useKeyboardState_1 = require("./useKeyboardState");
+/** Provides an animated 0-to-1 visibility value and the native event duration. */
+function useKeyboardAnimation() {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const progressRef = (0, react_1.useRef)(null);
+    if (!progressRef.current) {
+        progressRef.current = new react_native_1.Animated.Value(keyboard.progress);
+    }
+    const progress = progressRef.current;
+    const [reduceMotion, setReduceMotion] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        let active = true;
+        react_native_1.AccessibilityInfo.isReduceMotionEnabled()
+            .then(enabled => {
+            if (active) {
+                setReduceMotion(enabled);
+            }
+        })
+            .catch(() => {
+            // Keep animations enabled when the platform preference cannot be read.
+        });
+        const subscription = react_native_1.AccessibilityInfo.addEventListener('reduceMotionChanged', setReduceMotion);
+        return () => {
+            active = false;
+            subscription.remove();
+        };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        const animation = react_native_1.Animated.timing(progress, {
+            toValue: keyboard.progress,
+            duration: reduceMotion ? 0 : keyboard.animationDuration,
+            useNativeDriver: true,
+        });
+        animation.start();
+        return () => animation.stop();
+    }, [keyboard.animationDuration, keyboard.progress, progress, reduceMotion]);
+    return { progress, animationDuration: keyboard.animationDuration };
+}

package/dist/hooks/useKeyboardState.d.ts

@@ -0,0 +1,2 @@
+/** Subscribe to the shared, normalized keyboard state. A provider is optional. */
+export declare function useKeyboardState(): import("..").KeyboardState;

package/dist/hooks/useKeyboardState.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyboardState = useKeyboardState;
+const react_1 = require("react");
+const keyboardEvents_1 = require("../utils/keyboardEvents");
+/** Subscribe to the shared, normalized keyboard state. A provider is optional. */
+function useKeyboardState() {
+    return (0, react_1.useSyncExternalStore)(keyboardEvents_1.subscribeKeyboardState, keyboardEvents_1.getKeyboardState, keyboardEvents_1.getKeyboardState);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { KeyboardAwareScrollView, KeyboardAwareView, KeyboardDismissButton, KeyboardToolbar, } from './components';
+export { KeyboardProvider } from './context';
+export { useFocusedInput, useKeyboard, useKeyboardAnimation, useKeyboardState, } from './hooks';
+export { calculateScrollOffset, calculateKeyboardOverlap, focusInput, getFocusedInput, isAndroid, isIOS, measureFocusedInput, } from './utils';
+export type { FocusedInputLayout, KeyboardAwareScrollViewProps, KeyboardAwareScrollViewRef, KeyboardAwareViewProps, KeyboardAwareViewRef, KeyboardBehavior, KeyboardDismissButtonProps, KeyboardProviderProps, KeyboardState, KeyboardToolbarProps, TextInputRef, } from './types';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureFocusedInput = exports.isIOS = exports.isAndroid = exports.getFocusedInput = exports.focusInput = exports.calculateKeyboardOverlap = exports.calculateScrollOffset = exports.useKeyboardState = exports.useKeyboardAnimation = exports.useKeyboard = exports.useFocusedInput = exports.KeyboardProvider = exports.KeyboardToolbar = exports.KeyboardDismissButton = exports.KeyboardAwareView = exports.KeyboardAwareScrollView = void 0;
+var components_1 = require("./components");
+Object.defineProperty(exports, "KeyboardAwareScrollView", { enumerable: true, get: function () { return components_1.KeyboardAwareScrollView; } });
+Object.defineProperty(exports, "KeyboardAwareView", { enumerable: true, get: function () { return components_1.KeyboardAwareView; } });
+Object.defineProperty(exports, "KeyboardDismissButton", { enumerable: true, get: function () { return components_1.KeyboardDismissButton; } });
+Object.defineProperty(exports, "KeyboardToolbar", { enumerable: true, get: function () { return components_1.KeyboardToolbar; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "KeyboardProvider", { enumerable: true, get: function () { return context_1.KeyboardProvider; } });
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "useFocusedInput", { enumerable: true, get: function () { return hooks_1.useFocusedInput; } });
+Object.defineProperty(exports, "useKeyboard", { enumerable: true, get: function () { return hooks_1.useKeyboard; } });
+Object.defineProperty(exports, "useKeyboardAnimation", { enumerable: true, get: function () { return hooks_1.useKeyboardAnimation; } });
+Object.defineProperty(exports, "useKeyboardState", { enumerable: true, get: function () { return hooks_1.useKeyboardState; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "calculateScrollOffset", { enumerable: true, get: function () { return utils_1.calculateScrollOffset; } });
+Object.defineProperty(exports, "calculateKeyboardOverlap", { enumerable: true, get: function () { return utils_1.calculateKeyboardOverlap; } });
+Object.defineProperty(exports, "focusInput", { enumerable: true, get: function () { return utils_1.focusInput; } });
+Object.defineProperty(exports, "getFocusedInput", { enumerable: true, get: function () { return utils_1.getFocusedInput; } });
+Object.defineProperty(exports, "isAndroid", { enumerable: true, get: function () { return utils_1.isAndroid; } });
+Object.defineProperty(exports, "isIOS", { enumerable: true, get: function () { return utils_1.isIOS; } });
+Object.defineProperty(exports, "measureFocusedInput", { enumerable: true, get: function () { return utils_1.measureFocusedInput; } });

package/dist/types/index.d.ts

@@ -0,0 +1,69 @@
+import type { ScrollView, ScrollViewProps, StyleProp, TextInput, View, ViewProps, ViewStyle } from 'react-native';
+import type { ComponentPropsWithRef, ElementRef, ReactNode, RefObject } from 'react';
+type RefTarget<T> = T extends RefObject<infer Value> ? NonNullable<Value> : never;
+export type TextInputRef = RefTarget<NonNullable<ComponentPropsWithRef<typeof TextInput>['ref']>>;
+export type KeyboardAwareScrollViewRef = ElementRef<typeof ScrollView>;
+export type KeyboardAwareViewRef = ElementRef<typeof View>;
+/** Layout strategies supported by the keyboard-aware components. */
+export type KeyboardBehavior = 'smart' | 'scroll' | 'resize' | 'padding' | 'none';
+/** A normalized snapshot of the most recent on-screen keyboard event. */
+export interface KeyboardState {
+    isVisible: boolean;
+    height: number;
+    progress: 0 | 1;
+    animationDuration: number;
+    screenY?: number;
+}
+export interface KeyboardAwareScrollViewProps extends ScrollViewProps {
+    /** Defaults to `smart`, which scrolls only when the focused field is covered. */
+    behavior?: KeyboardBehavior;
+    /** Space to leave between the focused field and keyboard, in points. */
+    keyboardSpacing?: number;
+    /** Disable keyboard-driven padding and focus scrolling. */
+    enabled?: boolean;
+}
+export interface KeyboardAwareViewProps extends ViewProps {
+    /** Defaults to `smart`; absolute-positioned views are moved above the keyboard. */
+    behavior?: KeyboardBehavior;
+    /** Extra space between the view content and the keyboard, in points. */
+    keyboardSpacing?: number;
+    /** Disable keyboard-driven layout changes. */
+    enabled?: boolean;
+}
+export interface KeyboardProviderProps {
+    children: ReactNode;
+    /** Log keyboard state changes in development builds. */
+    debug?: boolean;
+}
+export interface KeyboardToolbarProps extends ViewProps {
+    /** Refs to the form inputs the toolbar should navigate between. */
+    inputRefs?: readonly RefObject<TextInputRef | null>[];
+    /** @deprecated Focus is detected automatically from the provided input refs. */
+    focusedInputIndex?: number;
+    /** Called when the focused input in `inputRefs` changes. */
+    onFocusedInputChange?: (index: number) => void;
+    /** Called after the Done action dismisses the keyboard. */
+    onDone?: () => void;
+    /** Label shown by the built-in Done button. */
+    doneText?: string;
+    /** Replaces the built-in previous/next/done controls. */
+    children?: ReactNode;
+    /** Render the toolbar while the keyboard is hidden. Defaults to false. */
+    alwaysVisible?: boolean;
+}
+export interface KeyboardDismissButtonProps extends ViewProps {
+    children: ReactNode;
+    /** Custom press handler. The keyboard is also dismissed unless disabled. */
+    onPress?: () => void;
+    /** Defaults to true. */
+    dismissKeyboard?: boolean;
+    accessibilityLabel?: string;
+    style?: StyleProp<ViewStyle>;
+}
+export interface FocusedInputLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export {};

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_KEYBOARD_SPACING = 16;
+export declare const DEFAULT_ANIMATION_DURATION = 250;

package/dist/utils/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ANIMATION_DURATION = exports.DEFAULT_KEYBOARD_SPACING = void 0;
+exports.DEFAULT_KEYBOARD_SPACING = 16;
+exports.DEFAULT_ANIMATION_DURATION = 250;

package/dist/utils/focusManager.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from 'react';
+import type { FocusedInputLayout, TextInputRef } from '../types';
+type Measurable = Pick<TextInputRef, 'measureInWindow'>;
+/** Returns the currently focused native TextInput when React Native exposes it. */
+export declare function getFocusedInput(): Measurable | null;
+/** Measure the focused TextInput in window coordinates. */
+export declare function measureFocusedInput(input?: Measurable | null): Promise<FocusedInputLayout | null>;
+/** Request focus on a TextInput ref and return whether a native input was available. */
+export declare function focusInput(input: RefObject<TextInputRef | null>): boolean;
+export {};

package/dist/utils/focusManager.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFocusedInput = getFocusedInput;
+exports.measureFocusedInput = measureFocusedInput;
+exports.focusInput = focusInput;
+const react_native_1 = require("react-native");
+/** Returns the currently focused native TextInput when React Native exposes it. */
+function getFocusedInput() {
+    const input = react_native_1.TextInput.State.currentlyFocusedInput?.();
+    if (input) {
+        return input;
+    }
+    return null;
+}
+/** Measure the focused TextInput in window coordinates. */
+function measureFocusedInput(input = getFocusedInput()) {
+    if (!input?.measureInWindow) {
+        return Promise.resolve(null);
+    }
+    return new Promise(resolve => {
+        input.measureInWindow?.((x, y, width, height) => {
+            resolve({ x, y, width, height });
+        });
+    });
+}
+/** Request focus on a TextInput ref and return whether a native input was available. */
+function focusInput(input) {
+    const node = input.current;
+    if (!node) {
+        return false;
+    }
+    node.focus();
+    return true;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { calculateKeyboardOverlap, calculateScrollOffset, } from './scrollManager';
+export { focusInput, getFocusedInput, measureFocusedInput, } from './focusManager';
+export { isAndroid, isIOS } from './platform';

package/dist/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIOS = exports.isAndroid = exports.measureFocusedInput = exports.getFocusedInput = exports.focusInput = exports.calculateScrollOffset = exports.calculateKeyboardOverlap = void 0;
+var scrollManager_1 = require("./scrollManager");
+Object.defineProperty(exports, "calculateKeyboardOverlap", { enumerable: true, get: function () { return scrollManager_1.calculateKeyboardOverlap; } });
+Object.defineProperty(exports, "calculateScrollOffset", { enumerable: true, get: function () { return scrollManager_1.calculateScrollOffset; } });
+var focusManager_1 = require("./focusManager");
+Object.defineProperty(exports, "focusInput", { enumerable: true, get: function () { return focusManager_1.focusInput; } });
+Object.defineProperty(exports, "getFocusedInput", { enumerable: true, get: function () { return focusManager_1.getFocusedInput; } });
+Object.defineProperty(exports, "measureFocusedInput", { enumerable: true, get: function () { return focusManager_1.measureFocusedInput; } });
+var platform_1 = require("./platform");
+Object.defineProperty(exports, "isAndroid", { enumerable: true, get: function () { return platform_1.isAndroid; } });
+Object.defineProperty(exports, "isIOS", { enumerable: true, get: function () { return platform_1.isIOS; } });

package/dist/utils/keyboardEvents.d.ts

@@ -0,0 +1,7 @@
+import type { KeyboardState } from '../types';
+/** Subscribe to the shared keyboard event stream. */
+export declare function subscribeKeyboardState(subscriber: () => void): () => void;
+/** Return the stable current snapshot used by `useSyncExternalStore`. */
+export declare function getKeyboardState(): KeyboardState;
+/** Reset the shared state and event listeners; intended for tests. */
+export declare function resetKeyboardStateForTests(): void;

package/dist/utils/keyboardEvents.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeKeyboardState = subscribeKeyboardState;
+exports.getKeyboardState = getKeyboardState;
+exports.resetKeyboardStateForTests = resetKeyboardStateForTests;
+const react_native_1 = require("react-native");
+const constants_1 = require("./constants");
+const platform_1 = require("./platform");
+const initialState = {
+    isVisible: false,
+    height: 0,
+    progress: 0,
+    animationDuration: 0,
+};
+let state = initialState;
+let listeners = [];
+const subscribers = new Set();
+function update(event, visible) {
+    const coordinates = event.endCoordinates;
+    state = {
+        isVisible: visible,
+        height: visible ? Math.max(0, coordinates?.height ?? 0) : 0,
+        progress: visible ? 1 : 0,
+        animationDuration: Math.max(0, event.duration ?? constants_1.DEFAULT_ANIMATION_DURATION),
+        ...(visible && typeof coordinates?.screenY === 'number'
+            ? { screenY: coordinates.screenY }
+            : {}),
+    };
+    subscribers.forEach(subscriber => subscriber());
+}
+function syncCurrentKeyboardState() {
+    const metrics = typeof react_native_1.Keyboard.metrics === 'function' ? react_native_1.Keyboard.metrics() : undefined;
+    const isVisible = typeof react_native_1.Keyboard.isVisible === 'function'
+        ? react_native_1.Keyboard.isVisible()
+        : metrics != null;
+    if (!isVisible || !metrics) {
+        return;
+    }
+    state = {
+        isVisible: true,
+        height: metrics.height,
+        progress: 1,
+        animationDuration: 0,
+        screenY: metrics.screenY,
+    };
+    subscribers.forEach(subscriber => subscriber());
+}
+function startListening() {
+    const names = (0, platform_1.getKeyboardEventNames)();
+    if (platform_1.isIOS && names.frameChange) {
+        listeners = [
+            react_native_1.Keyboard.addListener(names.frameChange, event => update(event, event.endCoordinates.height > 0)),
+        ];
+        syncCurrentKeyboardState();
+        return;
+    }
+    const showSubscription = react_native_1.Keyboard.addListener(names.show, event => update(event, true));
+    const hideSubscription = react_native_1.Keyboard.addListener(names.hide, event => update(event, false));
+    listeners = [showSubscription, hideSubscription];
+    syncCurrentKeyboardState();
+}
+function stopListening() {
+    listeners.forEach(subscription => subscription.remove());
+    listeners = [];
+}
+/** Subscribe to the shared keyboard event stream. */
+function subscribeKeyboardState(subscriber) {
+    subscribers.add(subscriber);
+    if (subscribers.size === 1) {
+        startListening();
+    }
+    return () => {
+        subscribers.delete(subscriber);
+        if (subscribers.size === 0) {
+            stopListening();
+        }
+    };
+}
+/** Return the stable current snapshot used by `useSyncExternalStore`. */
+function getKeyboardState() {
+    return state;
+}
+/** Reset the shared state and event listeners; intended for tests. */
+function resetKeyboardStateForTests() {
+    stopListening();
+    subscribers.clear();
+    state = initialState;
+}

package/dist/utils/platform.d.ts

@@ -0,0 +1,11 @@
+import type { KeyboardEventName } from 'react-native';
+/** True when running on iOS. */
+export declare const isIOS: boolean;
+/** True when running on Android. */
+export declare const isAndroid: boolean;
+/** Selects the native keyboard event names for the current platform. */
+export declare function getKeyboardEventNames(): {
+    show: KeyboardEventName;
+    hide: KeyboardEventName;
+    frameChange?: KeyboardEventName;
+};

package/dist/utils/platform.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAndroid = exports.isIOS = void 0;
+exports.getKeyboardEventNames = getKeyboardEventNames;
+const react_native_1 = require("react-native");
+/** True when running on iOS. */
+exports.isIOS = react_native_1.Platform.OS === 'ios';
+/** True when running on Android. */
+exports.isAndroid = react_native_1.Platform.OS === 'android';
+/** Selects the native keyboard event names for the current platform. */
+function getKeyboardEventNames() {
+    return exports.isIOS
+        ? {
+            show: 'keyboardWillShow',
+            hide: 'keyboardWillHide',
+            frameChange: 'keyboardWillChangeFrame',
+        }
+        : { show: 'keyboardDidShow', hide: 'keyboardDidHide' };
+}