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

package/src/context.ts

@@ -1,68 +1,68 @@
-import { createContext, useContext } from "react";
-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>;
-};
-export type ReanimatedContext = {
-  progress: SharedValue<number>;
-  height: SharedValue<number>;
-};
-export type KeyboardAnimationContext = {
-  enabled: boolean;
-  animated: AnimatedContext;
-  reanimated: ReanimatedContext;
-  layout: SharedValue<FocusedInputLayoutChangedEvent | null>;
-  setKeyboardHandlers: (handlers: KeyboardHandlers) => void;
-  setInputHandlers: (handlers: FocusedInputHandlers) => void;
-  setEnabled: React.Dispatch<React.SetStateAction<boolean>>;
-};
-const NOOP = () => {};
-const NESTED_NOOP = () => NOOP;
-const withSharedValue = <T>(value: T): SharedValue<T> => ({
-  value,
-  addListener: NOOP,
-  removeListener: NOOP,
-  modify: NOOP,
-  get: () => value,
-  set: NOOP,
-});
-const DEFAULT_SHARED_VALUE = withSharedValue(0);
-const DEFAULT_LAYOUT = withSharedValue<FocusedInputLayoutChangedEvent | null>(
-  null,
-);
-const defaultContext: KeyboardAnimationContext = {
-  enabled: true,
-  animated: {
-    progress: new Animated.Value(0),
-    height: new Animated.Value(0),
-  },
-  reanimated: {
-    progress: DEFAULT_SHARED_VALUE,
-    height: DEFAULT_SHARED_VALUE,
-  },
-  layout: DEFAULT_LAYOUT,
-  setKeyboardHandlers: NESTED_NOOP,
-  setInputHandlers: NESTED_NOOP,
-  setEnabled: NOOP,
-};
-export const KeyboardContext = createContext(defaultContext);
-export const useKeyboardContext = () => {
-  const context = useContext(KeyboardContext);
-  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.",
-    );
-  }
-
-  return context;
-};
+import { createContext, useContext } from "react";
+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>;
+};
+export type ReanimatedContext = {
+  progress: SharedValue<number>;
+  height: SharedValue<number>;
+};
+export type KeyboardAnimationContext = {
+  enabled: boolean;
+  animated: AnimatedContext;
+  reanimated: ReanimatedContext;
+  layout: SharedValue<FocusedInputLayoutChangedEvent | null>;
+  setKeyboardHandlers: (handlers: KeyboardHandlers) => void;
+  setInputHandlers: (handlers: FocusedInputHandlers) => void;
+  setEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+};
+const NOOP = () => {};
+const NESTED_NOOP = () => NOOP;
+const withSharedValue = <T>(value: T): SharedValue<T> => ({
+  value,
+  addListener: NOOP,
+  removeListener: NOOP,
+  modify: NOOP,
+  get: () => value,
+  set: NOOP,
+});
+const DEFAULT_SHARED_VALUE = withSharedValue(0);
+const DEFAULT_LAYOUT = withSharedValue<FocusedInputLayoutChangedEvent | null>(
+  null,
+);
+const defaultContext: KeyboardAnimationContext = {
+  enabled: true,
+  animated: {
+    progress: new Animated.Value(0),
+    height: new Animated.Value(0),
+  },
+  reanimated: {
+    progress: DEFAULT_SHARED_VALUE,
+    height: DEFAULT_SHARED_VALUE,
+  },
+  layout: DEFAULT_LAYOUT,
+  setKeyboardHandlers: NESTED_NOOP,
+  setInputHandlers: NESTED_NOOP,
+  setEnabled: NOOP,
+};
+export const KeyboardContext = createContext(defaultContext);
+export const useKeyboardContext = () => {
+  const context = useContext(KeyboardContext);
+  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.",
+    );
+  }
+
+  return context;
+};

package/src/hooks/index.ts

@@ -1,90 +1,90 @@
-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 };
+}
+
+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";

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,23 @@
-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 {
+  KeyboardAvoidingView,
+  KeyboardStickyView,
+  KeyboardAwareScrollView,
+  // keyboard toolbar
+  KeyboardToolbar,
+  DefaultKeyboardToolbarTheme,
+} from "./components";
+export type {
+  KeyboardAvoidingViewProps,
+  KeyboardStickyViewProps,
+  KeyboardAwareScrollViewProps,
+  KeyboardToolbarProps,
+} from "./components";
+export { OverKeyboardView } from "./views";

package/src/internal.ts

@@ -1,84 +1,84 @@
-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 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;
+}