react-native-keyboard-controller 1.9.5 → 1.10.1

package/lib/typescript/components/hooks/useKeyboardInterpolation.d.ts

@@ -0,0 +1,20 @@
+type KeyboardInterpolationOutput = [number, number];
+/**
+ * Hook that can be used for interpolation keyboard movement. The main concern is the thing
+ * when keyboard is opened and gets resized on Android. Let's say we are interpolating from
+ * closed to open [0, 200] and we want to interpolate it to [0, 230] (to achieve nice parallax effect).
+ * Then let's say keyboard changes its height to 220 (and we want to interpolate the value to 250, +30
+ * to keyboard height). If we interpolate based on `progress` value, then we will have a jump on first frame:
+ * the last interpolated position was 230, now we will interpolate to 250, but first frame will be calculated
+ * as 200 / 220 * 250 = 227 (and last interpolated position was 230) so we will have a jump.
+ *
+ * This hook handles it, and when keyboard changes its size it does an interpolation as:
+ * [200, 220] -> [230, 250], i. e. we preserve last interpolated value and use it as initial value for interpolation
+ * and because of that we will not have a jump and animation will start from the last frame and will be smooth.
+ *
+ * @see https://github.com/kirillzyusko/react-native-keyboard-controller/issues/315
+ */
+declare const useKeyboardInterpolation: () => {
+    interpolate: (keyboardPosition: number, output: KeyboardInterpolationOutput) => number;
+};
+export default useKeyboardInterpolation;

package/lib/typescript/components/index.d.ts

@@ -1,2 +1,3 @@
-export { default as KeyboardAvoidingView } from './KeyboardAvoidingView';
-export { default as KeyboardStickyView } from './KeyboardStickyView';
+export { default as KeyboardAvoidingView } from "./KeyboardAvoidingView";
+export { default as KeyboardStickyView } from "./KeyboardStickyView";
+export { default as KeyboardAwareScrollView } from "./KeyboardAwareScrollView";

package/lib/typescript/context.d.ts

