react-native-keyboard-controller 1.9.5 → 1.10.1

package/src/components/hooks/useKeyboardInterpolation.ts

@@ -0,0 +1,96 @@
+import {
+  interpolate as interpolateREA,
+  useSharedValue,
+} from "react-native-reanimated";
+
+import { useKeyboardHandler } from "../../hooks";
+
+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
+ */
+const useKeyboardInterpolation = () => {
+  // keyboard heights
+  const nextKeyboardHeight = useSharedValue(0);
+  const prevKeyboardHeight = useSharedValue(0);
+  // save latest interpolated position
+  const lastInterpolation = useSharedValue(0);
+  // boolean flag indicating which output range should be used
+  const shouldUseInternalInterpolation = useSharedValue(false);
+
+  const interpolate = (
+    keyboardPosition: number,
+    output: KeyboardInterpolationOutput,
+  ) => {
+    "worklet";
+
+    lastInterpolation.value = interpolateREA(
+      keyboardPosition,
+      [prevKeyboardHeight.value, nextKeyboardHeight.value],
+      shouldUseInternalInterpolation.value
+        ? [lastInterpolation.value, output[1]]
+        : output,
+    );
+
+    return lastInterpolation.value;
+  };
+
+  useKeyboardHandler(
+    {
+      onStart: (e) => {
+        "worklet";
+
+        const keyboardWillBeHidden = e.height === 0;
+
+        // keyboard will be hidden
+        if (keyboardWillBeHidden) {
+          shouldUseInternalInterpolation.value = false;
+          prevKeyboardHeight.value = 0;
+        }
+
+        // keyboard will change its size
+        if (
+          // keyboard is shown on screen
+          nextKeyboardHeight.value !== 0 &&
+          // it really changes size (handles iOS case when after interactive keyboard gets shown again)
+          nextKeyboardHeight.value !== e.height &&
+          // keyboard is not hiding
+          !keyboardWillBeHidden
+        ) {
+          prevKeyboardHeight.value = nextKeyboardHeight.value;
+          shouldUseInternalInterpolation.value = true;
+        }
+
+        // keyboard will show or change size
+        if (!keyboardWillBeHidden) {
+          nextKeyboardHeight.value = e.height;
+        }
+      },
+      onEnd: (e) => {
+        "worklet";
+
+        // handles case show -> resize -> hide -> show
+        // here we reset value to 0 when keyboard is hidden
+        nextKeyboardHeight.value = e.height;
+      },
+    },
+    [],
+  );
+
+  return { interpolate };
+};
+
+export default useKeyboardInterpolation;

package/src/components/index.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/src/context.ts

@@ -1,9 +1,13 @@
-import { createContext, useContext } from 'react';
-import { Animated } from 'react-native';
+import { createContext, useContext } from "react";
+import { Animated } from "react-native";
 
-import type { FocusedInputLayoutChangedEvent, KeyboardHandlers } from './types';
-import type React from 'react';
-import type { SharedValue } from 'react-native-reanimated';
+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;
@@ -18,7 +22,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>>;
 };
 const NOOP = () => {};
@@ -30,7 +35,7 @@ const withSharedValue = <T>(value: T): SharedValue<T> => ({
 });
 const DEFAULT_SHARED_VALUE = withSharedValue(0);
 const DEFAULT_LAYOUT = withSharedValue<FocusedInputLayoutChangedEvent | null>(
-  null
+  null,
 );
 const defaultContext: KeyboardAnimationContext = {
   enabled: true,
@@ -43,7 +48,8 @@ const defaultContext: KeyboardAnimationContext = {
     height: DEFAULT_SHARED_VALUE,
   },
   layout: DEFAULT_LAYOUT,
-  setHandlers: NOOP,
+  setKeyboardHandlers: NOOP,
+  setInputHandlers: NOOP,
   setEnabled: NOOP,
 };
 export const KeyboardContext = createContext(defaultContext);
