@react-native-ohos/react-native-keyboard-controller 1.17.0-beta.2 → 1.17.1-rc.1

package/src/hooks/index.ts

@@ -1,90 +1,91 @@
-import { useEffect } from "react";
-
-import { AndroidSoftInputModes } from "../constants";
-import { useKeyboardContext } from "../context";
-import { uuid } from "../utils";
-import { KeyboardController } from "../module";
-
-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,
-    );
-
-    return () => KeyboardController.setDefaultMode();
-  }, []);
-};
-
-export const useKeyboardAnimation = (): AnimatedContext => {
-  useResizeMode();
-  const context = useKeyboardContext();
-
-  return context.animated;
-};
-
-export const useReanimatedKeyboardAnimation = (): ReanimatedContext => {
-  useResizeMode();
-  const context = useKeyboardContext();
-
-  return context.reanimated;
-};
-
-export function useGenericKeyboardHandler(
-  handler: KeyboardHandler,
-  deps?: DependencyList,
-) {
-  const context = useKeyboardContext();
-
-  useEffect(() => {
-    const key = uuid();
-
-    context.setKeyboardHandlers({ [key]: handler });
-
-    return () => {
-      context.setKeyboardHandlers({ [key]: undefined });
-    };
-  }, deps);
-}
-
-export function useKeyboardHandler(
-  handler: KeyboardHandler,
-  deps?: DependencyList,
-) {
-  useResizeMode();
-  useGenericKeyboardHandler(handler, deps);
-}
-
-export function useKeyboardController() {
-  const context = useKeyboardContext();
-
-  return { setEnabled: context.setEnabled, enabled: context.enabled };
-}
-
-export function useReanimatedFocusedInput() {
-  const context = useKeyboardContext();
-
-  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);
-}
-
-export * from "./useWindowDimensions";
+import { useEffect } from "react";
+
+import { AndroidSoftInputModes } from "../constants";
+import { useKeyboardContext } from "../context";
+import { uuid } from "../utils";
+import { KeyboardController } from "../module";
+
+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,
+    );
+
+    return () => KeyboardController.setDefaultMode();
+  }, []);
+};
+
+export const useKeyboardAnimation = (): AnimatedContext => {
+  useResizeMode();
+  const context = useKeyboardContext();
+
+  return context.animated;
+};
+
+export const useReanimatedKeyboardAnimation = (): ReanimatedContext => {
+  useResizeMode();
+  const context = useKeyboardContext();
+
+  return context.reanimated;
+};
+
+export function useGenericKeyboardHandler(
+  handler: KeyboardHandler,
+  deps?: DependencyList,
+) {
+  const context = useKeyboardContext();
+
+  useEffect(() => {
+    const key = uuid();
+
+    context.setKeyboardHandlers({ [key]: handler });
+
+    return () => {
+      context.setKeyboardHandlers({ [key]: undefined });
+    };
+  }, deps);
+}
+
+export function useKeyboardHandler(
+  handler: KeyboardHandler,
+  deps?: DependencyList,
+) {
+  useResizeMode();
+  useGenericKeyboardHandler(handler, deps);
+}
+
+export function useKeyboardController() {
+  const context = useKeyboardContext();
+
+  return { setEnabled: context.setEnabled, enabled: context.enabled };
+}
+
+export function useReanimatedFocusedInput() {
+  const context = useKeyboardContext();
+
+  return { input: context.layout, update: context.update };
+}
+
+export function useFocusedInputHandler(
+  handler?: FocusedInputHandler,
+  deps?: DependencyList,
+) {
+  const context = useKeyboardContext();
+
+  useEffect(() => {
+    const key = uuid();
+
+    context.setInputHandlers({ [key]: handler });
+
+    return () => {
+      context.setInputHandlers({ [key]: undefined });
+    };
+  }, deps);
+}
+
+export * from "./useWindowDimensions";
+export * from "./useKeyboardState";

package/src/hooks/useKeyboardState/index.ts

