@react-native-ohos/react-native-keyboard-controller 1.12.8-beta.9

package/lib/typescript/components/KeyboardToolbar/types.d.ts

@@ -0,0 +1,18 @@
+import type { ColorValue } from "react-native";
+type Theme = {
+    /** Color for arrow when it's enabled */
+    primary: ColorValue;
+    /** Color for arrow when it's disabled */
+    disabled: ColorValue;
+    /** Keyboard toolbar background color */
+    background: string;
+    /** Color for ripple effect (on button touch) on Android */
+    ripple: ColorValue;
+};
+export type KeyboardToolbarTheme = {
+    light: Theme;
+    dark: Theme;
+};
+type HexSymbol = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f";
+export type HEX = `${HexSymbol}${HexSymbol}`;
+export {};

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

@@ -0,0 +1,2 @@
+declare const useColorScheme: () => "light" | "dark";
+export default useColorScheme;

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

@@ -0,0 +1,8 @@
+export { default as KeyboardAvoidingView } from "./KeyboardAvoidingView";
+export { default as KeyboardStickyView } from "./KeyboardStickyView";
+export { default as KeyboardAwareScrollView } from "./KeyboardAwareScrollView";
+export { default as KeyboardToolbar, DefaultKeyboardToolbarTheme, } from "./KeyboardToolbar";
+export type { KeyboardAvoidingViewProps } from "./KeyboardAvoidingView";
+export type { KeyboardStickyViewProps } from "./KeyboardStickyView";
+export type { KeyboardAwareScrollViewProps } from "./KeyboardAwareScrollView";
+export type { KeyboardToolbarProps } from "./KeyboardToolbar";

package/lib/typescript/constants.d.ts

@@ -0,0 +1,16 @@
+export declare enum AndroidSoftInputModes {
+    SOFT_INPUT_ADJUST_NOTHING = 48,
+    SOFT_INPUT_ADJUST_PAN = 32,
+    SOFT_INPUT_ADJUST_RESIZE = 16,
+    SOFT_INPUT_ADJUST_UNSPECIFIED = 0,
+    SOFT_INPUT_IS_FORWARD_NAVIGATION = 256,
+    SOFT_INPUT_MASK_ADJUST = 240,
+    SOFT_INPUT_MASK_STATE = 15,
+    SOFT_INPUT_MODE_CHANGED = 512,
+    SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3,
+    SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5,
+    SOFT_INPUT_STATE_HIDDEN = 2,
+    SOFT_INPUT_STATE_UNCHANGED = 1,
+    SOFT_INPUT_STATE_UNSPECIFIED = 0,
+    SOFT_INPUT_STATE_VISIBLE = 4
+}

package/lib/typescript/context.d.ts

@@ -0,0 +1,23 @@
+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>>;
+};
+export declare const KeyboardContext: React.Context<KeyboardAnimationContext>;
+export declare const useKeyboardContext: () => KeyboardAnimationContext;

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

@@ -0,0 +1,17 @@
+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;
+export declare function useGenericKeyboardHandler(handler: KeyboardHandler, deps?: DependencyList): void;
+export declare function useKeyboardHandler(handler: KeyboardHandler, deps?: DependencyList): void;
+export declare function useKeyboardController(): {
+    setEnabled: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    enabled: boolean;
+};
+export declare function useReanimatedFocusedInput(): {
+    input: import("react-native-reanimated").SharedValue<import("../types").FocusedInputLayoutChangedEvent | null>;
+};
+export declare function useFocusedInputHandler(handler?: FocusedInputHandler, deps?: DependencyList): void;
+export * from "./useWindowDimensions";

package/lib/typescript/hooks/useWindowDimensions/index.android.d.ts

@@ -0,0 +1,2 @@
+import type { WindowDimensionsEventData } from "../../types";
+export declare const useWindowDimensions: () => WindowDimensionsEventData;

package/lib/typescript/hooks/useWindowDimensions/index.d.ts

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

