react-native-dodge-keyboard 1.0.5 → 1.0.7

package/index.d.ts

@@ -11,7 +11,7 @@ export interface LiftUpDodge {
     /**
      * A reference to the view that should be lifted.
      * 
-     * null is returned if the view has been recently removed from the node hierarchy
+     * null may be returned if the view has been recently removed from the node hierarchy
      */
     viewRef: ScrollView | View | null;
 }

package/index.js

@@ -1,7 +1,7 @@
-import { Children, cloneElement, createElement, forwardRef, isValidElement, memo, useEffect, useMemo, useRef, useState } from "react";
+import { Children, cloneElement, createElement, forwardRef, isValidElement, memo, useEffect, useMemo, useRef, useState, useImperativeHandle } from "react";
 import { Animated, Dimensions, findNodeHandle, Keyboard, Platform, StyleSheet, UIManager, useAnimatedValue } from "react-native";
 
-export default function ({ children, offset = 10, disabled, onHandleDodging, disableTagCheck, checkIfElementIsFocused }) {
+const DodgeKeyboard = forwardRef(({ children, offset = 10, disabled, onHandleDodging, disableTagCheck, checkIfElementIsFocused }, ref) => {
     if (checkIfElementIsFocused !== undefined) {
         if (typeof checkIfElementIsFocused !== 'function')
             throw 'checkIfElementIsFocused should be a function';
@@ -25,21 +25,21 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
      */
     const viewRefsMap = useRef({});
     const doDodgeKeyboard = useRef();
-    const previousLift = useRef();
+    const previousLift = useRef({ scrollId: undefined, lift: undefined });
     const wasVisible = useRef();
     const pendingIdleTask = useRef();
     const resizerTimer = useRef();
     const lastKeyboardEvent = useRef();
 
     const clearPreviousDodge = (scrollId) => {
-        if (previousLift.current && previousLift.current !== scrollId) {
-            const viewRef = viewRefsMap.current[previousLift.current]?.scrollRef;
+        if (previousLift.current.scrollId && previousLift.current.scrollId !== scrollId) {
+            const viewRef = viewRefsMap.current[previousLift.current.scrollId]?.scrollRef;
             onHandleDodging?.({
                 liftUp: 0,
                 viewRef: viewRef || null,
                 keyboardEvent: lastKeyboardEvent.current
             });
-            previousLift.current = undefined;
+            previousLift.current = { scrollId: undefined, lift: undefined };
         }
     }
 
@@ -107,16 +107,17 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
                     if (scrollRef) {
                         if (__is_standalone) {
                             if (checkFocused(scrollRef, allInputList)) {
-                                UIManager.measure(findNodeHandle(scrollRef), (_x, _y, w, h, x, y) => {
-                                    const { dodge_keyboard_offset } = _standalone_props || {};
+                                UIManager.measure(findNodeHandle(scrollRef), (x, y, width, height, pageX, pageY) => {
+                                    const { dodge_keyboard_offset, dodge_keyboard_clipping } = _standalone_props || {};
                                     const thisOffset = isNumber(dodge_keyboard_offset) ? dodge_keyboard_offset : offset;
 
-                                    const liftUp = Math.max(0, (y - keyboardInfo.screenY) + Math.min(h + thisOffset, keyboardInfo.screenY));
+                                    const liftUp = (pageY - keyboardInfo.screenY) + Math.min(height + thisOffset, keyboardInfo.screenY);
                                     clearPreviousDodge(scrollId);
-                                    if (liftUp) {
-                                        previousLift.current = scrollId;
+                                    if (liftUp > 0 || (dodge_keyboard_clipping && liftUp && previousLift.current.lift !== liftUp)) {
+                                        previousLift.current = { scrollId, lift: liftUp };
                                         onHandleDodging?.({
                                             liftUp,
+                                            layout: { x, y, width, height, pageX, pageY },
                                             viewRef: scrollRef,
                                             keyboardEvent: lastKeyboardEvent.current
                                         });
@@ -130,23 +131,27 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
                                 if (checkFocused(inputObj, allInputList)) {
                                     Promise.all([
                                         new Promise(resolve => {
-                                            UIManager.measure(findNodeHandle(scrollRef), (x, y, w, h, px, py) => {
-                                                resolve({ h, py });
+                                            UIManager.measure(findNodeHandle(scrollRef), (x, y, width, height, pageX, pageY) => {
+                                                resolve({
+                                                    h: height,
+                                                    py: pageY,
+                                                    scrollLayout: { x, y, width, height, pageX, pageY }
+                                                });
                                             });
                                         }),
                                         new Promise(resolve => {
-                                            inputObj.measure((x, y, w, h, px, py) => { // y is dynamic
-                                                resolve({ py });
+                                            inputObj.measure((x, y, width, height, pageX, pageY) => { // y is dynamic
+                                                resolve({ py: pageY, layout: { x, y, width, height, pageX, pageY } });
                                             });
                                         }),
                                         new Promise((resolve, reject) => {
-                                            inputObj.measureLayout(scrollRef, (l, t, w, h) => { // t is fixed
-                                                resolve({ t, h })
+                                            inputObj.measureLayout(scrollRef, (l, t, width, height) => { // t is fixed
+                                                resolve({ t, h: height, relativeLayout: { left: l, top: t, width, height } });
                                             }, reject);
                                         })
-                                    ]).then(([{ h: sh, py: sy }, { py: y }, { t, h }]) => {
+                                    ]).then(([{ h: sh, py: sy, scrollLayout }, { py: y, layout }, { t, h, relativeLayout }]) => {
 
-                                        const { dodge_keyboard_offset } = props || {};
+                                        const { dodge_keyboard_offset, dodge_keyboard_clipping } = props || {};
                                         const thisOffset = isNumber(dodge_keyboard_offset) ? dodge_keyboard_offset : offset;
 
                                         const scrollInputY = y - sy;
@@ -159,10 +164,13 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
                                                 // for lifting up the scroll-view
                                                 const liftUp = Math.max(0, requiredScrollY - t);
                                                 clearPreviousDodge(scrollId);
-                                                if (liftUp) {
-                                                    previousLift.current = scrollId;
+                                                if (liftUp > 0 || (dodge_keyboard_clipping && liftUp && previousLift.current.lift !== liftUp)) {
+                                                    previousLift.current = { scrollId, lift: liftUp };
                                                     onHandleDodging?.({
                                                         liftUp,
+                                                        layout,
+                                                        scrollLayout,
+                                                        relativeLayout,
                                                         viewRef: scrollRef,
                                                         keyboardEvent: lastKeyboardEvent.current
                                                     });
@@ -216,7 +224,14 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
     useEffect(() => {
         if (currentPaddedScroller) {
             const ref = viewRefsMap.current[paddedId]?.scrollRef;
-            tryPerformScroll(ref, paddedScroll, false);
+            if (Platform.OS === 'android') {
+                tryPerformScroll(ref, paddedScroll, false);
+            } else {
+                // this seem to be removing `the flash bang` on IOS
+                setTimeout(() => {
+                    tryPerformScroll(ref, paddedScroll, false);
+                }, 1);
+            }
         }
     }, [currentPaddedScroller]);
 
@@ -224,6 +239,10 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
         doDodgeKeyboard.current();
     }, [offset, !disabled]);
 
+    useImperativeHandle(ref, () => ({
+        trigger: () => doDodgeKeyboard.current()
+    }), []);
+
     useEffect(() => {
         if (disabled) return;
         const frameListener = Keyboard.addListener('keyboardDidChangeFrame', e => doDodgeKeyboard.current(e));
@@ -272,7 +291,8 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
                     viewRefsMap.current[scrollId].__is_standalone = true;
                     viewRefsMap.current[scrollId]._standalone_props = {
                         dodge_keyboard_offset: node.props?.dodge_keyboard_offset,
-                        dodge_keyboard_lift: node.props?.dodge_keyboard_lift
+                        dodge_keyboard_lift: node.props?.dodge_keyboard_lift,
+                        dodge_keyboard_clipping: node.props?.dodge_keyboard_clipping
                     };
                 }
             }
@@ -302,7 +322,8 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
                             viewRefsMap.current[scrollId].inputRef[inputId] = {};
                         viewRefsMap.current[scrollId].inputRef[inputId].props = {
                             dodge_keyboard_offset: inputNode.props?.dodge_keyboard_offset,
-                            dodge_keyboard_lift: inputNode.props?.dodge_keyboard_lift
+                            dodge_keyboard_lift: inputNode.props?.dodge_keyboard_lift,
+                            dodge_keyboard_clipping: inputNode.props?.dodge_keyboard_clipping
                         };
                     }
 
@@ -414,7 +435,9 @@ export default function ({ children, offset = 10, disabled, onHandleDodging, dis
             {children}
         </ReactHijacker>
     );
-};
+});
+
+export default DodgeKeyboard;
 
 const niceFunction = (func, message) => {
     return (...args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-dodge-keyboard",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "react-native-dodge-keyboard is a tiny library designed to flawlessly move your UI out of the way of the keyboard",
   "keywords": [
     "react-native",