@@ -0,0 +1,52 @@
+import { useEffect, useState } from "react";
+
+import { KeyboardEvents } from "../../bindings";
+import { KeyboardController } from "../../module";
+
+import type { IKeyboardState } from "../../types";
+
+const EVENTS = ["keyboardDidShow", "keyboardDidHide"] as const;
+
+const getLatestState = () => ({
+  ...KeyboardController.state(),
+  isVisible: KeyboardController.isVisible(),
+});
+
+type KeyboardStateSelector<T> = (state: IKeyboardState) => T;
+
+const defaultSelector: KeyboardStateSelector<IKeyboardState> = (state) => state;
+
+export function useKeyboardState<T = IKeyboardState>(
+  selector: KeyboardStateSelector<T> = defaultSelector as KeyboardStateSelector<T>,
+): T {
+  const [state, setState] = useState<T>(() => selector(getLatestState()));
+
+  useEffect(() => {
+    const subscriptions = EVENTS.map((event) =>
+      KeyboardEvents.addListener(event, () =>
+        // state will be updated by global listener first,
+        // so we simply read it and don't derive data from the event
+        setState(selector(getLatestState())),
+      ),
+    );
+    const willShowSubscription = KeyboardEvents.addListener(
+      "keyboardWillShow",
+      (event) =>
+        setState(
+          selector({ ...getLatestState(), appearance: event.appearance }),
+        ),
+    );
+
+    // we might have missed an update between reading a value in render and
+    // `addListener` in this handler, so we set it here. If there was
+    // no change, React will filter out this update as a no-op.
+    setState(selector(getLatestState()));
+
+    return () => {
+      subscriptions.forEach((subscription) => subscription.remove());
+      willShowSubscription.remove();
+    };
+  }, []);
+
+  return state;
+}

package/src/hooks/useWindowDimensions/index.android.ts