package/lib/typescript/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./bindings";
+export * from "./animated";
+export * from "./context";
+export * from "./hooks";
+export * from "./constants";
+export * from "./types";
+export { KeyboardAvoidingView, KeyboardStickyView, KeyboardAwareScrollView, KeyboardToolbar, DefaultKeyboardToolbarTheme, } from "./components";
+export type { KeyboardAvoidingViewProps, KeyboardStickyViewProps, KeyboardAwareScrollViewProps, KeyboardToolbarProps, } from "./components";

package/lib/typescript/internal.d.ts

@@ -0,0 +1,30 @@
+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.
+ *
+ * T is a generic that looks like:
+ * @example
+ * {
+ *  onEvent: () => {},
+ *  onEvent2: () => {},
+ * }
+ */
+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
+ * 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 declare function useAnimatedValue(initialValue: number, config?: Animated.AnimatedConfig): Animated.Value;
+export {};

package/lib/typescript/monkey-patch.android.d.ts

@@ -0,0 +1,2 @@
+export declare const applyMonkeyPatch: () => void;
+export declare const revertMonkeyPatch: () => void;

package/lib/typescript/monkey-patch.d.ts

@@ -0,0 +1,2 @@
+export declare const applyMonkeyPatch: () => void;
+export declare const revertMonkeyPatch: () => void;

package/lib/typescript/reanimated.d.ts

@@ -0,0 +1,5 @@
+import type { EventWithName, FocusedInputLayoutChangedEvent, FocusedInputLayoutHandlerHook, FocusedInputSelectionChangedEvent, FocusedInputSelectionHandlerHook, FocusedInputTextChangedEvent, FocusedInputTextHandlerHook, KeyboardHandlerHook, NativeEvent } from "./types";
+export declare const useAnimatedKeyboardHandler: KeyboardHandlerHook<Record<string, unknown>, EventWithName<NativeEvent>>;
+export declare const useFocusedInputLayoutHandler: FocusedInputLayoutHandlerHook<Record<string, unknown>, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputTextHandler: FocusedInputTextHandlerHook<Record<string, unknown>, EventWithName<FocusedInputTextChangedEvent>>;
+export declare const useFocusedInputSelectionHandler: FocusedInputSelectionHandlerHook<Record<string, unknown>, EventWithName<FocusedInputSelectionChangedEvent>>;

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

@@ -0,0 +1,7 @@
+import type { EventWithName, FocusedInputLayoutChangedEvent, FocusedInputLayoutHandlerHook, FocusedInputSelectionChangedEvent, FocusedInputSelectionHandlerHook, FocusedInputTextChangedEvent, FocusedInputTextHandlerHook, KeyboardHandlerHook, NativeEvent } from "./types";
+type EventContext = Record<string, unknown>;
+export declare const useAnimatedKeyboardHandler: KeyboardHandlerHook<EventContext, EventWithName<NativeEvent>>;
+export declare const useFocusedInputLayoutHandler: FocusedInputLayoutHandlerHook<EventContext, EventWithName<FocusedInputLayoutChangedEvent>>;
+export declare const useFocusedInputTextHandler: FocusedInputTextHandlerHook<EventContext, EventWithName<FocusedInputTextChangedEvent>>;
+export declare const useFocusedInputSelectionHandler: FocusedInputSelectionHandlerHook<EventContext, EventWithName<FocusedInputSelectionChangedEvent>>;
+export {};

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

