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

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+## 1.0.1 - 2026-11-05
+
+- Fix absolutely positioned `KeyboardAwareView` footers remaining behind the
+  keyboard; animate them above the keyboard and restore their position on hide.
+- Update the demo with a scrollable form and a bottom-sticky submit action.
+- Add sticky footer regression tests and clarify platform/layout guidance.
+- Rewrite the README with concise installation, form, sticky button, and API
+  examples.
+
+## 1.0.0 - 2026-11-04
+
+- Added keyboard-aware scrolling, view layout adjustment, toolbar navigation,
+  dismissal controls, and shared keyboard hooks for iOS and Android.
+- Added public imperative ref types for both keyboard-aware components.
+- Added platform event, focus, component-ref, and lifecycle tests.
+- Documented installation, APIs, platform behavior, and device testing guidance.
+- Initial release candidate with keyboard-aware views and scrolling.
+- Added shared keyboard state and animation/focus hooks.
+- Added toolbar and keyboard dismissal components.
+- Added local React Native demo, tests, and platform guidance.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denish Dabhi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,257 @@
-# Temporary Holding Version
+# react-native-keyboard-toolkit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/react-native-keyboard-toolkit.svg)](https://www.npmjs.com/package/react-native-keyboard-toolkit)
+[![license](https://img.shields.io/npm/l/react-native-keyboard-toolkit.svg)](LICENSE)
+![platforms](https://img.shields.io/badge/platforms-iOS%20%7C%20Android-blue.svg)
+
+Keyboard-aware scroll view, sticky submit button, input toolbar, and keyboard hooks for React Native on iOS and Android. Keep focused `TextInput` fields visible, move footers above the keyboard, and read keyboard state — all in plain TypeScript, with no native module, linking, or config plugin.
+
+## Features
+
+- **`KeyboardAwareScrollView`** – a `ScrollView` that scrolls a covered input into view.
+- **`KeyboardAwareView`** – adds bottom space to normal content, or lifts an absolutely positioned footer above the keyboard (sticky button).
+- **`KeyboardToolbar`** – Previous / Next / Done controls for moving between inputs.
+- **`KeyboardDismissButton`** – a `Pressable` that dismisses the keyboard.
+- **Hooks** – `useKeyboardState` (alias `useKeyboard`), `useKeyboardAnimation`, `useFocusedInput`.
+- **Utilities** – `focusInput`, `getFocusedInput`, `measureFocusedInput`, `calculateKeyboardOverlap`, `calculateScrollOffset`, `isIOS`, `isAndroid`.
+- Written in TypeScript with bundled type declarations.
+
+## Installation
+
+```sh
+npm install react-native-keyboard-toolkit
+# or
+yarn add react-native-keyboard-toolkit
+```
+
+**Requirements:** React `>=18.2.0`, React Native `>=0.71.0`. No iOS setup is needed.
+
+On Android, set `adjustResize` on your activity in `AndroidManifest.xml`:
+
+```xml
+<activity
+    android:name=".MainActivity"
+    android:windowSoftInputMode="adjustResize"
+    ... />
+```
+
+## Quick start
+
+### Keyboard-aware form
+
+```tsx
+import React from 'react';
+import { TextInput } from 'react-native';
+import { KeyboardAwareScrollView } from 'react-native-keyboard-toolkit';
+
+export function ContactForm() {
+  return (
+    <KeyboardAwareScrollView
+      keyboardShouldPersistTaps="handled"
+      keyboardSpacing={16}
+      contentContainerStyle={{ padding: 20 }}
+    >
+      <TextInput placeholder="Name" />
+      <TextInput placeholder="Email" keyboardType="email-address" />
+      <TextInput placeholder="Message" multiline />
+    </KeyboardAwareScrollView>
+  );
+}
+```
+
+### Sticky submit button
+
+Put a `KeyboardAwareView` with `position: 'absolute'` next to the scroll view. It animates above the keyboard and returns to its original place when the keyboard closes.
+
+```tsx
+import React from 'react';
+import { Pressable, Text, TextInput, View } from 'react-native';
+import {
+  KeyboardAwareScrollView,
+  KeyboardAwareView,
+} from 'react-native-keyboard-toolkit';
+
+export function StickyForm() {
+  return (
+    <View style={{ flex: 1 }}>
+      <KeyboardAwareScrollView
+        keyboardShouldPersistTaps="handled"
+        keyboardSpacing={112} // leave room for the footer
+        contentContainerStyle={{ padding: 20, paddingBottom: 96 }}
+      >
+        <TextInput placeholder="Name" />
+        <TextInput placeholder="Email" keyboardType="email-address" />
+        <TextInput placeholder="Company" />
+        <TextInput placeholder="Message" multiline />
+      </KeyboardAwareScrollView>
+
+      <KeyboardAwareView
+        keyboardSpacing={12}
+        style={{
+          position: 'absolute',
+          left: 0,
+          right: 0,
+          bottom: 0,
+          padding: 16,
+          backgroundColor: 'white',
+        }}
+      >
+        <Pressable onPress={() => console.log('Submit')}>
+          <Text>Submit</Text>
+        </Pressable>
+      </KeyboardAwareView>
+    </View>
+  );
+}
+```
+
+Set the scroll view's `keyboardSpacing` to roughly your footer height so focused inputs are not hidden behind it.
+
+### Previous / Next / Done toolbar
+
+Pass your input refs in navigation order. The toolbar renders only while the keyboard is visible.
+
+```tsx
+import React, { useRef } from 'react';
+import { TextInput, View } from 'react-native';
+import {
+  KeyboardAwareScrollView,
+  KeyboardToolbar,
+  type TextInputRef,
+} from 'react-native-keyboard-toolkit';
+
+export function SignUpForm() {
+  const name = useRef<TextInputRef>(null);
+  const email = useRef<TextInputRef>(null);
+  const password = useRef<TextInputRef>(null);
+
+  return (
+    <View style={{ flex: 1 }}>
+      <KeyboardAwareScrollView keyboardShouldPersistTaps="handled">
+        <TextInput ref={name} placeholder="Name" />
+        <TextInput ref={email} placeholder="Email" />
+        <TextInput ref={password} placeholder="Password" secureTextEntry />
+      </KeyboardAwareScrollView>
+
+      <KeyboardToolbar inputRefs={[name, email, password]} />
+    </View>
+  );
+}
+```
+
+## API
+
+### `KeyboardAwareScrollView`
+
+Accepts all `ScrollView` props, forwards its ref to the `ScrollView`, and adds:
+
+| Prop              | Type                                                     | Default   | Description                                                                          |
+| ----------------- | -------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| `behavior`        | `'smart' \| 'scroll' \| 'resize' \| 'padding' \| 'none'` | `'smart'` | See [Behaviors](#behaviors).                                                         |
+| `keyboardSpacing` | `number`                                                 | `16`      | Gap (points) between the focused input and the keyboard. Negative values become `0`. |
+| `enabled`         | `boolean`                                                | `true`    | Turns keyboard padding and focus scrolling on or off.                                |
+
+### `KeyboardAwareView`
+
+Accepts all `View` props, forwards its ref to the native view, and supports `behavior`, `keyboardSpacing` (default `16`), and `enabled`.
+
+- **Normal layout:** adds bottom padding equal to the part of the view covered by the keyboard.
+- **`position: 'absolute'`:** animates the view up so it clears the keyboard plus `keyboardSpacing`.
+- It does not scroll to reveal hidden children.
+
+### `KeyboardToolbar`
+
+Accepts all `View` props plus:
+
+| Prop                   | Type                                | Default  | Description                                                                                          |
+| ---------------------- | ----------------------------------- | -------- | ---------------------------------------------------------------------------------------------------- |
+| `inputRefs`            | `RefObject<TextInputRef \| null>[]` | `[]`     | Inputs in navigation order. The focused input is detected automatically; unmounted refs are skipped. |
+| `onFocusedInputChange` | `(index: number) => void`           | –        | Called when the focused input changes (`-1` = none of `inputRefs`).                                  |
+| `onDone`               | `() => void`                        | –        | Called after Done dismisses the keyboard.                                                            |
+| `doneText`             | `string`                            | `'Done'` | Label of the Done button.                                                                            |
+| `alwaysVisible`        | `boolean`                           | `false`  | Show the toolbar even when the keyboard is hidden.                                                   |
+| `children`             | `ReactNode`                         | –        | Replaces the built-in Previous / Next / Done controls.                                               |
+
+### `KeyboardDismissButton`
+
+A `Pressable` (accepts `View` props) that dismisses the keyboard when pressed.
+
+| Prop                 | Type         | Default              | Description                               |
+| -------------------- | ------------ | -------------------- | ----------------------------------------- |
+| `children`           | `ReactNode`  | required             | Button content.                           |
+| `onPress`            | `() => void` | –                    | Runs before the keyboard is dismissed.    |
+| `dismissKeyboard`    | `boolean`    | `true`               | Set `false` to skip `Keyboard.dismiss()`. |
+| `accessibilityLabel` | `string`     | `'Dismiss keyboard'` | Accessibility label.                      |
+
+### `KeyboardProvider`
+
+Optional. Wrap your app in `<KeyboardProvider debug>` to log keyboard changes in development builds. Components and hooks work without it.
+
+### Behaviors
+
+| Value       | `KeyboardAwareScrollView`                                               | `KeyboardAwareView`                    |
+| ----------- | ----------------------------------------------------------------------- | -------------------------------------- |
+| `'smart'`   | Adds scroll space and scrolls only when the focused input is covered    | Adjusts for keyboard overlap (default) |
+| `'scroll'`  | Same as `'smart'`                                                       | Same as `'smart'`                      |
+| `'padding'` | Adds scroll space only, no focus scrolling                              | Same as `'smart'`                      |
+| `'resize'`  | Leaves resizing to the platform (uses automatic keyboard insets on iOS) | No adjustment                          |
+| `'none'`    | No adjustment                                                           | No adjustment                          |
+
+### Hooks
+
+```tsx
+import {
+  useKeyboardState,
+  useKeyboardAnimation,
+  useFocusedInput,
+} from 'react-native-keyboard-toolkit';
+
+const { isVisible, height, progress, animationDuration, screenY } =
+  useKeyboardState(); // `useKeyboard()` is an alias
+
+const { progress: anim, animationDuration: ms } = useKeyboardAnimation();
+// `anim` is an Animated.Value (0 → 1); updates instantly if Reduce Motion is on
+
+const { focusedInput, refresh } = useFocusedInput();
+// focusedInput: { x, y, width, height } in window coordinates, or null
+```
+
+| Hook                     | Returns                                                                                   |
+| ------------------------ | ----------------------------------------------------------------------------------------- |
+| `useKeyboardState()`     | `{ isVisible, height, progress (0 \| 1), animationDuration, screenY? }`                   |
+| `useKeyboardAnimation()` | `{ progress: Animated.Value, animationDuration }`                                         |
+| `useFocusedInput()`      | `{ focusedInput, refresh }` – the focused input's layout, and a function to re-measure it |
+
+Example: animate a view with the keyboard.
+
+```tsx
+import { Animated } from 'react-native';
+import { useKeyboardAnimation } from 'react-native-keyboard-toolkit';
+
+function FadeWithKeyboard({ children }: { children: React.ReactNode }) {
+  const { progress } = useKeyboardAnimation();
+  return (
+    <Animated.View style={{ opacity: progress }}>{children}</Animated.View>
+  );
+}
+```
+
+### Utilities and types
+
+- `focusInput(ref)` – focuses a `TextInput` ref; returns `false` if the ref is empty.
+- `getFocusedInput()` / `measureFocusedInput(input?)` – get or measure the focused input.
+- `calculateKeyboardOverlap(viewport, keyboardHeight, keyboardTop?)` and `calculateScrollOffset(input, viewport, keyboardHeight, spacing, currentOffset, keyboardTop?)` – the layout math used internally.
+- `isIOS`, `isAndroid` – platform flags.
+- Types: `KeyboardState`, `KeyboardBehavior`, `TextInputRef`, `FocusedInputLayout`, `KeyboardAwareScrollViewProps`, `KeyboardAwareScrollViewRef`, `KeyboardAwareViewProps`, `KeyboardAwareViewRef`, `KeyboardToolbarProps`, `KeyboardDismissButtonProps`, `KeyboardProviderProps`.
+
+## Tips
+
+- Use React Native `TextInput` fields inside `KeyboardAwareScrollView`. Custom input wrappers must forward refs and support native measurement.
+- Use only one keyboard-spacing component per region to avoid adding space twice.
+- Keyboard coordinates can differ across devices, edge-to-edge modes, and modals — test on the devices you support.
+
+More guides: [Installation](docs/installation.md) · [API](docs/api.md) · [Android](docs/android.md) · [iOS](docs/ios.md) · [Troubleshooting](docs/troubleshooting.md)
+
+## License
+
+[MIT](LICENSE) © Denish Dabhi

package/dist/components/KeyboardAwareScrollView.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { KeyboardAwareScrollViewProps } from '../types';
+import type { KeyboardAwareScrollViewRef } from '../types';
+/** A ScrollView that adds keyboard space and scrolls a covered focused input into view. */
+export declare const KeyboardAwareScrollView: React.ForwardRefExoticComponent<KeyboardAwareScrollViewProps & React.RefAttributes<KeyboardAwareScrollViewRef>>;
+export default KeyboardAwareScrollView;

package/dist/components/KeyboardAwareScrollView.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardAwareScrollView = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const focusManager_1 = require("../utils/focusManager");
+const scrollManager_1 = require("../utils/scrollManager");
+const KeyboardContext_1 = require("../context/KeyboardContext");
+const useKeyboardState_1 = require("../hooks/useKeyboardState");
+const constants_1 = require("../utils/constants");
+const platform_1 = require("../utils/platform");
+/** A ScrollView that adds keyboard space and scrolls a covered focused input into view. */
+exports.KeyboardAwareScrollView = (0, react_1.forwardRef)(function KeyboardAwareScrollViewComponent({ behavior = 'smart', keyboardSpacing = constants_1.DEFAULT_KEYBOARD_SPACING, enabled = true, contentContainerStyle, onScroll, onScrollBeginDrag, onContentSizeChange, onLayout, onFocusCapture, scrollEventThrottle = 16, ...props }, forwardedRef) {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const debug = (0, KeyboardContext_1.useKeyboardDebug)();
+    const scrollRef = (0, react_1.useRef)(null);
+    (0, react_1.useImperativeHandle)(forwardedRef, () => scrollRef.current, []);
+    const scrollOffset = (0, react_1.useRef)(0);
+    const lastScrollTarget = (0, react_1.useRef)(null);
+    const measurementSequence = (0, react_1.useRef)(0);
+    const [keyboardOverlap, setKeyboardOverlap] = (0, react_1.useState)(0);
+    const spacing = Math.max(0, keyboardSpacing);
+    const scrollFocusedInput = (0, react_1.useCallback)(async () => {
+        const sequence = ++measurementSequence.current;
+        if (!enabled || !keyboard.isVisible || behavior === 'resize') {
+            return;
+        }
+        const scrollView = scrollRef.current;
+        const input = (0, focusManager_1.getFocusedInput)();
+        if (!scrollView?.measureInWindow) {
+            return;
+        }
+        const viewport = await new Promise(resolve => {
+            scrollView.measureInWindow((_x, y, _width, height) => resolve({ y, height }));
+        });
+        if (sequence !== measurementSequence.current || !keyboard.isVisible) {
+            return;
+        }
+        const overlap = (0, scrollManager_1.calculateKeyboardOverlap)(viewport, keyboard.height, keyboard.screenY);
+        if (Math.abs(overlap - keyboardOverlap) > 1) {
+            setKeyboardOverlap(overlap);
+            return;
+        }
+        if (!input?.measureInWindow ||
+            behavior === 'none' ||
+            behavior === 'padding') {
+            return;
+        }
+        const inputLayout = await (0, focusManager_1.measureFocusedInput)(input);
+        if (sequence !== measurementSequence.current || !inputLayout) {
+            return;
+        }
+        const calculation = (0, scrollManager_1.calculateScrollOffset)({ y: inputLayout.y, height: inputLayout.height }, viewport, keyboard.height, spacing, scrollOffset.current, keyboard.screenY);
+        if (debug && __DEV__) {
+            console.debug('[keyboard-toolkit] scroll calculation', calculation);
+        }
+        if (Math.abs(calculation.delta) > 1 &&
+            (lastScrollTarget.current === null ||
+                Math.abs(lastScrollTarget.current - calculation.offset) > 1)) {
+            lastScrollTarget.current = calculation.offset;
+            scrollView.scrollTo({ y: calculation.offset, animated: true });
+        }
+    }, [
+        behavior,
+        debug,
+        enabled,
+        keyboard.height,
+        keyboard.isVisible,
+        keyboard.screenY,
+        keyboardOverlap,
+        spacing,
+    ]);
+    (0, react_1.useEffect)(() => {
+        if (!keyboard.isVisible) {
+            lastScrollTarget.current = null;
+            measurementSequence.current += 1;
+            setKeyboardOverlap(0);
+            return;
+        }
+        const frame = requestAnimationFrame(() => {
+            scrollFocusedInput();
+        });
+        return () => cancelAnimationFrame(frame);
+    }, [keyboard.height, keyboard.isVisible, scrollFocusedInput]);
+    const handleScroll = (0, react_1.useCallback)((event) => {
+        scrollOffset.current = event.nativeEvent.contentOffset.y;
+        if (lastScrollTarget.current !== null &&
+            Math.abs(scrollOffset.current - lastScrollTarget.current) <= 1) {
+            lastScrollTarget.current = null;
+        }
+        onScroll?.(event);
+    }, [onScroll]);
+    const handleScrollBeginDrag = (0, react_1.useCallback)((event) => {
+        lastScrollTarget.current = null;
+        onScrollBeginDrag?.(event);
+    }, [onScrollBeginDrag]);
+    const handleContentSizeChange = (0, react_1.useCallback)((width, height) => {
+        onContentSizeChange?.(width, height);
+        if (keyboard.isVisible) {
+            requestAnimationFrame(() => scrollFocusedInput());
+        }
+    }, [keyboard.isVisible, onContentSizeChange, scrollFocusedInput]);
+    const handleLayout = (0, react_1.useCallback)((event) => {
+        onLayout?.(event);
+        if (keyboard.isVisible) {
+            requestAnimationFrame(() => scrollFocusedInput());
+        }
+    }, [keyboard.isVisible, onLayout, scrollFocusedInput]);
+    const handleFocusCapture = (0, react_1.useCallback)((event) => {
+        onFocusCapture?.(event);
+        if (keyboard.isVisible) {
+            requestAnimationFrame(() => scrollFocusedInput());
+        }
+    }, [keyboard.isVisible, onFocusCapture, scrollFocusedInput]);
+    const flattenedContentStyle = react_native_1.StyleSheet.flatten(contentContainerStyle);
+    const existingBottomPadding = typeof flattenedContentStyle?.paddingBottom === 'number'
+        ? flattenedContentStyle.paddingBottom
+        : 0;
+    const shouldPad = enabled &&
+        keyboard.isVisible &&
+        behavior !== 'none' &&
+        behavior !== 'resize' &&
+        keyboardOverlap > 0;
+    const adjustedContentStyle = shouldPad && typeof flattenedContentStyle?.paddingBottom !== 'string'
+        ? [
+            contentContainerStyle,
+            {
+                paddingBottom: Math.max(existingBottomPadding, keyboardOverlap + spacing),
+            },
+        ]
+        : contentContainerStyle;
+    return ((0, jsx_runtime_1.jsx)(react_native_1.ScrollView, { ...props, automaticallyAdjustKeyboardInsets: props.automaticallyAdjustKeyboardInsets ??
+            (behavior === 'resize' && platform_1.isIOS), ref: scrollRef, contentContainerStyle: adjustedContentStyle, onContentSizeChange: handleContentSizeChange, onLayout: handleLayout, onFocusCapture: handleFocusCapture, onScroll: handleScroll, onScrollBeginDrag: handleScrollBeginDrag, scrollEventThrottle: scrollEventThrottle }));
+});
+exports.KeyboardAwareScrollView.displayName = 'KeyboardAwareScrollView';
+exports.default = exports.KeyboardAwareScrollView;

package/dist/components/KeyboardAwareView.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { KeyboardAwareViewProps } from '../types';
+import type { KeyboardAwareViewRef } from '../types';
+/** Adds keyboard spacing to in-flow content and keeps absolute footers visible. */
+export declare const KeyboardAwareView: React.ForwardRefExoticComponent<KeyboardAwareViewProps & React.RefAttributes<KeyboardAwareViewRef>>;
+export default KeyboardAwareView;

package/dist/components/KeyboardAwareView.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardAwareView = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const constants_1 = require("../utils/constants");
+const useKeyboardState_1 = require("../hooks/useKeyboardState");
+const scrollManager_1 = require("../utils/scrollManager");
+/** Adds keyboard spacing to in-flow content and keeps absolute footers visible. */
+exports.KeyboardAwareView = (0, react_1.forwardRef)(function KeyboardAwareViewComponent({ behavior = 'smart', keyboardSpacing = constants_1.DEFAULT_KEYBOARD_SPACING, enabled = true, style, onLayout, ...props }, forwardedRef) {
+    const keyboard = (0, useKeyboardState_1.useKeyboardState)();
+    const viewRef = (0, react_1.useRef)(null);
+    (0, react_1.useImperativeHandle)(forwardedRef, () => viewRef.current, []);
+    const measurementSequence = (0, react_1.useRef)(0);
+    const [keyboardOverlap, setKeyboardOverlap] = (0, react_1.useState)(0);
+    const [keyboardDisplacement, setKeyboardDisplacement] = (0, react_1.useState)(0);
+    const animatedDisplacement = (0, react_1.useRef)(new react_native_1.Animated.Value(0)).current;
+    const flattenedStyle = react_native_1.StyleSheet.flatten(style);
+    const isAbsolutelyPositioned = flattenedStyle?.position === 'absolute';
+    const spacing = Number.isFinite(keyboardSpacing)
+        ? Math.max(0, keyboardSpacing)
+        : 0;
+    const basePadding = typeof flattenedStyle?.paddingBottom === 'number'
+        ? flattenedStyle.paddingBottom
+        : 0;
+    const measureOverlap = (0, react_1.useCallback)(() => {
+        const view = viewRef.current;
+        if (!view?.measureInWindow || !keyboard.isVisible) {
+            return;
+        }
+        const sequence = ++measurementSequence.current;
+        view.measureInWindow((_x, y, _width, height) => {
+            if (sequence !== measurementSequence.current || !keyboard.isVisible) {
+                return;
+            }
+            if (!isAbsolutelyPositioned) {
+                setKeyboardOverlap((0, scrollManager_1.calculateKeyboardOverlap)({ y, height }, keyboard.height, keyboard.screenY));
+            }
+            setKeyboardDisplacement(isAbsolutelyPositioned && typeof keyboard.screenY === 'number'
+                ? (0, scrollManager_1.calculateKeyboardDisplacement)({ y, height }, keyboard.screenY, spacing)
+                : 0);
+        });
+    }, [
+        isAbsolutelyPositioned,
+        keyboard.height,
+        keyboard.isVisible,
+        keyboard.screenY,
+        spacing,
+    ]);
+    (0, react_1.useEffect)(() => {
+        if (!keyboard.isVisible) {
+            measurementSequence.current += 1;
+            setKeyboardOverlap(0);
+            setKeyboardDisplacement(0);
+            return;
+        }
+        const frame = requestAnimationFrame(measureOverlap);
+        return () => cancelAnimationFrame(frame);
+    }, [keyboard.isVisible, keyboard.height, keyboard.screenY, measureOverlap]);
+    const shouldAdjust = enabled &&
+        keyboard.isVisible &&
+        behavior !== 'none' &&
+        behavior !== 'resize';
+    (0, react_1.useEffect)(() => {
+        if (!isAbsolutelyPositioned) {
+            animatedDisplacement.setValue(0);
+            return;
+        }
+        const animation = react_native_1.Animated.timing(animatedDisplacement, {
+            toValue: shouldAdjust ? -keyboardDisplacement : 0,
+            duration: keyboard.animationDuration,
+            useNativeDriver: true,
+        });
+        animation.start();
+        return () => animation.stop();
+    }, [
+        animatedDisplacement,
+        isAbsolutelyPositioned,
+        keyboard.animationDuration,
+        keyboardDisplacement,
+        shouldAdjust,
+    ]);
+    const handleLayout = (0, react_1.useCallback)((event) => {
+        onLayout?.(event);
+        measureOverlap();
+    }, [measureOverlap, onLayout]);
+    const adjustPadding = shouldAdjust &&
+        !isAbsolutelyPositioned &&
+        keyboardOverlap > 0 &&
+        typeof flattenedStyle?.paddingBottom !== 'string';
+    const stickyTransform = isAbsolutelyPositioned
+        ? [
+            ...(Array.isArray(flattenedStyle?.transform)
+                ? flattenedStyle.transform
+                : []),
+            { translateY: animatedDisplacement },
+        ]
+        : undefined;
+    return ((0, jsx_runtime_1.jsx)(react_native_1.Animated.View, { ...props, ref: viewRef, onLayout: handleLayout, style: adjustPadding
+            ? [
+                style,
+                {
+                    paddingBottom: Math.max(basePadding, keyboardOverlap + spacing),
+                },
+            ]
+            : isAbsolutelyPositioned
+                ? [style, { transform: stickyTransform }]
+                : style }));
+});
+exports.KeyboardAwareView.displayName = 'KeyboardAwareView';
+exports.default = exports.KeyboardAwareView;

package/dist/components/KeyboardDismissButton.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { KeyboardDismissButtonProps } from '../types';
+/** A pressable that dismisses the software keyboard by default. */
+export declare function KeyboardDismissButton({ children, onPress, dismissKeyboard, accessibilityLabel, ...props }: KeyboardDismissButtonProps): React.JSX.Element;
+export default KeyboardDismissButton;

package/dist/components/KeyboardDismissButton.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardDismissButton = KeyboardDismissButton;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_native_1 = require("react-native");
+/** A pressable that dismisses the software keyboard by default. */
+function KeyboardDismissButton({ children, onPress, dismissKeyboard = true, accessibilityLabel = 'Dismiss keyboard', ...props }) {
+    const handlePress = () => {
+        onPress?.();
+        if (dismissKeyboard) {
+            react_native_1.Keyboard.dismiss();
+        }
+    };
+    return ((0, jsx_runtime_1.jsx)(react_native_1.Pressable, { ...props, accessibilityLabel: accessibilityLabel, accessibilityRole: "button", onPress: handlePress, children: children }));
+}
+exports.default = KeyboardDismissButton;

package/dist/components/KeyboardToolbar.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { KeyboardToolbarProps } from '../types';
+/** An optional in-layout toolbar for input navigation and keyboard dismissal. */
+export declare function KeyboardToolbar({ inputRefs, focusedInputIndex, onFocusedInputChange, onDone, doneText, children, alwaysVisible, style, ...props }: KeyboardToolbarProps): React.JSX.Element | null;
+export default KeyboardToolbar;