react-native-keyboard-controller 1.19.6 → 1.20.0

package/src/animated.tsx

@@ -1,5 +1,11 @@
 /* eslint react/jsx-sort-props: off */
-import React, { useEffect, useMemo, useRef, useState } from "react";
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { Animated, Platform, StyleSheet } from "react-native";
 import {
   controlEdgeToEdgeValues,
@@ -7,9 +13,12 @@ import {
 } from "react-native-is-edge-to-edge";
 import Reanimated, { useSharedValue } from "react-native-reanimated";
 
-import { KeyboardControllerView } from "./bindings";
+import {
+  FocusedInputEvents,
+  KeyboardControllerView,
+  KeyboardControllerViewCommands,
+} from "./bindings";
 import { KeyboardContext } from "./context";
-import { focusedInputEventsMap, keyboardEventsMap } from "./event-mappings";
 import { useAnimatedValue, useEventHandlerRegistration } from "./internal";
 import { KeyboardController } from "./module";
 import {
@@ -19,10 +28,8 @@ import {
 
 import type { KeyboardAnimationContext } from "./context";
 import type {
-  FocusedInputHandler,
   FocusedInputLayoutChangedEvent,
   KeyboardControllerProps,
-  KeyboardHandler,
   NativeEvent,
 } from "./types";
 import type { ViewStyle } from "react-native";
@@ -120,7 +127,7 @@ export const KeyboardProvider = (props: KeyboardProviderProps) => {
     preload = true,
   } = props;
   // ref
-  const viewTagRef = useRef<React.Component<KeyboardControllerProps>>(null);
+  const viewRef = useRef<React.Component<KeyboardControllerProps>>(null);
   // state
   const [enabled, setEnabled] = useState(initiallyEnabled);
   // animated values
@@ -130,14 +137,23 @@ export const KeyboardProvider = (props: KeyboardProviderProps) => {
   const progressSV = useSharedValue(0);
   const heightSV = useSharedValue(0);
   const layout = useSharedValue<FocusedInputLayoutChangedEvent | null>(null);
-  const setKeyboardHandlers = useEventHandlerRegistration<KeyboardHandler>(
-    keyboardEventsMap,
-    viewTagRef,
-  );
-  const setInputHandlers = useEventHandlerRegistration<FocusedInputHandler>(
-    focusedInputEventsMap,
-    viewTagRef,
-  );
+  const setKeyboardHandlers = useEventHandlerRegistration(viewRef);
+  const setInputHandlers = useEventHandlerRegistration(viewRef);
+  const update = useCallback(async () => {
+    KeyboardControllerViewCommands.synchronizeFocusedInputLayout(
+      viewRef.current,
+    );
+
+    await new Promise((resolve) => {
+      const subscription = FocusedInputEvents.addListener(
+        "layoutDidSynchronize",
+        () => {
+          subscription.remove();
+          resolve(null);
+        },
+      );
+    });
+  }, []);
   // memo
   const context = useMemo<KeyboardAnimationContext>(
     () => ({
@@ -145,6 +161,7 @@ export const KeyboardProvider = (props: KeyboardProviderProps) => {
       animated: { progress: progress, height: Animated.multiply(height, -1) },
       reanimated: { progress: progressSV, height: heightSV },
       layout,
+      update,
       setKeyboardHandlers,
       setInputHandlers,
       setEnabled,
@@ -241,7 +258,7 @@ export const KeyboardProvider = (props: KeyboardProviderProps) => {
   return (
     <KeyboardContext.Provider value={context}>
       <KeyboardControllerViewAnimated
-        ref={viewTagRef}
+        ref={viewRef}
         enabled={enabled}
         navigationBarTranslucent={IS_EDGE_TO_EDGE || navigationBarTranslucent}
         statusBarTranslucent={IS_EDGE_TO_EDGE || statusBarTranslucent}

package/src/bindings.native.ts

@@ -18,6 +18,7 @@ const LINKING_ERROR =
   "- You rebuilt the app after installing the package\n" +
   "- You are not using Expo Go\n";
 
+const KeyboardControllerViewNativeComponentModule = require("./specs/KeyboardControllerViewNativeComponent");
 const RCTKeyboardController =
   require("./specs/NativeKeyboardController").default;
 
@@ -55,7 +56,9 @@ export const WindowDimensionsEvents: WindowDimensionsEventsModule = {
     eventEmitter.addListener(KEYBOARD_CONTROLLER_NAMESPACE + name, cb),
 };
 export const KeyboardControllerView: React.FC<KeyboardControllerProps> =
-  require("./specs/KeyboardControllerViewNativeComponent").default;
+  KeyboardControllerViewNativeComponentModule.default;
+export const KeyboardControllerViewCommands =
+  KeyboardControllerViewNativeComponentModule.Commands;
 export const KeyboardGestureArea: React.FC<KeyboardGestureAreaProps> =
   (Platform.OS === "android" && Platform.Version >= 30) || Platform.OS === "ios"
     ? require("./specs/KeyboardGestureAreaNativeComponent").default

package/src/bindings.ts

@@ -53,6 +53,11 @@ export const WindowDimensionsEvents: WindowDimensionsEventsModule = {
  */
 export const KeyboardControllerView =
   View as unknown as React.FC<KeyboardControllerProps>;
+export const KeyboardControllerViewCommands = {
+  synchronizeFocusedInputLayout: (
+    _ref: React.Component<KeyboardControllerProps> | null,
+  ) => {},
+};
 /**
  * A view that defines a region on the screen, where gestures will control the keyboard position.
  *

package/src/compat.ts

@@ -0,0 +1,61 @@
+import { useSharedValue } from "react-native-reanimated";
+
+import { useKeyboardHandler } from "./hooks";
+
+export const KeyboardState = {
+  UNKNOWN: 0,
+  OPENING: 1,
+  OPEN: 2,
+  CLOSING: 3,
+  CLOSED: 4,
+};
+
+/**
+ * A compatibility layer for migration from https://docs.swmansion.com/react-native-reanimated/docs/device/useAnimatedKeyboard.
+ *
+ * @returns An object containing `height` and `state` properties represented as `SharedValue<number>`.
+ * @example
+ * ```ts
+ * import { useAnimatedKeyboard, useAnimatedStyle } from 'react-native-keyboard-controller';
+ *
+ * export default function App() {
+ *   const keyboard = useAnimatedKeyboard();
+ *
+ *   const animatedStyles = useAnimatedStyle(() => ({
+ *     transform: [{ translateY: -keyboard.height.value }],
+ *   }));
+ * }
+ */
+export const useAnimatedKeyboard = () => {
+  const height = useSharedValue(0);
+  const state = useSharedValue(KeyboardState.UNKNOWN);
+
+  useKeyboardHandler(
+    {
+      onStart: (e) => {
+        "worklet";
+
+        state.set(e.height > 0 ? KeyboardState.OPENING : KeyboardState.CLOSING);
+      },
+      onMove: (e) => {
+        "worklet";
+
+        height.set(e.height);
+      },
+      onInteractive: (e) => {
+        "worklet";
+
+        height.set(e.height);
+      },
+      onEnd: (e) => {
+        "worklet";
+
+        state.set(e.height > 0 ? KeyboardState.OPEN : KeyboardState.CLOSED);
+        height.set(e.height);
+      },
+    },
+    [],
+  );
+
+  return { height, state };
+};

package/src/components/KeyboardAwareScrollView/index.tsx

@@ -1,4 +1,10 @@
-import React, { forwardRef, useCallback, useEffect, useMemo } from "react";
+import React, {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+} from "react";
 import Reanimated, {
   clamp,
   interpolate,
@@ -44,6 +50,9 @@ export type KeyboardAwareScrollViewProps = {
   /** Custom component for `ScrollView`. Default is `ScrollView`. */
   ScrollViewComponent?: React.ComponentType<ScrollViewProps>;
 } & ScrollViewProps;
+export type KeyboardAwareScrollViewRef = {
+  assureFocusedInputVisible: () => void;
+} & ScrollView;
 
 // Everything begins from `onStart` handler. This handler is called every time,
 // when keyboard changes its size or when focused `TextInput` was changed. In
@@ -99,7 +108,7 @@ export type KeyboardAwareScrollViewProps = {
  * ```
  */
 const KeyboardAwareScrollView = forwardRef<
-  ScrollView,
+  KeyboardAwareScrollViewRef,
   React.PropsWithChildren<KeyboardAwareScrollViewProps>
 >(
   (
@@ -117,6 +126,7 @@ const KeyboardAwareScrollView = forwardRef<
     ref,
   ) => {
     const scrollViewAnimatedRef = useAnimatedRef<Reanimated.ScrollView>();
+    const scrollViewRef = React.useRef<ScrollView>(null);
     const scrollViewTarget = useSharedValue<number | null>(null);
     const scrollPosition = useSharedValue(0);
     const position = useScrollViewOffset(scrollViewAnimatedRef);
@@ -126,7 +136,7 @@ const KeyboardAwareScrollView = forwardRef<
     const tag = useSharedValue(-1);
     const initialKeyboardSize = useSharedValue(0);
     const scrollBeforeKeyboardMovement = useSharedValue(0);
-    const { input } = useReanimatedFocusedInput();
+    const { input, update } = useReanimatedFocusedInput();
     const layout = useSharedValue<FocusedInputLayoutChangedEvent | null>(null);
     const lastSelection =
       useSharedValue<FocusedInputSelectionChangedEvent | null>(null);
@@ -134,11 +144,7 @@ const KeyboardAwareScrollView = forwardRef<
     const { height } = useWindowDimensions();
 
     const onRef = useCallback((assignedRef: Reanimated.ScrollView) => {
-      if (typeof ref === "function") {
-        ref(assignedRef);
-      } else if (ref) {
-        ref.current = assignedRef;
-      }
+      scrollViewRef.current = assignedRef;
 
       scrollViewAnimatedRef(assignedRef);
     }, []);
@@ -392,10 +398,36 @@ const KeyboardAwareScrollView = forwardRef<
       [maybeScroll, disableScrollOnKeyboardHide, syncKeyboardFrame],
     );
 
+    const synchronize = useCallback(async () => {
+      await update();
+
+      runOnUI(() => {
+        "worklet";
+
+        scrollFromCurrentPosition();
+      })();
+    }, [update, scrollFromCurrentPosition]);
+
+    useImperativeHandle(
+      ref,
+      () => {
+        const scrollView = scrollViewRef.current;
+
+        const existingMethods = scrollView ? { ...scrollView } : {};
+
+        return {
+          ...existingMethods,
+
+          assureFocusedInputVisible: () => {
+            synchronize();
+          },
+        } as KeyboardAwareScrollViewRef;
+      },
+      [synchronize],
+    );
+
     useEffect(() => {
-      runOnUI(performScrollWithPositionRestoration)(
-        scrollBeforeKeyboardMovement.value,
-      );
+      synchronize();
     }, [bottomOffset]);
 
     useAnimatedReaction(

package/src/components/index.ts

@@ -7,5 +7,8 @@ export {
 } from "./KeyboardToolbar";
 export type { KeyboardAvoidingViewProps } from "./KeyboardAvoidingView";
 export type { KeyboardStickyViewProps } from "./KeyboardStickyView";
-export type { KeyboardAwareScrollViewProps } from "./KeyboardAwareScrollView";
+export type {
+  KeyboardAwareScrollViewProps,
+  KeyboardAwareScrollViewRef,
+} from "./KeyboardAwareScrollView";
 export type { KeyboardToolbarProps } from "./KeyboardToolbar";

package/src/context.ts

@@ -1,13 +1,12 @@
 import { createContext, useContext } from "react";
 import { Animated } from "react-native";
 
-import type {
-  FocusedInputHandler,
-  FocusedInputLayoutChangedEvent,
-  KeyboardHandler,
-} from "./types";
+import type { FocusedInputLayoutChangedEvent } from "./types";
 import type React from "react";
-import type { SharedValue } from "react-native-reanimated";
+import type {
+  EventHandlerProcessed,
+  SharedValue,
+} from "react-native-reanimated";
 
 export type AnimatedContext = {
   /**
@@ -36,10 +35,16 @@ export type KeyboardAnimationContext = {
   reanimated: ReanimatedContext;
   /** Layout of the focused `TextInput` represented as `SharedValue`. */
   layout: SharedValue<FocusedInputLayoutChangedEvent | null>;
+  /** Method for updating info about focused input layout. */
+  update: () => Promise<void>;
   /** Method for setting workletized keyboard handlers. */
-  setKeyboardHandlers: (handlers: KeyboardHandler) => () => void;
+  setKeyboardHandlers: (
+    handlers: EventHandlerProcessed<never, never>,
+  ) => () => void;
   /** Method for setting workletized handlers for tracking focused input events. */
-  setInputHandlers: (handlers: FocusedInputHandler) => () => void;
+  setInputHandlers: (
+    handlers: EventHandlerProcessed<never, never>,
+  ) => () => void;
   /** Method to enable/disable KeyboardController library. */
   setEnabled: React.Dispatch<React.SetStateAction<boolean>>;
 };
@@ -68,6 +73,7 @@ const defaultContext: KeyboardAnimationContext = {
     height: DEFAULT_SHARED_VALUE,
   },
   layout: DEFAULT_LAYOUT,
+  update: Promise.resolve,
   setKeyboardHandlers: NESTED_NOOP,
   setInputHandlers: NESTED_NOOP,
   setEnabled: NOOP,

package/src/hooks/index.ts

@@ -1,12 +1,18 @@
 import { useEffect, useLayoutEffect } from "react";
+import { useEvent, useHandler } from "react-native-reanimated";
 
 import { AndroidSoftInputModes } from "../constants";
 import { useKeyboardContext } from "../context";
 import { KeyboardController } from "../module";
 
 import type { AnimatedContext, ReanimatedContext } from "../context";
-import type { FocusedInputHandler, KeyboardHandler } from "../types";
-import type { DependencyList } from "react";
+import type {
+  FocusedInputHandler,
+  FocusedInputSelectionChangedEvent,
+  FocusedInputTextChangedEvent,
+  KeyboardHandler,
+  NativeEvent,
+} from "../types";
 
 /**
  * Hook that sets the Android soft input mode to adjust resize on mount and
@@ -107,12 +113,43 @@ export const useReanimatedKeyboardAnimation = (): ReanimatedContext => {
  */
 export function useGenericKeyboardHandler(
   handler: KeyboardHandler,
-  deps?: DependencyList,
+  deps?: unknown[],
 ) {
   const context = useKeyboardContext();
 
+  const { doDependenciesDiffer } = useHandler(handler, deps);
+
+  const eventHandler = useEvent<NativeEvent>(
+    (event) => {
+      "worklet";
+
+      if (event.eventName.endsWith("onKeyboardMoveStart")) {
+        handler.onStart?.(event);
+      }
+
+      if (event.eventName.endsWith("onKeyboardMove")) {
+        handler.onMove?.(event);
+      }
+
+      if (event.eventName.endsWith("onKeyboardMoveEnd")) {
+        handler.onEnd?.(event);
+      }
+
+      if (event.eventName.endsWith("onKeyboardMoveInteractive")) {
+        handler.onInteractive?.(event);
+      }
+    },
+    [
+      "onKeyboardMoveStart",
+      "onKeyboardMove",
+      "onKeyboardMoveEnd",
+      "onKeyboardMoveInteractive",
+    ],
+    doDependenciesDiffer,
+  );
+
   useLayoutEffect(() => {
-    const cleanup = context.setKeyboardHandlers(handler);
+    const cleanup = context.setKeyboardHandlers(eventHandler);
 
     return () => cleanup();
   }, deps);
@@ -149,10 +186,7 @@ export function useGenericKeyboardHandler(
  * }
  * ```
  */
-export function useKeyboardHandler(
-  handler: KeyboardHandler,
-  deps?: DependencyList,
-) {
+export function useKeyboardHandler(handler: KeyboardHandler, deps?: unknown[]) {
   useResizeMode();
   useGenericKeyboardHandler(handler, deps);
 }
@@ -202,7 +236,10 @@ export function useKeyboardController() {
 export function useReanimatedFocusedInput() {
   const context = useKeyboardContext();
 
-  return { input: context.layout };
+  return {
+    input: context.layout,
+    update: context.update,
+  };
 }
 
 /**
@@ -224,12 +261,32 @@ export function useReanimatedFocusedInput() {
  */
 export function useFocusedInputHandler(
   handler: FocusedInputHandler,
-  deps?: DependencyList,
+  deps?: unknown[],
 ) {
   const context = useKeyboardContext();
 
+  const { doDependenciesDiffer } = useHandler<never, never>(handler, deps);
+
+  const eventHandler = useEvent<
+    FocusedInputSelectionChangedEvent | FocusedInputTextChangedEvent
+  >(
+    (event) => {
+      "worklet";
+
+      if (event.eventName.endsWith("onFocusedInputTextChanged")) {
+        handler.onChangeText?.(event as FocusedInputTextChangedEvent);
+      }
+
+      if (event.eventName.endsWith("onFocusedInputSelectionChanged")) {
+        handler.onSelectionChange?.(event as FocusedInputSelectionChangedEvent);
+      }
+    },
+    ["onFocusedInputTextChanged", "onFocusedInputSelectionChanged"],
+    doDependenciesDiffer,
+  );
+
   useLayoutEffect(() => {
-    const cleanup = context.setInputHandlers(handler);
+    const cleanup = context.setInputHandlers(eventHandler);
 
     return () => cleanup();
   }, deps);

package/src/hooks/useKeyboardState/index.ts

@@ -3,7 +3,7 @@ import { useEffect, useState } from "react";
 import { KeyboardEvents } from "../../bindings";
 import { KeyboardController } from "../../module";
 
-import type { KeyboardState } from "../../types";
+import type { IKeyboardState } from "../../types";
 
 const EVENTS = ["keyboardDidShow", "keyboardDidHide"] as const;
 
@@ -12,9 +12,9 @@ const getLatestState = () => ({
   isVisible: KeyboardController.isVisible(),
 });
 
-type KeyboardStateSelector<T> = (state: KeyboardState) => T;
+type KeyboardStateSelector<T> = (state: IKeyboardState) => T;
 
-const defaultSelector: KeyboardStateSelector<KeyboardState> = (state) => state;
+const defaultSelector: KeyboardStateSelector<IKeyboardState> = (state) => state;
 
 /**
  * React Hook that represents the current keyboard state on iOS and Android.
@@ -40,7 +40,7 @@ const defaultSelector: KeyboardStateSelector<KeyboardState> = (state) => state;
  * }
  * ```
  */
-function useKeyboardState<T = KeyboardState>(
+function useKeyboardState<T = IKeyboardState>(
   selector: KeyboardStateSelector<T> = defaultSelector as KeyboardStateSelector<T>,
 ): T {
   const [state, setState] = useState<T>(() => selector(getLatestState()));

package/src/index.ts

@@ -5,6 +5,7 @@ export * from "./hooks";
 export * from "./constants";
 export * from "./module";
 export * from "./types";
+export * from "./compat";
 
 export {
   KeyboardAvoidingView,
@@ -18,6 +19,7 @@ export type {
   KeyboardAvoidingViewProps,
   KeyboardStickyViewProps,
   KeyboardAwareScrollViewProps,
+  KeyboardAwareScrollViewRef,
   KeyboardToolbarProps,
 } from "./components";
 export { OverKeyboardView, KeyboardExtender } from "./views";

package/src/internal.ts

@@ -1,16 +1,26 @@
 import { useRef } from "react";
 import { Animated } from "react-native";
 
-import { registerEventHandler, unregisterEventHandler } from "./event-handler";
 import { findNodeHandle } from "./utils/findNodeHandle";
 
-type EventHandler = (event: never) => void;
+import type { EventHandlerProcessed } from "react-native-reanimated";
+
 type ComponentOrHandle = Parameters<typeof findNodeHandle>[0];
 
+type WorkletHandler = {
+  registerForEvents: (viewTag: number) => void;
+  unregisterFromEvents: (viewTag: number) => void;
+};
+
+type WorkletHandlerOrWorkletHandlerObject =
+  | WorkletHandler
+  | {
+      workletEventHandler: WorkletHandler;
+    };
+
 /**
  * An internal hook that helps to register workletized event handlers.
  *
- * @param map - Map of event handlers and their names.
  * @param viewTagRef - Ref to the view that produces events.
  * @returns A function that registers supplied event handlers.
  * @example
@@ -21,14 +31,12 @@ type ComponentOrHandle = Parameters<typeof findNodeHandle>[0];
  * );
  * ```
  */
-export function useEventHandlerRegistration<
-  H extends Partial<Record<string, EventHandler>>,
->(
-  map: Map<keyof H, string>,
+export function useEventHandlerRegistration(
   viewTagRef: React.MutableRefObject<ComponentOrHandle>,
 ) {
-  const onRegisterHandler = (handler: H) => {
-    const ids: (number | null)[] = [];
+  const onRegisterHandler = (handler: EventHandlerProcessed<never, never>) => {
+    const currentHandler =
+      handler as unknown as WorkletHandlerOrWorkletHandlerObject;
     const attachWorkletHandlers = () => {
       const viewTag = findNodeHandle(viewTagRef.current);
 
@@ -38,26 +46,13 @@ export function useEventHandlerRegistration<
         );
       }
 
-      ids.push(
-        ...Object.keys(handler).map((handlerName) => {
-          const eventName = map.get(handlerName as keyof H);
-          const functionToCall = handler[handlerName as keyof H];
-
-          if (eventName && viewTag) {
-            return registerEventHandler(
-              (event: Parameters<NonNullable<H[keyof H]>>[0]) => {
-                "worklet";
-
-                functionToCall?.(event);
-              },
-              eventName,
-              viewTag,
-            );
-          }
-
-          return null;
-        }),
-      );
+      if (viewTag) {
+        if ("workletEventHandler" in currentHandler) {
+          currentHandler.workletEventHandler.registerForEvents(viewTag);
+        } else {
+          currentHandler.registerForEvents(viewTag);
+        }
+      }
     };
 
     if (viewTagRef.current) {
@@ -68,7 +63,15 @@ export function useEventHandlerRegistration<
     }
 
     return () => {
-      ids.forEach((id) => (id ? unregisterEventHandler(id) : null));
+      const viewTag = findNodeHandle(viewTagRef.current);
+
+      if (viewTag) {
+        if ("workletEventHandler" in currentHandler) {
+          currentHandler.workletEventHandler.unregisterFromEvents(viewTag);
+        } else {
+          currentHandler.unregisterFromEvents(viewTag);
+        }
+      }
     };
   };
 

package/src/specs/KeyboardControllerViewNativeComponent.ts

@@ -1,3 +1,4 @@
+import codegenNativeCommands from "react-native/Libraries/Utilities/codegenNativeCommands";
 import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
 
 import type { HostComponent } from "react-native";
@@ -66,6 +67,16 @@ export interface NativeProps extends ViewProps {
   onFocusedInputSelectionChanged?: DirectEventHandler<FocusedInputSelectionChangedEvent>;
 }
 
+interface NativeCommands {
+  synchronizeFocusedInputLayout: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ["synchronizeFocusedInputLayout"],
+});
+
 export default codegenNativeComponent<NativeProps>("KeyboardControllerView", {
   interfaceOnly: true,
 }) as HostComponent<NativeProps>;

package/src/types/internal.ts

@@ -1,6 +1,8 @@
 import type { EmitterSubscription } from "react-native";
 
-export type FocusedInputAvailableEvents = "focusDidSet";
+export type FocusedInputAvailableEvents =
+  | "focusDidSet"
+  | "layoutDidSynchronize";
 export type FocusedInputEventData = {
   current: number;
   count: number;

package/src/types/module.ts

@@ -23,7 +23,7 @@ export type KeyboardEventData = {
 /**
  * An object that represent current keyboard state.
  */
-export type KeyboardState = {
+export type IKeyboardState = {
   /** Whether the keyboard is currently visible. */
   isVisible: boolean;
 } & KeyboardEventData;
@@ -85,10 +85,11 @@ export type KeyboardControllerModule = {
   // all platforms
   /**
    * Dismisses the active keyboard. Removes a focus by default, but allows to pass `{keepFocus: true}` to keep focus.
+   * If you want to close keyboard immediately pass `{animated: false}`.
    *
    * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/keyboard-controller#dismiss|docs} page for more details.
    */
-  dismiss: (options?: DismissOptions) => Promise<void>;
+  dismiss: (options?: Partial<DismissOptions>) => Promise<void>;
   /**
    * Moves focus to the specified direction (`next`, `prev` or `current` to restore a focus).
    *

package/lib/commonjs/event-handler.d.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=event-handler.d.js.map

package/lib/commonjs/event-handler.d.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sources":["event-handler.d.ts"],"sourcesContent":["declare function registerEventHandler(\n  handler: (event: never) => void,\n  eventName: string,\n  viewTag: number,\n): number;\ndeclare function unregisterEventHandler(id: number): void;\n\nexport { registerEventHandler, unregisterEventHandler };\n"],"mappings":"","ignoreList":[]}