@@ -0,0 +1,53 @@
+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;
+    duration: Int32;
+    target: Int32;
+}>;
+type FocusedInputLayoutChangedEvent = Readonly<{
+    target: Int32;
+    parentScrollViewTarget: Int32;
+    layout: {
+        x: Double;
+        y: Double;
+        width: Double;
+        height: Double;
+        absoluteX: Double;
+        absoluteY: Double;
+    };
+}>;
+type FocusedInputTextChangedEvent = Readonly<{
+    text: string;
+}>;
+type FocusedInputSelectionChangedEvent = Readonly<{
+    target: Int32;
+    selection: {
+        start: {
+            x: Double;
+            y: Double;
+            position: Int32;
+        };
+        end: {
+            x: Double;
+            y: Double;
+            position: Int32;
+        };
+    };
+}>;
+export interface NativeProps extends ViewProps {
+    enabled?: boolean;
+    statusBarTranslucent?: boolean;
+    navigationBarTranslucent?: boolean;
+    onKeyboardMoveStart?: DirectEventHandler<KeyboardMoveEvent>;
+    onKeyboardMove?: DirectEventHandler<KeyboardMoveEvent>;
+    onKeyboardMoveEnd?: DirectEventHandler<KeyboardMoveEvent>;
+    onKeyboardMoveInteractive?: DirectEventHandler<KeyboardMoveEvent>;
+    onFocusedInputLayoutChanged?: DirectEventHandler<FocusedInputLayoutChangedEvent>;
+    onFocusedInputTextChanged?: DirectEventHandler<FocusedInputTextChangedEvent>;
+    onFocusedInputSelectionChanged?: DirectEventHandler<FocusedInputSelectionChangedEvent>;
+}
+declare const _default: HostComponent<NativeProps>;
+export default _default;

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

@@ -0,0 +1,10 @@
+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">;
+    showOnSwipeUp?: boolean;
+    enableSwipeToDismiss?: boolean;
+}
+declare const _default: HostComponent<NativeProps>;
+export default _default;

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

@@ -0,0 +1,12 @@
+import type { TurboModule } from "react-native";
+export interface Spec extends TurboModule {
+    readonly getConstants: () => {};
+    setInputMode(mode: number): void;
+    setDefaultMode(): void;
+    dismiss(): void;
+    setFocusTo(direction: string): void;
+    addListener: (eventName: string) => void;
+    removeListeners: (count: number) => void;
+}
+declare const _default: Spec | null;
+export default _default;

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