@@ -52,7 +58,7 @@ export const useKeyboardContext = () => {
 
   if (__DEV__ && context === defaultContext) {
     console.warn(
-      "Couldn't find real values for `KeyboardContext`. Please make sure you're inside of `KeyboardProvider` - otherwise functionality of `react-native-keyboard-controller` will not work."
+      "Couldn't find real values for `KeyboardContext`. Please make sure you're inside of `KeyboardProvider` - otherwise functionality of `react-native-keyboard-controller` will not work.",
     );
   }
 

package/src/hooks.ts

@@ -1,18 +1,18 @@
-import { useEffect } from 'react';
+import { useEffect } from "react";
 
-import { KeyboardController } from './bindings';
-import { AndroidSoftInputModes } from './constants';
-import { useKeyboardContext } from './context';
-import { uuid } from './utils';
+import { KeyboardController } from "./bindings";
+import { AndroidSoftInputModes } from "./constants";
+import { useKeyboardContext } from "./context";
+import { uuid } from "./utils";
 
-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 const useResizeMode = () => {
   useEffect(() => {
     KeyboardController.setInputMode(
-      AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE
+      AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE,
     );
 
     return () => KeyboardController.setDefaultMode();
@@ -35,24 +35,24 @@ export const useReanimatedKeyboardAnimation = (): ReanimatedContext => {
 
 export function useGenericKeyboardHandler(
   handler: KeyboardHandler,
-  deps?: DependencyList
+  deps?: DependencyList,
 ) {
   const context = useKeyboardContext();
 
   useEffect(() => {
     const key = uuid();
 
-    context.setHandlers({ [key]: handler });
+    context.setKeyboardHandlers({ [key]: handler });
 
     return () => {
-      context.setHandlers({ [key]: undefined });
+      context.setKeyboardHandlers({ [key]: undefined });
     };
   }, deps);
 }
 
 export function useKeyboardHandler(
   handler: KeyboardHandler,
-  deps?: DependencyList
+  deps?: DependencyList,
 ) {
   useResizeMode();
   useGenericKeyboardHandler(handler, deps);
@@ -69,3 +69,20 @@ export function useReanimatedFocusedInput() {
 
   return { input: context.layout };
 }
+
+export function useFocusedInputHandler(
+  handler?: FocusedInputHandler,
+  deps?: DependencyList,
+) {
+  const context = useKeyboardContext();
+
+  useEffect(() => {
+    const key = uuid();
+
+    context.setInputHandlers({ [key]: handler });
+
+    return () => {
+      context.setInputHandlers({ [key]: undefined });
+    };
+  }, deps);
+}

package/src/index.ts

@@ -1,9 +1,13 @@
-export * from './bindings';
-export * from './animated';
-export * from './replicas';
-export * from './context';
-export * from './hooks';
-export * from './constants';
-export * from './types';
+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 {
+  KeyboardAvoidingView,
+  KeyboardStickyView,
+  KeyboardAwareScrollView,
+} from "./components";

package/src/internal.ts

@@ -1,8 +1,14 @@
-import { useCallback, useRef } from 'react';
-import { Animated } from 'react-native';
-import { useSharedValue } from 'react-native-reanimated';
+import { useCallback, useRef } from "react";
+import { Animated } from "react-native";
+import { useSharedValue } from "react-native-reanimated";
 
-import type { Handlers, NativeEvent } from './types';
+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).
@@ -16,8 +22,8 @@ import type { Handlers, NativeEvent } from './types';
  * }
  */
 export function useSharedHandlers<
-  T extends Record<string, (event: NativeEvent) => void>
->() {
+  T extends UntypedHandler,
+>(): SharedHandlersReturnType<T> {
   const handlers = useSharedValue<Handlers<T>>({});
   const jsHandlers = useRef<Handlers<T>>({});
 
@@ -40,15 +46,18 @@ export function useSharedHandlers<
     };
     updateSharedHandlers();
   }, []);
-  const broadcast = (type: keyof T, event: NativeEvent) => {
-    'worklet';
+  const broadcast = <K extends keyof T>(
+    type: K,
+    event: Parameters<T[K]>[0],
+  ) => {
+    "worklet";
 
-    Object.keys(handlers.value).forEach((key) =>
-      handlers.value[key]?.[type]?.(event)
-    );
+    Object.keys(handlers.value).forEach((key) => {
+      handlers.value[key]?.[type]?.(event);
+    });
   };
 
-  return { setHandlers, broadcast };
+  return [setHandlers, broadcast];
 }
 
 /**
@@ -62,7 +71,7 @@ export function useSharedHandlers<
  */
 export function useAnimatedValue(
   initialValue: number,
-  config?: Animated.AnimatedConfig
+  config?: Animated.AnimatedConfig,
 ): Animated.Value {
   const ref = useRef<Animated.Value | null>(null);
 

package/src/monkey-patch.android.ts

@@ -1,10 +1,10 @@
 // @ts-expect-error because there is no corresponding type definition
-import * as NativeAndroidManager from 'react-native/Libraries/Components/StatusBar/NativeStatusBarManagerAndroid';
+import * as NativeAndroidManager from "react-native/Libraries/Components/StatusBar/NativeStatusBarManagerAndroid";
 
 const DefaultNativeAndroidManager = NativeAndroidManager.default;
 const getConstants = NativeAndroidManager.default.getConstants;
 const RCTStatusBarManagerCompat =
-  require('./specs/NativeStatusBarManagerCompat').default;
+  require("./specs/NativeStatusBarManagerCompat").default;
 
 // On Android < 11 RN uses legacy API which breaks EdgeToEdge mode in RN, so
 // in order to use library on all available platforms we have to monkey patch

package/src/reanimated.native.ts

@@ -1,12 +1,14 @@
-import { useEvent, useHandler } from 'react-native-reanimated';
+import { useEvent, useHandler } from "react-native-reanimated";
 
 import type {
   EventWithName,
-  FocusedInputHandlerHook,
   FocusedInputLayoutChangedEvent,
+  FocusedInputLayoutHandlerHook,
+  FocusedInputTextChangedEvent,
+  FocusedInputTextHandlerHook,
   KeyboardHandlerHook,
   NativeEvent,
-} from './types';
+} from "./types";
 
 export const useAnimatedKeyboardHandler: KeyboardHandlerHook<
   Record<string, unknown>,
@@ -16,7 +18,7 @@ export const useAnimatedKeyboardHandler: KeyboardHandlerHook<
 
   return useEvent(
     (event) => {
-      'worklet';
+      "worklet";
       const {
         onKeyboardMoveStart,
         onKeyboardMove,
@@ -26,37 +28,37 @@ export const useAnimatedKeyboardHandler: KeyboardHandlerHook<
 
       if (
         onKeyboardMoveStart &&
-        event.eventName.endsWith('onKeyboardMoveStart')
+        event.eventName.endsWith("onKeyboardMoveStart")
       ) {
         onKeyboardMoveStart(event, context);
       }
 
-      if (onKeyboardMove && event.eventName.endsWith('onKeyboardMove')) {
+      if (onKeyboardMove && event.eventName.endsWith("onKeyboardMove")) {
         onKeyboardMove(event, context);
       }
 
-      if (onKeyboardMoveEnd && event.eventName.endsWith('onKeyboardMoveEnd')) {
+      if (onKeyboardMoveEnd && event.eventName.endsWith("onKeyboardMoveEnd")) {
         onKeyboardMoveEnd(event, context);
       }
 
       if (
         onKeyboardMoveInteractive &&
-        event.eventName.endsWith('onKeyboardMoveInteractive')
+        event.eventName.endsWith("onKeyboardMoveInteractive")
       ) {
         onKeyboardMoveInteractive(event, context);
       }
     },
     [
-      'onKeyboardMoveStart',
-      'onKeyboardMove',
-      'onKeyboardMoveEnd',
-      'onKeyboardMoveInteractive',
+      "onKeyboardMoveStart",
+      "onKeyboardMove",
+      "onKeyboardMoveEnd",
+      "onKeyboardMoveInteractive",
     ],
-    doDependenciesDiffer
+    doDependenciesDiffer,
   );
 };
 
-export const useFocusedInputHandler: FocusedInputHandlerHook<
+export const useFocusedInputLayoutHandler: FocusedInputLayoutHandlerHook<
   Record<string, unknown>,
   EventWithName<FocusedInputLayoutChangedEvent>
 > = (handlers, dependencies) => {
@@ -64,17 +66,40 @@ export const useFocusedInputHandler: FocusedInputHandlerHook<
 
   return useEvent(
     (event) => {
-      'worklet';
+      "worklet";
       const { onFocusedInputLayoutChanged } = handlers;
 
       if (
         onFocusedInputLayoutChanged &&
-        event.eventName.endsWith('onFocusedInputLayoutChanged')
+        event.eventName.endsWith("onFocusedInputLayoutChanged")
       ) {
         onFocusedInputLayoutChanged(event, context);
       }
     },
-    ['onFocusedInputLayoutChanged'],
-    doDependenciesDiffer
+    ["onFocusedInputLayoutChanged"],
+    doDependenciesDiffer,
+  );
+};
+
+export const useFocusedInputTextHandler: FocusedInputTextHandlerHook<
+  Record<string, unknown>,
+  EventWithName<FocusedInputTextChangedEvent>
+> = (handlers, dependencies) => {
+  const { context, doDependenciesDiffer } = useHandler(handlers, dependencies);
+
+  return useEvent(
+    (event) => {
+      "worklet";
+      const { onFocusedInputTextChanged } = handlers;
+
+      if (
+        onFocusedInputTextChanged &&
+        event.eventName.endsWith("onFocusedInputTextChanged")
+      ) {
+        onFocusedInputTextChanged(event, context);
+      }
+    },
+    ["onFocusedInputTextChanged"],
+    doDependenciesDiffer,
   );
 };

package/src/reanimated.ts

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

package/src/replicas.ts

@@ -1,19 +1,18 @@
-import { useEffect, useMemo, useRef } from 'react';
-import { Animated, Easing, Keyboard, Platform } from 'react-native';
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { Animated, Easing, Keyboard, Platform } from "react-native";
 import {
   runOnUI,
   useAnimatedReaction,
   useDerivedValue,
   useSharedValue,
-  useWorkletCallback,
   withSpring,
-} from 'react-native-reanimated';
+} from "react-native-reanimated";
 
-import { KeyboardController } from './bindings';
-import { AndroidSoftInputModes } from './constants';
-import { useReanimatedKeyboardAnimation } from './hooks';
+import { KeyboardController } from "./bindings";
+import { AndroidSoftInputModes } from "./constants";
+import { useReanimatedKeyboardAnimation } from "./hooks";
 
-const availableOSEventType = Platform.OS === 'ios' ? 'Will' : 'Did';
+const availableOSEventType = Platform.OS === "ios" ? "Will" : "Did";
 
 // cubic-bezier(.17,.67,.34,.94)
 export const defaultAndroidEasing = Easing.bezier(0.4, 0.0, 0.2, 1);
@@ -38,12 +37,12 @@ export const useKeyboardAnimationReplica = (): KeyboardAnimation => {
       height: height.current,
       progress: progress.current,
     }),
-    []
+    [],
   );
 
   useEffect(() => {
     KeyboardController.setInputMode(
-      AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE
+      AndroidSoftInputModes.SOFT_INPUT_ADJUST_RESIZE,
     );
 
     return () => KeyboardController.setDefaultMode();
@@ -60,7 +59,7 @@ export const useKeyboardAnimationReplica = (): KeyboardAnimation => {
         }).start();
 
         return () => listener.remove();
-      }
+      },
     );
   }, []);
   useEffect(() => {
@@ -75,7 +74,7 @@ export const useKeyboardAnimationReplica = (): KeyboardAnimation => {
         }).start();
 
         return () => listener.remove();
-      }
+      },
     );
   }, []);
 