@@ -1,38 +1,38 @@
-import { useEffect, useState } from "react";
-
-import { WindowDimensionsEvents } from "../../bindings";
-
-import type { WindowDimensionsEventData } from "../../types";
-
-let initialDimensions: WindowDimensionsEventData = {
-  width: 0,
-  height: 0,
-};
-
-WindowDimensionsEvents.addListener("windowDidResize", (e) => {
-  initialDimensions = e;
-});
-
-export const useWindowDimensions = () => {
-  const [dimensions, setDimensions] = useState(initialDimensions);
-
-  useEffect(() => {
-    const subscription = WindowDimensionsEvents.addListener(
-      "windowDidResize",
-      (e) => {
-        setDimensions(e);
-      },
-    );
-
-    // we might have missed an update between reading a value in render and
-    // `addListener` in this handler, so we set it here. If there was
-    // no change, React will filter out this update as a no-op.
-    setDimensions(initialDimensions);
-
-    return () => {
-      subscription.remove();
-    };
-  }, []);
-
-  return dimensions;
-};
+import { useEffect, useState } from "react";
+
+import { WindowDimensionsEvents } from "../../bindings";
+
+import type { WindowDimensionsEventData } from "../../types";
+
+let initialDimensions: WindowDimensionsEventData = {
+  width: 0,
+  height: 0,
+};
+
+WindowDimensionsEvents.addListener("windowDidResize", (e) => {
+  initialDimensions = e;
+});
+
+export const useWindowDimensions = () => {
+  const [dimensions, setDimensions] = useState(initialDimensions);
+
+  useEffect(() => {
+    const subscription = WindowDimensionsEvents.addListener(
+      "windowDidResize",
+      (e) => {
+        setDimensions(e);
+      },
+    );
+
+    // we might have missed an update between reading a value in render and
+    // `addListener` in this handler, so we set it here. If there was
+    // no change, React will filter out this update as a no-op.
+    setDimensions(initialDimensions);
+
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+
+  return dimensions;
+};

package/src/hooks/useWindowDimensions/index.ts

@@ -1 +1 @@
-export { useWindowDimensions } from "react-native";
+export { useWindowDimensions } from "react-native";

package/src/index.ts

@@ -1,23 +1,27 @@
-export * from "./bindings";
-export * from "./animated";
-export * from "./context";
-export * from "./hooks";
-export * from "./constants";
-export * from "./module";
-export * from "./types";
-
-export {
-  KeyboardAvoidingView,
-  KeyboardStickyView,
-  KeyboardAwareScrollView,
-  // keyboard toolbar
-  KeyboardToolbar,
-  DefaultKeyboardToolbarTheme,
-} from "./components";
-export type {
-  KeyboardAvoidingViewProps,
-  KeyboardStickyViewProps,
-  KeyboardAwareScrollViewProps,
-  KeyboardToolbarProps,
-} from "./components";
-export { OverKeyboardView } from "./views";
+export * from "./bindings";
+export * from "./animated";
+export * from "./context";
+export * from "./hooks";
+export * from "./constants";
+export * from "./module";
+export * from "./types";
+export * from "./compat";
+
+export {
+  KeyboardChatScrollView,
+  KeyboardAvoidingView,
+  KeyboardStickyView,
+  KeyboardAwareScrollView,
+  // keyboard toolbar
+  KeyboardToolbar,
+  DefaultKeyboardToolbarTheme,
+} from "./components";
+export type {
+  KeyboardChatScrollViewProps,
+  KeyboardAvoidingViewProps,
+  KeyboardStickyViewProps,
+  KeyboardAwareScrollViewProps,
+  KeyboardAwareScrollViewRef,
+  KeyboardToolbarProps,
+} from "./components";
+export { OverKeyboardView, KeyboardExtender } from "./views";

package/src/internal.ts

@@ -1,84 +1,146 @@
-import { useCallback, useRef } from "react";
-import { Animated } from "react-native";
-import { useSharedValue } from "react-native-reanimated";
-
-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.
- *
- * T is a generic that looks like:
- * @example
- * {
- *  onEvent: () => {},
- *  onEvent2: () => {},
- * }
- */
-export function useSharedHandlers<
-  T extends UntypedHandler,
->(): SharedHandlersReturnType<T> {
-  const handlers = useSharedValue<Handlers<T>>({});
-  const jsHandlers = useRef<Handlers<T>>({});
-
-  // since js -> worklet -> js call is asynchronous, we can not write handlers
-  // straight into shared variable (using current shared value as a previous result),
-  // since there may be a race condition in a call, and closure may have out-of-dated
-  // values. As a result, some of handlers may be not written to "all handlers" object.
-  // Below we are writing all handlers to `ref` and afterwards synchronize them with
-  // shared value (since `refs` are not referring to actual value in worklets).
-  // This approach allow us to update synchronously handlers in js thread (and it assures,
-  // that it will have all of them) and then update them in worklet thread (calls are
-  // happening in FIFO order, so we will always have actual value).
-  const updateSharedHandlers = () => {
-    // eslint-disable-next-line react-compiler/react-compiler
-    handlers.value = jsHandlers.current;
-  };
-  const setHandlers = useCallback((handler: Handlers<T>) => {
-    jsHandlers.current = {
-      ...jsHandlers.current,
-      ...handler,
-    };
-    updateSharedHandlers();
-  }, []);
-  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);
-    });
-  };
-
-  return [setHandlers, broadcast];
-}
-
-/**
- * TS variant of `useAnimatedValue` hook which is added in RN 0.71
- * A better alternative of storing animated values in refs, since
- * it doesn't recreate a new `Animated.Value` object on every re-render
- * and therefore consumes less memory. We can not use a variant from
- * RN, since this library supports earlier versions of RN.
- *
- * @see https://github.com/facebook/react-native/commit/e22217fe8b9455e32695f88ca835e11442b0a937
- */
-export function useAnimatedValue(
-  initialValue: number,
-  config?: Animated.AnimatedConfig,
-): Animated.Value {
-  const ref = useRef<Animated.Value | null>(null);
-
-  if (ref.current == null) {
-    ref.current = new Animated.Value(initialValue, config);
-  }
-
-  return ref.current;
-}
+import { useCallback, useRef } from "react";
+import { Animated } from "react-native";
+import { useSharedValue } from "react-native-reanimated";
+
+import { findNodeHandle } from "./utils/findNodeHandle";
+
+import type { EventHandlerProcessed } from "react-native-reanimated";
+import type { Handlers } from "./types";
+
+type ComponentOrHandle = Parameters<typeof findNodeHandle>[0];
+
+type WorkletHandler = {
+  registerForEvents: (viewTag: number) => void;
+  unregisterFromEvents: (viewTag: number) => void;
+};
+
+type WorkletHandlerOrWorkletHandlerObject =
+  | WorkletHandler
+  | {
+      workletEventHandler: WorkletHandler;
+    };
+
+export function useEventHandlerRegistration(
+  viewTagRef: React.MutableRefObject<ComponentOrHandle>,
+) {
+  const onRegisterHandler = (handler: EventHandlerProcessed<never, never>) => {
+    const currentHandler =
+      handler as unknown as WorkletHandlerOrWorkletHandlerObject;
+    const attachWorkletHandlers = () => {
+      const viewTag = findNodeHandle(viewTagRef.current);
+
+      if (__DEV__ && !viewTag) {
+        console.warn(
+          "Can not attach worklet handlers for `react-native-keyboard-controller` because view tag can not be resolved. Be sure that `KeyboardProvider` is fully mounted before registering handlers. If you think it is a bug in library, please open an issue.",
+        );
+      }
+
+      if (viewTag) {
+        if ("workletEventHandler" in currentHandler) {
+          currentHandler.workletEventHandler.registerForEvents(viewTag);
+        } else {
+          currentHandler.registerForEvents(viewTag);
+        }
+      }
+    };
+
+    if (viewTagRef.current) {
+      attachWorkletHandlers();
+    } else {
+      queueMicrotask(attachWorkletHandlers);
+    }
+
+    return () => {
+      const viewTag = findNodeHandle(viewTagRef.current);
+
+      if (viewTag) {
+        if ("workletEventHandler" in currentHandler) {
+          currentHandler.workletEventHandler.unregisterFromEvents(viewTag);
+        } else {
+          currentHandler.unregisterFromEvents(viewTag);
+        }
+      }
+    };
+  };
+
+  return onRegisterHandler;
+}
+
+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.
+ *
+ * T is a generic that looks like:
+ * @example
+ * {
+ *  onEvent: () => {},
+ *  onEvent2: () => {},
+ * }
+ */
+export function useSharedHandlers<
+  T extends UntypedHandler,
+>(): SharedHandlersReturnType<T> {
+  const handlers = useSharedValue<Handlers<T>>({});
+  const jsHandlers = useRef<Handlers<T>>({});
+
+  // since js -> worklet -> js call is asynchronous, we can not write handlers
+  // straight into shared variable (using current shared value as a previous result),
+  // since there may be a race condition in a call, and closure may have out-of-dated
+  // values. As a result, some of handlers may be not written to "all handlers" object.
+  // Below we are writing all handlers to `ref` and afterwards synchronize them with
+  // shared value (since `refs` are not referring to actual value in worklets).
+  // This approach allow us to update synchronously handlers in js thread (and it assures,
+  // that it will have all of them) and then update them in worklet thread (calls are
+  // happening in FIFO order, so we will always have actual value).
+  const updateSharedHandlers = () => {
+    // eslint-disable-next-line react-compiler/react-compiler
+    handlers.value = jsHandlers.current;
+  };
+  const setHandlers = useCallback((handler: Handlers<T>) => {
+    jsHandlers.current = {
+      ...jsHandlers.current,
+      ...handler,
+    };
+    updateSharedHandlers();
+  }, []);
+  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);
+    });
+  };
+
+  return [setHandlers, broadcast];
+}
+
+/**
+ * TS variant of `useAnimatedValue` hook which is added in RN 0.71
+ * A better alternative of storing animated values in refs, since
+ * it doesn't recreate a new `Animated.Value` object on every re-render
+ * and therefore consumes less memory. We can not use a variant from
+ * RN, since this library supports earlier versions of RN.
+ *
+ * @see https://github.com/facebook/react-native/commit/e22217fe8b9455e32695f88ca835e11442b0a937
+ */
+export function useAnimatedValue(
+  initialValue: number,
+  config?: Animated.AnimatedConfig,
+): Animated.Value {
+  const ref = useRef<Animated.Value | null>(null);
+
+  if (ref.current == null) {
+    ref.current = new Animated.Value(initialValue, config);
+  }
+
+  return ref.current;
+}