@@ -0,0 +1,10 @@
+import type { TurboModule } from "react-native";
+export interface Spec extends TurboModule {
+    readonly getConstants: () => {};
+    setHidden(hidden: boolean): void;
+    setColor(color: number, animated: boolean): void;
+    setTranslucent(translucent: boolean): void;
+    setStyle(style: string): void;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/typescript/types.d.ts

@@ -0,0 +1,133 @@
+import type { EmitterSubscription, NativeSyntheticEvent, ViewProps } from "react-native";
+export type NativeEvent = {
+    progress: number;
+    height: number;
+    duration: number;
+    target: number;
+};
+export type FocusedInputLayoutChangedEvent = {
+    target: number;
+    parentScrollViewTarget: number;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        absoluteX: number;
+        absoluteY: number;
+    };
+};
+export type FocusedInputTextChangedEvent = {
+    text: string;
+};
+export type FocusedInputSelectionChangedEvent = {
+    target: number;
+    selection: {
+        start: {
+            x: number;
+            y: number;
+            position: number;
+        };
+        end: {
+            x: number;
+            y: number;
+            position: number;
+        };
+    };
+};
+export type EventWithName<T> = {
+    eventName: string;
+} & T;
+export type KeyboardControllerProps = {
+    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;
+    onFocusedInputSelectionChanged?: (e: NativeSyntheticEvent<EventWithName<FocusedInputSelectionChangedEvent>>) => void;
+    onKeyboardMoveReanimated?: (e: NativeSyntheticEvent<EventWithName<NativeEvent>>) => void;
+    onFocusedInputLayoutChangedReanimated?: (e: NativeSyntheticEvent<EventWithName<FocusedInputLayoutChangedEvent>>) => void;
+    onFocusedInputTextChangedReanimated?: (e: NativeSyntheticEvent<EventWithName<FocusedInputTextChangedEvent>>) => void;
+    onFocusedInputSelectionChangedReanimated?: (e: NativeSyntheticEvent<EventWithName<FocusedInputSelectionChangedEvent>>) => void;
+    statusBarTranslucent?: boolean;
+    navigationBarTranslucent?: boolean;
+    enabled?: boolean;
+} & ViewProps;
+export type KeyboardGestureAreaProps = {
+    interpolator: "ios" | "linear";
+    /**
+     * Whether to allow to show a keyboard from dismissed state by swipe up.
+     * Default to `false`.
+     */
+    showOnSwipeUp?: boolean;
+    /**
+     * Whether to allow to control a keyboard by gestures. The strategy how
+     * it should be controlled is determined by `interpolator` property.
+     * Defaults to `true`.
+     */
+    enableSwipeToDismiss?: boolean;
+} & ViewProps;
+export type Direction = "next" | "prev" | "current";
+export type KeyboardControllerModule = {
+    setDefaultMode: () => void;
+    setInputMode: (mode: number) => void;
+    dismiss: () => void;
+    setFocusTo: (direction: Direction) => void;
+    addListener: (eventName: string) => void;
+    removeListeners: (count: number) => void;
+};
+export type KeyboardControllerEvents = "keyboardWillShow" | "keyboardDidShow" | "keyboardWillHide" | "keyboardDidHide";
+export type KeyboardEventData = {
+    height: number;
+    duration: number;
+    timestamp: number;
+    target: number;
+};
+export type KeyboardEventsModule = {
+    addListener: (name: KeyboardControllerEvents, cb: (e: KeyboardEventData) => void) => EmitterSubscription;
+};
+export type FocusedInputAvailableEvents = "focusDidSet";
+export type FocusedInputEventData = {
+    current: number;
+    count: number;
+};
+export type FocusedInputEventsModule = {
+    addListener: (name: FocusedInputAvailableEvents, cb: (e: FocusedInputEventData) => void) => EmitterSubscription;
+};
+export type WindowDimensionsAvailableEvents = "windowDidResize";
+export type WindowDimensionsEventData = {
+    width: number;
+    height: number;
+};
+export type WindowDimensionsEventsModule = {
+    addListener: (name: WindowDimensionsAvailableEvents, cb: (e: WindowDimensionsEventData) => void) => EmitterSubscription;
+};
+export type KeyboardHandlerHook<TContext, Event> = (handlers: {
+    onKeyboardMoveStart?: (e: NativeEvent, context: TContext) => void;
+    onKeyboardMove?: (e: NativeEvent, context: TContext) => void;
+    onKeyboardMoveEnd?: (e: NativeEvent, context: TContext) => void;
+    onKeyboardMoveInteractive?: (e: NativeEvent, context: TContext) => void;
+}, dependencies?: unknown[]) => (e: NativeSyntheticEvent<Event>) => void;
+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 FocusedInputSelectionHandlerHook<TContext, Event> = (handlers: {
+    onFocusedInputSelectionChanged?: (e: FocusedInputSelectionChangedEvent, 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;
+    onMove: (e: NativeEvent) => void;
+    onEnd: (e: NativeEvent) => void;
+    onInteractive: (e: NativeEvent) => void;
+}>;
+export type KeyboardHandlers = Handlers<KeyboardHandler>;
+export type FocusedInputHandler = Partial<{
+    onChangeText: (e: FocusedInputTextChangedEvent) => void;
+    onSelectionChange: (e: FocusedInputSelectionChangedEvent) => void;
+}>;
+export type FocusedInputHandlers = Handlers<FocusedInputHandler>;

package/lib/typescript/utils.d.ts

@@ -0,0 +1 @@
+export declare const uuid: () => string;

package/package.json

@@ -0,0 +1,178 @@
+{
+  "name": "@react-native-ohos/react-native-keyboard-controller",
+  "version": "1.12.8-beta.9",
+  "description": "Keyboard manager which works in identical way on  iOS and Android and harmony",
+  "main": "lib/commonjs/index",
+  "module": "lib/module/index",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "harmony",
+    "cpp",
+    "react-native-keyboard-controller.podspec",
+    "jest",
+    "!lib/typescript/example",
+    "!harmony/keyboard_controller/build",
+    "!android/build",
+    "!android/.gradle",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!ios/build",
+    "!ios/KeyboardControllerNative",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "format": "prettier '**/*' --ignore-unknown --write",
+    "test": "jest",
+    "typescript": "tsc --noEmit --project tsconfig.build.json",
+    "lint": "eslint --quiet \"**/*.{js,ts,tsx}\"",
+    "lint-clang": "find ios/ -iname *.h -o -iname *.m -o -iname *.mm | grep -v -e Pods -e build | xargs clang-format -i -n --Werror",
+    "prepare": "bob build",
+    "release": "release-it",
+    "example": "yarn --cwd example",
+    "pods": "cd example && pod-install --quiet",
+    "bootstrap": "yarn example && yarn && yarn pods"
+  },
+  "keywords": [
+    "react-native",
+    "keyboard",
+    "interactive",
+    "dismiss",
+    "animation",
+    "focused input",
+    "text changed",
+    "selection changed",
+    "avoiding view",
+    "avoid keyboard",
+    "sticky view",
+    "keyboard aware scroll view",
+    "keyboard toolbar",
+    "keyboard done button",
+    "keyboard next button",
+    "keyboard previous button",
+    "ios",
+    "android",
+    "harmony"
+  ],
+  "repository": "https://github.com/react-native-oh-library/react-native-keyboard-controller",
+  "author": "Kiryl Ziusko <zyusko.kirik@gmail.com> (https://github.com/kirillzyusko)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/react-native-oh-library/react-native-keyboard-controller/issues"
+  },
+  "homepage": "https://kirillzyusko.github.io/react-native-keyboard-controller/",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^11.0.0",
+    "@react-native/eslint-config": "^0.75.3",
+    "@release-it/conventional-changelog": "^2.0.0",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@types/jest": "^29.2.1",
+    "@types/react": "^18.2.6",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
+    "clang-format": "^1.8.0",
+    "commitlint": "^11.0.0",
+    "eslint": "^8.19.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jest": "^26.5.3",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-react-compiler": "^0.0.0-experimental-0998c1e-20240625",
+    "eslint-plugin-react-perf": "^3.3.2",
+    "husky": "^6.0.0",
+    "jest": "^29.6.3",
+    "pod-install": "^0.1.0",
+    "prettier": "^2.8.8",
+    "react": "18.3.1",
+    "react-native": "0.75.3",
+    "react-native-builder-bob": "^0.18.0",
+    "react-native-reanimated": "3.15.0",
+    "react-test-renderer": "18.2.0",
+    "release-it": "^14.2.2",
+    "typescript": "5.0.4"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-reanimated": ">=3.0.0",
+    "react-native-keyboard-controller": "1.12.7"
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": "angular"
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "trailingComma": "all"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "reactnativekeyboardcontroller",
+    "type": "all",
+    "jsSrcsDir": "./src/specs",
+    "android": {
+      "javaPackageName": "com.reactnativekeyboardcontroller"
+    }
+  },
+  "harmony": {
+    "alias": "react-native-keyboard-controller",
+    "autolinking": {
+      "etsPackageClassName":"RNKeyboardControllerPackage",
+      "cppPackageClassName":"RNKeyboardControllerPackage",
+      "cmakeLibraryTargetName": "rnoh_keyboard_controller", 
+      "ohPackageName": "@react-native-ohos/react-native-keyboard-controller"
+    }
+  }
+}

package/react-native-keyboard-controller.podspec

@@ -0,0 +1,61 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-keyboard-controller"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://github.com/kirillzyusko/react-native-keyboard-controller.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.exclude_files = "ios/KeyboardControllerNative/**/*"
+  s.public_header_files = "ios/**/*.h"
+
+  # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
+  if new_arch_enabled then
+    s.pod_target_xcconfig = {
+      # This is handy when we want to detect if new arch is enabled in Swift code
+      # and can be used like:
+      # #if KEYBOARD_CONTROLLER_NEW_ARCH_ENABLED
+      # // do sth when new arch is enabled
+      # #else
+      # // do sth when old arch is enabled
+      # #endif
+      "OTHER_SWIFT_FLAGS" => "-DKEYBOARD_CONTROLLER_NEW_ARCH_ENABLED"
+    }
+  end
+
+  # install_modules_dependencies has been defined since React Native 71
+  if defined?(install_modules_dependencies)
+    install_modules_dependencies(s)
+  else
+    s.dependency 'React-Core'
+
+    # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
+    if new_arch_enabled then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig = s.pod_target_xcconfig | {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+
+      s.dependency "React-RCTFabric"
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+end