@@ -1,7 +1,7 @@
-import { Animated } from 'react-native';
-import type { FocusedInputLayoutChangedEvent, KeyboardHandlers } from './types';
-import type React from 'react';
-import type { SharedValue } from 'react-native-reanimated';
+import { Animated } from "react-native";
+import type { FocusedInputHandlers, FocusedInputLayoutChangedEvent, KeyboardHandlers } from "./types";
+import type React from "react";
+import type { SharedValue } from "react-native-reanimated";
 export type AnimatedContext = {
     progress: Animated.Value;
     height: Animated.AnimatedMultiplication<number>;
@@ -15,7 +15,8 @@ export type KeyboardAnimationContext = {
     animated: AnimatedContext;
     reanimated: ReanimatedContext;
     layout: SharedValue<FocusedInputLayoutChangedEvent | null>;
-    setHandlers: (handlers: KeyboardHandlers) => void;
+    setKeyboardHandlers: (handlers: KeyboardHandlers) => void;
+    setInputHandlers: (handlers: FocusedInputHandlers) => void;
     setEnabled: React.Dispatch<React.SetStateAction<boolean>>;
 };
 export declare const KeyboardContext: React.Context<KeyboardAnimationContext>;

package/lib/typescript/hooks.d.ts

@@ -1,6 +1,6 @@
-import type { AnimatedContext, ReanimatedContext } from './context';
-import type { KeyboardHandler } from './types';
-import type { DependencyList } from 'react';
+import type { AnimatedContext, ReanimatedContext } from "./context";
+import type { FocusedInputHandler, KeyboardHandler } from "./types";
+import type { DependencyList } from "react";
 export declare const useResizeMode: () => void;
 export declare const useKeyboardAnimation: () => AnimatedContext;
 export declare const useReanimatedKeyboardAnimation: () => ReanimatedContext;
@@ -13,3 +13,4 @@ export declare function useKeyboardController(): {
 export declare function useReanimatedFocusedInput(): {
     input: import("react-native-reanimated").SharedValue<import("./types").FocusedInputLayoutChangedEvent | null>;
 };
+export declare function useFocusedInputHandler(handler?: FocusedInputHandler, deps?: DependencyList): void;

package/lib/typescript/index.d.ts

@@ -1,8 +1,8 @@
-export * from './bindings';
-export * from './animated';
-export * from './replicas';
-export * from './context';
-export * from './hooks';
-export * from './constants';
-export * from './types';
-export { KeyboardAvoidingView, KeyboardStickyView } from './components';
+export * from "./bindings";
+export * from "./animated";
+export * from "./replicas";
+export * from "./context";
+export * from "./hooks";
+export * from "./constants";
+export * from "./types";
+export { KeyboardAvoidingView, KeyboardStickyView, KeyboardAwareScrollView, } from "./components";

package/lib/typescript/internal.d.ts

@@ -1,5 +1,10 @@
-import { Animated } from 'react-native';
-import type { Handlers, NativeEvent } from './types';
+import { Animated } from "react-native";
+import type { Handlers } from "./types";
+type UntypedHandler = Record<string, (event: never) => void>;
+type SharedHandlersReturnType<T extends UntypedHandler> = [
+    (handler: Handlers<T>) => void,
+    <K extends keyof T>(type: K, event: Parameters<T[K]>[0]) => void
+];
 /**
  * Hook for storing worklet handlers (objects with keys, where values are worklets).
  * Returns methods for setting handlers and broadcasting events in them.
@@ -11,10 +16,7 @@ import type { Handlers, NativeEvent } from './types';
  *  onEvent2: () => {},
  * }
  */
-export declare function useSharedHandlers<T extends Record<string, (event: NativeEvent) => void>>(): {
-    setHandlers: (handler: Handlers<T>) => void;
-    broadcast: (type: keyof T, event: NativeEvent) => void;
-};
+export declare function useSharedHandlers<T extends UntypedHandler>(): SharedHandlersReturnType<T>;
 /**
  * TS variant of `useAnimatedValue` hook which is added in RN 0.71
  * A better alternative of storing animated values in refs, since
@@ -25,3 +27,4 @@ export declare function useSharedHandlers<T extends Record<string, (event: Nativ
  * @see https://github.com/facebook/react-native/commit/e22217fe8b9455e32695f88ca835e11442b0a937
  */
 export declare function useAnimatedValue(initialValue: number, config?: Animated.AnimatedConfig): Animated.Value;
+export {};

package/lib/typescript/reanimated.d.ts

@@ -1,3 +1,4 @@
-import type { EventWithName, FocusedInputHandlerHook, FocusedInputLayoutChangedEvent, KeyboardHandlerHook, NativeEvent } from './types';
+import type { EventWithName, FocusedInputLayoutChangedEvent, FocusedInputLayoutHandlerHook, FocusedInputTextChangedEvent, FocusedInputTextHandlerHook, KeyboardHandlerHook, NativeEvent } from "./types";
 export declare const useAnimatedKeyboardHandler: KeyboardHandlerHook<Record<string, unknown>, EventWithName<NativeEvent>>;
-export declare const useFocusedInputHandler: FocusedInputHandlerHook<Record<string, unknown>, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputLayoutHandler: FocusedInputLayoutHandlerHook<Record<string, unknown>, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputTextHandler: FocusedInputTextHandlerHook<Record<string, unknown>, EventWithName<FocusedInputTextChangedEvent>>;

package/lib/typescript/reanimated.native.d.ts

@@ -1,3 +1,4 @@
-import type { EventWithName, FocusedInputHandlerHook, FocusedInputLayoutChangedEvent, KeyboardHandlerHook, NativeEvent } from './types';
+import type { EventWithName, FocusedInputLayoutChangedEvent, FocusedInputLayoutHandlerHook, FocusedInputTextChangedEvent, FocusedInputTextHandlerHook, KeyboardHandlerHook, NativeEvent } from "./types";
 export declare const useAnimatedKeyboardHandler: KeyboardHandlerHook<Record<string, unknown>, EventWithName<NativeEvent>>;
-export declare const useFocusedInputHandler: FocusedInputHandlerHook<Record<string, unknown>, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputLayoutHandler: FocusedInputLayoutHandlerHook<Record<string, unknown>, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputTextHandler: FocusedInputTextHandlerHook<Record<string, unknown>, EventWithName<FocusedInputTextChangedEvent>>;

package/lib/typescript/replicas.d.ts

@@ -1,4 +1,4 @@
-import { Animated } from 'react-native';
+import { Animated } from "react-native";
 export declare const defaultAndroidEasing: import("react-native").EasingFunction;
 type KeyboardAnimation = {
     progress: Animated.Value;

package/lib/typescript/specs/KeyboardControllerViewNativeComponent.d.ts

@@ -1,6 +1,6 @@
-import type { HostComponent } from 'react-native';
-import type { ViewProps } from 'react-native/Libraries/Components/View/ViewPropTypes';
-import type { DirectEventHandler, Double, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import type { HostComponent } from "react-native";
+import type { ViewProps } from "react-native/Libraries/Components/View/ViewPropTypes";
+import type { DirectEventHandler, Double, Int32 } from "react-native/Libraries/Types/CodegenTypes";
 type KeyboardMoveEvent = Readonly<{
     height: Double;
     progress: Double;
@@ -18,6 +18,9 @@ type FocusedInputLayoutChangedEvent = Readonly<{
         absoluteY: Double;
     };
 }>;
+type FocusedInputTextChangedEvent = Readonly<{
+    text: string;
+}>;
 export interface NativeProps extends ViewProps {
     enabled?: boolean;
     statusBarTranslucent?: boolean;
@@ -27,6 +30,7 @@ export interface NativeProps extends ViewProps {
     onKeyboardMoveEnd?: DirectEventHandler<KeyboardMoveEvent>;
     onKeyboardMoveInteractive?: DirectEventHandler<KeyboardMoveEvent>;
     onFocusedInputLayoutChanged?: DirectEventHandler<FocusedInputLayoutChangedEvent>;
+    onFocusedInputTextChanged?: DirectEventHandler<FocusedInputTextChangedEvent>;
 }
 declare const _default: HostComponent<NativeProps>;
 export default _default;

package/lib/typescript/specs/KeyboardGestureAreaNativeComponent.d.ts

@@ -1,8 +1,8 @@
-import type { HostComponent } from 'react-native';
-import type { ViewProps } from 'react-native/Libraries/Components/View/ViewPropTypes';
-import type { WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import type { HostComponent } from "react-native";
+import type { ViewProps } from "react-native/Libraries/Components/View/ViewPropTypes";
+import type { WithDefault } from "react-native/Libraries/Types/CodegenTypes";
 export interface NativeProps extends ViewProps {
-    interpolator?: WithDefault<'linear' | 'ios', 'linear'>;
+    interpolator?: WithDefault<"linear" | "ios", "linear">;
     showOnSwipeUp?: boolean;
     enableSwipeToDismiss?: boolean;
 }

package/lib/typescript/specs/NativeKeyboardController.d.ts

@@ -1,8 +1,9 @@
-import type { TurboModule } from 'react-native';
+import type { TurboModule } from "react-native";
 export interface Spec extends TurboModule {
     readonly getConstants: () => {};
     setInputMode(mode: number): void;
     setDefaultMode(): void;
+    dismiss(): void;
     addListener: (eventName: string) => void;
     removeListeners: (count: number) => void;
 }

package/lib/typescript/specs/NativeStatusBarManagerCompat.d.ts

@@ -1,4 +1,4 @@
-import type { TurboModule } from 'react-native';
+import type { TurboModule } from "react-native";
 export interface Spec extends TurboModule {
     readonly getConstants: () => {};
     setHidden(hidden: boolean): void;

package/lib/typescript/types.d.ts

@@ -1,4 +1,4 @@
-import type { EmitterSubscription, NativeSyntheticEvent, ViewProps } from 'react-native';
+import type { EmitterSubscription, NativeSyntheticEvent, ViewProps } from "react-native";
 export type NativeEvent = {
     progress: number;
     height: number;
@@ -16,23 +16,28 @@ export type FocusedInputLayoutChangedEvent = {
         absoluteY: number;
     };
 };
+export type FocusedInputTextChangedEvent = {
+    text: string;
+};
 export type EventWithName<T> = {
     eventName: string;
 } & T;
 export type KeyboardControllerProps = {
-    enabled?: boolean;
     onKeyboardMoveStart?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
     onKeyboardMove?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
     onKeyboardMoveEnd?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
     onKeyboardMoveInteractive?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
     onFocusedInputLayoutChanged?: (e: NativeSyntheticEvent<EventWithName<FocusedInputLayoutChangedEvent>>) => void;
+    onFocusedInputTextChanged?: (e: NativeSyntheticEvent<EventWithName<FocusedInputTextChangedEvent>>) => void;
     onKeyboardMoveReanimated?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
     onFocusedInputLayoutChangedReanimated?: (e: NativeSyntheticEvent<EventWithName<FocusedInputLayoutChangedEvent>>) => void;
+    onFocusedInputTextChangedReanimated?: (e: NativeSyntheticEvent<EventWithName<FocusedInputTextChangedEvent>>) => void;
     statusBarTranslucent?: boolean;
     navigationBarTranslucent?: boolean;
+    enabled?: boolean;
 } & ViewProps;
 export type KeyboardGestureAreaProps = {
-    interpolator: 'ios' | 'linear';
+    interpolator: "ios" | "linear";
     /**
      * Whether to allow to show a keyboard from dismissed state by swipe up.
      * Default to `false`.
@@ -48,10 +53,11 @@ export type KeyboardGestureAreaProps = {
 export type KeyboardControllerModule = {
     setDefaultMode: () => void;
     setInputMode: (mode: number) => void;
+    dismiss: () => void;
     addListener: (eventName: string) => void;
     removeListeners: (count: number) => void;
 };
-export type KeyboardControllerEvents = 'keyboardWillShow' | 'keyboardDidShow' | 'keyboardWillHide' | 'keyboardDidHide';
+export type KeyboardControllerEvents = "keyboardWillShow" | "keyboardDidShow" | "keyboardWillHide" | "keyboardDidHide";
 export type KeyboardEventData = {
     height: number;
     duration: number;
@@ -67,9 +73,12 @@ export type KeyboardHandlerHook<TContext, Event> = (handlers: {
     onKeyboardMoveEnd?: (e: NativeEvent, context: TContext) => void;
     onKeyboardMoveInteractive?: (e: NativeEvent, context: TContext) => void;
 }, dependencies?: unknown[]) => (e: NativeSyntheticEvent<Event>) => void;
-export type FocusedInputHandlerHook<TContext, Event> = (handlers: {
+export type FocusedInputLayoutHandlerHook<TContext, Event> = (handlers: {
     onFocusedInputLayoutChanged?: (e: FocusedInputLayoutChangedEvent, context: TContext) => void;
 }, dependencies?: unknown[]) => (e: NativeSyntheticEvent<Event>) => void;
+export type FocusedInputTextHandlerHook<TContext, Event> = (handlers: {
+    onFocusedInputTextChanged?: (e: FocusedInputTextChangedEvent, context: TContext) => void;
+}, dependencies?: unknown[]) => (e: NativeSyntheticEvent<Event>) => void;
 export type Handlers<T> = Record<string, T | undefined>;
 export type KeyboardHandler = Partial<{
     onStart: (e: NativeEvent) => void;
@@ -78,3 +87,7 @@ export type KeyboardHandler = Partial<{
     onInteractive: (e: NativeEvent) => void;
 }>;
 export type KeyboardHandlers = Handlers<KeyboardHandler>;
+export type FocusedInputHandler = Partial<{
+    onChangeText: (e: FocusedInputTextChangedEvent) => void;
+}>;
+export type FocusedInputHandlers = Handlers<FocusedInputHandler>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-keyboard-controller",
-  "version": "1.9.5",
+  "version": "1.10.1",
   "description": "Keyboard manager which works in identical way on both iOS and Android",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -27,6 +27,7 @@
     "!**/__mocks__"
   ],
   "scripts": {
+    "format": "prettier '**/*' --ignore-unknown --write",
     "test": "jest",
     "typescript": "tsc --noEmit --project tsconfig.build.json",
     "lint": "eslint --quiet \"**/*.{js,ts,tsx}\"",
@@ -41,9 +42,12 @@
     "react-native",
     "keyboard",
     "animation",
+    "dismiss",
     "focused input",
+    "text changed",
     "avoiding view",
     "sticky view",
+    "keyboard aware scroll view",
     "ios",
     "android"
   ],
@@ -59,7 +63,7 @@
   },
   "devDependencies": {
     "@commitlint/config-conventional": "^11.0.0",
-    "@react-native/eslint-config": "^0.72.2",
+    "@react-native/eslint-config": "^0.74.0",
     "@release-it/conventional-changelog": "^2.0.0",
     "@types/jest": "^29.2.1",
     "@types/react": "^18.0.24",
@@ -68,19 +72,19 @@
     "clang-format": "^1.8.0",
     "commitlint": "^11.0.0",
     "eslint": "^8.19.0",
-    "eslint-config-prettier": "^7.0.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-jest": "^27.4.2",
-    "eslint-plugin-prettier": "^3.1.3",
+    "eslint-plugin-jest": "^26.5.3",
+    "eslint-plugin-prettier": "^4.2.1",
     "husky": "^6.0.0",
     "jest": "^29.2.1",
     "pod-install": "^0.1.0",
-    "prettier": "^2.4.1",
+    "prettier": "^2.8.8",
     "react": "18.2.0",
     "react-native": "0.72.4",
     "react-native-builder-bob": "^0.18.0",
-    "react-native-reanimated": "3.4.2",
+    "react-native-reanimated": "3.6.1",
     "release-it": "^14.2.2",
     "typescript": "^4.8.4"
   },
@@ -120,10 +124,7 @@
   },
   "prettier": {
     "quoteProps": "consistent",
-    "singleQuote": true,
-    "tabWidth": 2,
-    "trailingComma": "es5",
-    "useTabs": false
+    "trailingComma": "all"
   },
   "react-native-builder-bob": {
     "source": "src",

package/react-native-keyboard-controller.podspec

@@ -24,7 +24,7 @@ Pod::Spec.new do |s|
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
     s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
     s.pod_target_xcconfig    = {
-      "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+      "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"${PODS_ROOT}/Headers/Private/Yoga\"",
       "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
       "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
       # This is handy when we want to detect if new arch is enabled in Swift code

package/src/animated.tsx

@@ -1,29 +1,31 @@
-import React, { useEffect, useMemo, useState } from 'react';
-import { Animated, Platform, StyleSheet } from 'react-native';
-import Reanimated, { useSharedValue } from 'react-native-reanimated';
+import React, { useEffect, useMemo, useState } from "react";
+import { Animated, Platform, StyleSheet } from "react-native";
+import Reanimated, { useSharedValue } from "react-native-reanimated";
 
-import { KeyboardControllerView } from './bindings';
-import { KeyboardContext } from './context';
-import { useAnimatedValue, useSharedHandlers } from './internal';
-import { applyMonkeyPatch, revertMonkeyPatch } from './monkey-patch';
+import { KeyboardControllerView } from "./bindings";
+import { KeyboardContext } from "./context";
+import { useAnimatedValue, useSharedHandlers } from "./internal";
+import { applyMonkeyPatch, revertMonkeyPatch } from "./monkey-patch";
 import {
   useAnimatedKeyboardHandler,
-  useFocusedInputHandler,
-} from './reanimated';
+  useFocusedInputLayoutHandler,
+  useFocusedInputTextHandler,
+} from "./reanimated";
 
-import type { KeyboardAnimationContext } from './context';
+import type { KeyboardAnimationContext } from "./context";
 import type {
+  FocusedInputHandler,
   FocusedInputLayoutChangedEvent,
   KeyboardControllerProps,
   KeyboardHandler,
   NativeEvent,
-} from './types';
-import type { ViewStyle } from 'react-native';
+} from "./types";
+import type { ViewStyle } from "react-native";
 
 const KeyboardControllerViewAnimated = Reanimated.createAnimatedComponent(
   Animated.createAnimatedComponent(
-    KeyboardControllerView
-  ) as React.FC<KeyboardControllerProps>
+    KeyboardControllerView,
+  ) as React.FC<KeyboardControllerProps>,
 );
 
 type Styles = {
@@ -36,8 +38,8 @@ const styles = StyleSheet.create<Styles>({
     flex: 1,
   },
   hidden: {
-    display: 'none',
-    position: 'absolute',
+    display: "none",
+    position: "absolute",
   },
 });
 
@@ -76,6 +78,7 @@ export const KeyboardProvider = ({
   navigationBarTranslucent,
   enabled: initiallyEnabled = true,
 }: KeyboardProviderProps) => {
+  // state
   const [enabled, setEnabled] = useState(initiallyEnabled);
   // animated values
   const progress = useAnimatedValue(0);
@@ -84,7 +87,10 @@ export const KeyboardProvider = ({
   const progressSV = useSharedValue(0);
   const heightSV = useSharedValue(0);
   const layout = useSharedValue<FocusedInputLayoutChangedEvent | null>(null);
-  const { setHandlers, broadcast } = useSharedHandlers<KeyboardHandler>();
+  const [setKeyboardHandlers, broadcastKeyboardEvents] =
+    useSharedHandlers<KeyboardHandler>();
+  const [setInputHandlers, broadcastInputEvents] =
+    useSharedHandlers<FocusedInputHandler>();
   // memo
   const context = useMemo<KeyboardAnimationContext>(
     () => ({
@@ -92,17 +98,18 @@ export const KeyboardProvider = ({
       animated: { progress: progress, height: Animated.multiply(height, -1) },
       reanimated: { progress: progressSV, height: heightSV },
       layout,
-      setHandlers,
+      setKeyboardHandlers,
+      setInputHandlers,
       setEnabled,
     }),
-    [enabled]
+    [enabled],
   );
   const style = useMemo(
     () => [
       styles.hidden,
       { transform: [{ translateX: height }, { translateY: progress }] },
     ],
-    []
+    [],
   );
   const onKeyboardMove = useMemo(
     () =>
@@ -115,13 +122,13 @@ export const KeyboardProvider = ({
             },
           },
         ],
-        { useNativeDriver: true }
+        { useNativeDriver: true },
       ),
-    []
+    [],
   );
   // handlers
   const updateSharedValues = (event: NativeEvent, platforms: string[]) => {
-    'worklet';
+    "worklet";
 
     if (platforms.includes(Platform.OS)) {
       progressSV.value = event.progress;
@@ -131,35 +138,35 @@ export const KeyboardProvider = ({
   const keyboardHandler = useAnimatedKeyboardHandler(
     {
       onKeyboardMoveStart: (event: NativeEvent) => {
-        'worklet';
+        "worklet";
 
-        broadcast('onStart', event);
-        updateSharedValues(event, ['ios']);
+        broadcastKeyboardEvents("onStart", event);
+        updateSharedValues(event, ["ios"]);
       },
       onKeyboardMove: (event: NativeEvent) => {
-        'worklet';
+        "worklet";
 
-        broadcast('onMove', event);
-        updateSharedValues(event, ['android']);
+        broadcastKeyboardEvents("onMove", event);
+        updateSharedValues(event, ["android"]);
       },
       onKeyboardMoveEnd: (event: NativeEvent) => {
-        'worklet';
+        "worklet";
 
-        broadcast('onEnd', event);
+        broadcastKeyboardEvents("onEnd", event);
       },
       onKeyboardMoveInteractive: (event: NativeEvent) => {
-        'worklet';
+        "worklet";
 
-        updateSharedValues(event, ['android', 'ios']);
-        broadcast('onInteractive', event);
+        updateSharedValues(event, ["android", "ios"]);
+        broadcastKeyboardEvents("onInteractive", event);
       },
     },
-    []
+    [],
   );
-  const inputHandler = useFocusedInputHandler(
+  const inputLayoutHandler = useFocusedInputLayoutHandler(
     {
       onFocusedInputLayoutChanged: (e) => {
-        'worklet';
+        "worklet";
 
         if (e.target !== -1) {
           layout.value = e;
@@ -168,7 +175,17 @@ export const KeyboardProvider = ({
         }
       },
     },
-    []
+    [],
+  );
+  const inputTextHandler = useFocusedInputTextHandler(
+    {
+      onFocusedInputTextChanged: (e) => {
+        "worklet";
+
+        broadcastInputEvents("onChangeText", e);
+      },
+    },
+    [],
   );
   // effects
   useEffect(() => {
@@ -184,13 +201,13 @@ export const KeyboardProvider = ({
       <KeyboardControllerViewAnimated
         enabled={enabled}
         onKeyboardMoveReanimated={keyboardHandler}
-        onKeyboardMoveStart={Platform.OS === 'ios' ? onKeyboardMove : undefined}
-        onKeyboardMove={Platform.OS === 'android' ? onKeyboardMove : undefined}
+        onKeyboardMoveStart={Platform.OS === "ios" ? onKeyboardMove : undefined}
+        onKeyboardMove={Platform.OS === "android" ? onKeyboardMove : undefined}
         onKeyboardMoveInteractive={onKeyboardMove}
-        onFocusedInputLayoutChangedReanimated={inputHandler}
+        onFocusedInputLayoutChangedReanimated={inputLayoutHandler}
+        onFocusedInputTextChangedReanimated={inputTextHandler}
         navigationBarTranslucent={navigationBarTranslucent}
         statusBarTranslucent={statusBarTranslucent}
-        // @ts-expect-error https://github.com/software-mansion/react-native-reanimated/pull/4923
         style={styles.container}
       >
         {children}

package/src/bindings.native.ts

@@ -1,20 +1,20 @@
-import { NativeEventEmitter, Platform } from 'react-native';
+import { NativeEventEmitter, Platform } from "react-native";
 
 import type {
   KeyboardControllerModule,
   KeyboardControllerProps,
   KeyboardEventsModule,
   KeyboardGestureAreaProps,
-} from './types';
+} from "./types";
 
 const LINKING_ERROR =
   `The package 'react-native-keyboard-controller' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
+  Platform.select({ ios: "- You have run 'pod install'\n", default: "" }) +
+  "- You rebuilt the app after installing the package\n" +
+  "- You are not using Expo Go\n";
 
 const RCTKeyboardController =
-  require('./specs/NativeKeyboardController').default;
+  require("./specs/NativeKeyboardController").default;
 export const KeyboardController = (
   RCTKeyboardController
     ? RCTKeyboardController
@@ -24,7 +24,7 @@ export const KeyboardController = (
           get() {
             throw new Error(LINKING_ERROR);
           },
-        }
+        },
       )
 ) as KeyboardControllerModule;
 
@@ -32,11 +32,11 @@ const eventEmitter = new NativeEventEmitter(KeyboardController);
 
 export const KeyboardEvents: KeyboardEventsModule = {
   addListener: (name, cb) =>
-    eventEmitter.addListener('KeyboardController::' + name, cb),
+    eventEmitter.addListener("KeyboardController::" + name, cb),
 };
 export const KeyboardControllerView: React.FC<KeyboardControllerProps> =
-  require('./specs/KeyboardControllerViewNativeComponent').default;
+  require("./specs/KeyboardControllerViewNativeComponent").default;
 export const KeyboardGestureArea: React.FC<KeyboardGestureAreaProps> =
-  Platform.OS === 'android' && Platform.Version >= 30
-    ? require('./specs/KeyboardGestureAreaNativeComponent').default
+  Platform.OS === "android" && Platform.Version >= 30
+    ? require("./specs/KeyboardGestureAreaNativeComponent").default
     : ({ children }: KeyboardGestureAreaProps) => children;

package/src/bindings.ts

@@ -1,17 +1,18 @@
-import { View } from 'react-native';
+import { View } from "react-native";
 
 import type {
   KeyboardControllerModule,
   KeyboardControllerProps,
   KeyboardEventsModule,
   KeyboardGestureAreaProps,
-} from './types';
-import type { EmitterSubscription } from 'react-native';
+} from "./types";
+import type { EmitterSubscription } from "react-native";
 
 const NOOP = () => {};
 export const KeyboardController: KeyboardControllerModule = {
   setDefaultMode: NOOP,
   setInputMode: NOOP,
+  dismiss: NOOP,
   addListener: NOOP,
   removeListeners: NOOP,
 };