@@ -111,7 +110,9 @@ export const useReanimatedKeyboardAnimationReplica = () => {
 
   const progress = useDerivedValue(() => height.value / heightEvent.value);
 
-  const handler = useWorkletCallback((_height: number) => {
+  const handler = useCallback((_height: number) => {
+    "worklet";
+
     heightEvent.value = _height;
   }, []);
 
@@ -127,14 +128,14 @@ export const useReanimatedKeyboardAnimationReplica = () => {
         height.value = withSpring(_keyboardHeight, IOS_SPRING_CONFIG);
       }
     },
-    []
+    [],
   );
 
   useEffect(() => {
-    const show = Keyboard.addListener('keyboardWillShow', (e) => {
+    const show = Keyboard.addListener("keyboardWillShow", (e) => {
       runOnUI(handler)(-e.endCoordinates.height);
     });
-    const hide = Keyboard.addListener('keyboardWillHide', () => {
+    const hide = Keyboard.addListener("keyboardWillHide", () => {
       runOnUI(handler)(0);
     });
 
@@ -148,6 +149,6 @@ export const useReanimatedKeyboardAnimationReplica = () => {
 };
 
 export const useGradualKeyboardAnimation =
-  Platform.OS === 'ios'
+  Platform.OS === "ios"
     ? useReanimatedKeyboardAnimationReplica
     : useReanimatedKeyboardAnimation;

package/src/specs/KeyboardControllerViewNativeComponent.ts

@@ -1,12 +1,12 @@
-import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
 
-import type { HostComponent } from 'react-native';
-import type { ViewProps } from 'react-native/Libraries/Components/View/ViewPropTypes';
+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';
+} from "react-native/Libraries/Types/CodegenTypes";
 
 type KeyboardMoveEvent = Readonly<{
   height: Double;
@@ -27,19 +27,26 @@ type FocusedInputLayoutChangedEvent = Readonly<{
   };
 }>;
 
+type FocusedInputTextChangedEvent = Readonly<{
+  text: string;
+}>;
+
 export interface NativeProps extends ViewProps {
   // props
   enabled?: boolean;
   statusBarTranslucent?: boolean;
   navigationBarTranslucent?: boolean;
   // callbacks
+  /// keyboard
   onKeyboardMoveStart?: DirectEventHandler<KeyboardMoveEvent>;
   onKeyboardMove?: DirectEventHandler<KeyboardMoveEvent>;
   onKeyboardMoveEnd?: DirectEventHandler<KeyboardMoveEvent>;
   onKeyboardMoveInteractive?: DirectEventHandler<KeyboardMoveEvent>;
+  /// focused input
   onFocusedInputLayoutChanged?: DirectEventHandler<FocusedInputLayoutChangedEvent>;
+  onFocusedInputTextChanged?: DirectEventHandler<FocusedInputTextChangedEvent>;
 }
 
 export default codegenNativeComponent<NativeProps>(
-  'KeyboardControllerView'
+  "KeyboardControllerView",
 ) as HostComponent<NativeProps>;

package/src/specs/KeyboardGestureAreaNativeComponent.ts

@@ -1,15 +1,15 @@
-import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
 
-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;
 }
 
-export default codegenNativeComponent<NativeProps>('KeyboardGestureArea', {
-  excludedPlatforms: ['iOS'],
+export default codegenNativeComponent<NativeProps>("KeyboardGestureArea", {
+  excludedPlatforms: ["iOS"],
 }) as HostComponent<NativeProps>;

package/src/specs/NativeKeyboardController.ts

@@ -1,6 +1,6 @@
-import { TurboModuleRegistry } from 'react-native';
+import { TurboModuleRegistry } from "react-native";
 
-import type { TurboModule } from 'react-native';
+import type { TurboModule } from "react-native";
 
 export interface Spec extends TurboModule {
   readonly getConstants: () => {};
@@ -8,10 +8,11 @@ export interface Spec extends TurboModule {
   // methods
   setInputMode(mode: number): void;
   setDefaultMode(): void;
+  dismiss(): void;
 
   // event emitter
   addListener: (eventName: string) => void;
   removeListeners: (count: number) => void;
 }
 
-export default TurboModuleRegistry.get<Spec>('KeyboardController');
+export default TurboModuleRegistry.get<Spec>("KeyboardController");