react-native-keyboard-controller 1.21.0-beta.3 → 1.21.1

package/lib/module/components/KeyboardChatScrollView/useChatKeyboard/helpers.js

@@ -3,7 +3,7 @@ const AT_END_THRESHOLD = 20;
 
 /**
  * Map the current keyboard height to an effective height that accounts for a
- * fixed offset (e.g. bottom safe-area or tab-bar height).
+ * fixed offset (e.g. Bottom safe-area or tab-bar height)..
  *
  * @param height - Current keyboard height.
  * @param targetKeyboardHeight - Full target keyboard height (captured on keyboard open).
@@ -15,14 +15,14 @@ const AT_END_THRESHOLD = 20;
  * getEffectiveHeight(150, 300, 50); // 125
  * ```
  */
-export function getEffectiveHeight(height, targetKeyboardHeight, offset) {
+export const getEffectiveHeight = (height, targetKeyboardHeight, offset) => {
   "worklet";
 
   if (offset === 0 || targetKeyboardHeight === 0) {
     return height;
   }
   return interpolate(height, [0, targetKeyboardHeight], [0, Math.max(targetKeyboardHeight - offset, 0)]);
-}
+};
 
 /**
  * Check whether the scroll view is at the end of its content.
@@ -42,14 +42,14 @@ export function getEffectiveHeight(height, targetKeyboardHeight, offset) {
  * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)
  * ```
  */
-export function isScrollAtEnd(scrollOffset, layoutHeight, contentHeight, inverted = false) {
+export const isScrollAtEnd = (scrollOffset, layoutHeight, contentHeight, inverted = false) => {
   "worklet";
 
   if (inverted) {
     return scrollOffset <= AT_END_THRESHOLD;
   }
   return scrollOffset + layoutHeight >= contentHeight - AT_END_THRESHOLD;
-}
+};
 
 /**
  * Decide whether content should be shifted based on the keyboard lift behavior.
@@ -63,7 +63,7 @@ export function isScrollAtEnd(scrollOffset, layoutHeight, contentHeight, inverte
  * shouldShiftContent("whenAtEnd", false); // false
  * ```
  */
-export function shouldShiftContent(behavior, isAtEnd) {
+export const shouldShiftContent = (behavior, isAtEnd) => {
   "worklet";
 
   switch (behavior) {
@@ -76,50 +76,132 @@ export function shouldShiftContent(behavior, isAtEnd) {
     case "persistent":
       return true;
   }
-}
+};
+
+/**
+ * Compute the fraction of minimum padding space currently visible in the viewport (0–1).
+ *
+ * The minimum padding space lives in the scroll view's contentInset, NOT in the
+ * content itself.  So `contentHeight` (from onContentSizeChange / scroll
+ * events) does **not** include it.  The visible portion is how far the
+ * viewport extends past the content boundary into the inset area.
+ *
+ * For non-inverted lists the padding is in contentInset.bottom.
+ * For inverted lists the padding is in contentInset.top (negative scroll).
+ *
+ * @param scrollOffset - Current vertical scroll offset.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param contentHeight - Height of the scroll content (excludes insets).
+ * @param blankSpace - Size of the minimum padding inset area.
+ * @param inverted - Whether the list is inverted.
+ * @returns A value between 0 (padding fully off-screen) and 1 (padding fully visible).
+ * @example
+ * ```ts
+ * // Non-inverted: contentHeight=1500, layout=800, blankSpace=300
+ * getVisibleMinimumPaddingFraction(1500, 800, 1500, 300, false); // 1   (at end, viewport past content)
+ * getVisibleMinimumPaddingFraction(850, 800, 1500, 300, false);  // 0.5 (half padding visible)
+ * getVisibleMinimumPaddingFraction(700, 800, 1500, 300, false);  // 0   (padding off-screen)
+ * ```
+ */
+export const getVisibleMinimumPaddingFraction = (scrollOffset, layoutHeight, contentHeight, blankSpace, inverted) => {
+  "worklet";
+
+  if (blankSpace <= 0) {
+    return 0;
+  }
+  if (inverted) {
+    // Minimum padding is in contentInset.top; visible when scroll < 0
+    return Math.max(0, Math.min(1, -scrollOffset / blankSpace));
+  }
+
+  // Minimum padding is in contentInset.bottom; visible when viewport extends past content
+  const pastContentEnd = scrollOffset + layoutHeight - contentHeight;
+  return Math.max(0, Math.min(1, pastContentEnd / blankSpace));
+};
+
+/**
+ * Compute how much of the minimum content padding absorbs the keyboard + extraContentPadding.
+ *
+ * @param blankSpace - Minimum inset floor.
+ * @param extraContentPadding - Extra content padding from external elements.
+ * @returns The portion of blankSpace that absorbs keyboard displacement.
+ * @example
+ * ```ts
+ * getMinimumPaddingAbsorbed(500, 20); // 480
+ * getMinimumPaddingAbsorbed(0, 20);   // 0
+ * ```
+ */
+export const getMinimumPaddingAbsorbed = (blankSpace, extraContentPadding) => {
+  "worklet";
+
+  return Math.max(0, blankSpace - extraContentPadding);
+};
+
+/**
+ * Compute the effective scroll displacement after minimum padding absorption.
+ *
+ * @param rawEffective - Raw effective keyboard height.
+ * @param minimumPaddingAbsorbed - Amount absorbed by minimum content padding.
+ * @returns The scroll displacement after subtracting the absorbed portion.
+ * @example
+ * ```ts
+ * getScrollEffective(300, 200); // 100
+ * getScrollEffective(300, 400); // 0
+ * ```
+ */
+export const getScrollEffective = (rawEffective, minimumPaddingAbsorbed) => {
+  "worklet";
+
+  return Math.max(0, rawEffective - minimumPaddingAbsorbed);
+};
 
 /**
  * Compute the clamped scroll target for non-inverted lists.
  *
  * @param offsetBeforeScroll - Scroll position before keyboard appeared.
- * @param keyboardHeight - Current keyboard height.
+ * @param keyboardHeight - Current keyboard height (used for scroll displacement).
  * @param contentHeight - Total height of the scrollable content.
  * @param layoutHeight - Visible height of the scroll view.
+ * @param totalPaddingForMaxScroll - Total padding to use for maxScroll calculation. When provided, used instead of keyboardHeight for the scrollable range. Defaults to keyboardHeight.
  * @returns Clamped scroll target between 0 and maxScroll.
  * @example
  * ```ts
  * clampedScrollTarget(100, 300, 1000, 800); // 400
+ * clampedScrollTarget(100, 100, 1000, 800, 500); // 200, maxScroll uses 500
  * ```
  */
-export function clampedScrollTarget(offsetBeforeScroll, keyboardHeight, contentHeight, layoutHeight) {
+export const clampedScrollTarget = (offsetBeforeScroll, keyboardHeight, contentHeight, layoutHeight, totalPaddingForMaxScroll) => {
   "worklet";
 
-  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);
+  const paddingForMax = totalPaddingForMaxScroll !== undefined ? totalPaddingForMaxScroll : keyboardHeight;
+  const maxScroll = Math.max(contentHeight - layoutHeight + paddingForMax, 0);
   return Math.min(Math.max(offsetBeforeScroll + keyboardHeight, 0), maxScroll);
-}
+};
 
 /**
  * Compute contentOffset.y for iOS lists.
  *
  * @param relativeScroll - Scroll position relative to current inset.
- * @param keyboardHeight - Target keyboard height.
+ * @param keyboardHeight - Target keyboard height (used for scroll displacement).
  * @param contentHeight - Total height of the scrollable content.
  * @param layoutHeight - Visible height of the scroll view.
  * @param inverted - Whether the list is inverted.
+ * @param totalPaddingForMaxScroll - Total padding to use for maxScroll calculation. When provided, used instead of keyboardHeight for the scrollable range. Defaults to keyboardHeight.
  * @returns The absolute contentOffset.y to set.
  * @example
  * ```ts
  * computeIOSContentOffset(100, 300, 1000, 800, false); // 400
  * ```
  */
-export function computeIOSContentOffset(relativeScroll, keyboardHeight, contentHeight, layoutHeight, inverted) {
+export const computeIOSContentOffset = (relativeScroll, keyboardHeight, contentHeight, layoutHeight, inverted, totalPaddingForMaxScroll) => {
   "worklet";
 
+  const paddingForMax = totalPaddingForMaxScroll !== undefined ? totalPaddingForMaxScroll : keyboardHeight;
   if (inverted) {
     const maxScroll = Math.max(contentHeight - layoutHeight, 0);
-    return Math.max(Math.min(relativeScroll - keyboardHeight, maxScroll), -keyboardHeight);
+    return Math.max(Math.min(relativeScroll - keyboardHeight, maxScroll), -paddingForMax);
   }
-  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);
+  const maxScroll = Math.max(contentHeight - layoutHeight + paddingForMax, 0);
   return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);
-}
+};
 //# sourceMappingURL=helpers.js.map

package/lib/module/components/KeyboardChatScrollView/useChatKeyboard/helpers.js.map

@@ -1 +1 @@
-{"version":3,"names":["interpolate","AT_END_THRESHOLD","getEffectiveHeight","height","targetKeyboardHeight","offset","Math","max","isScrollAtEnd","scrollOffset","layoutHeight","contentHeight","inverted","shouldShiftContent","behavior","isAtEnd","clampedScrollTarget","offsetBeforeScroll","keyboardHeight","maxScroll","min","computeIOSContentOffset","relativeScroll"],"sources":["helpers.ts"],"sourcesContent":["import { interpolate } from \"react-native-reanimated\";\n\nimport type { KeyboardLiftBehavior } from \"./types\";\n\nconst AT_END_THRESHOLD = 20;\n\n/**\n * Map the current keyboard height to an effective height that accounts for a\n * fixed offset (e.g. bottom safe-area or tab-bar height).\n *\n * @param height - Current keyboard height.\n * @param targetKeyboardHeight - Full target keyboard height (captured on keyboard open).\n * @param offset - Fixed distance between the scroll-view bottom and the screen bottom.\n * @returns Effective height after subtracting the offset proportionally.\n * @example\n * ```ts\n * getEffectiveHeight(300, 300, 50); // 250\n * getEffectiveHeight(150, 300, 50); // 125\n * ```\n */\nexport function getEffectiveHeight(\n  height: number,\n  targetKeyboardHeight: number,\n  offset: number,\n): number {\n  \"worklet\";\n\n  if (offset === 0 || targetKeyboardHeight === 0) {\n    return height;\n  }\n\n  return interpolate(\n    height,\n    [0, targetKeyboardHeight],\n    [0, Math.max(targetKeyboardHeight - offset, 0)],\n  );\n}\n\n/**\n * Check whether the scroll view is at the end of its content.\n *\n * For non-inverted lists the \"end\" is the bottom of the content.\n * For inverted lists the \"end\" is the top (scroll offset near 0),\n * because that is where the latest messages are displayed.\n *\n * @param scrollOffset - Current vertical scroll offset.\n * @param layoutHeight - Visible height of the scroll view.\n * @param contentHeight - Total height of the scrollable content.\n * @param inverted - Whether the list is inverted.\n * @returns `true` if the scroll position is within the threshold of the content end.\n * @example\n * ```ts\n * const atEnd = isScrollAtEnd(100, 800, 920); // true (100 + 800 >= 920 - 20)\n * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)\n * ```\n */\nexport function isScrollAtEnd(\n  scrollOffset: number,\n  layoutHeight: number,\n  contentHeight: number,\n  inverted: boolean = false,\n): boolean {\n  \"worklet\";\n\n  if (inverted) {\n    return scrollOffset <= AT_END_THRESHOLD;\n  }\n\n  return scrollOffset + layoutHeight >= contentHeight - AT_END_THRESHOLD;\n}\n\n/**\n * Decide whether content should be shifted based on the keyboard lift behavior.\n *\n * @param behavior - The configured keyboard lift behavior.\n * @param isAtEnd - Whether the scroll view is currently at the end.\n * @returns `true` if content should be shifted.\n * @example\n * ```ts\n * shouldShiftContent(\"always\", false); // true\n * shouldShiftContent(\"whenAtEnd\", false); // false\n * ```\n */\nexport function shouldShiftContent(\n  behavior: KeyboardLiftBehavior,\n  isAtEnd: boolean,\n): boolean {\n  \"worklet\";\n\n  switch (behavior) {\n    case \"always\":\n      return true;\n    case \"never\":\n      return false;\n    case \"whenAtEnd\":\n      return isAtEnd;\n    case \"persistent\":\n      return true;\n  }\n}\n\n/**\n * Compute the clamped scroll target for non-inverted lists.\n *\n * @param offsetBeforeScroll - Scroll position before keyboard appeared.\n * @param keyboardHeight - Current keyboard height.\n * @param contentHeight - Total height of the scrollable content.\n * @param layoutHeight - Visible height of the scroll view.\n * @returns Clamped scroll target between 0 and maxScroll.\n * @example\n * ```ts\n * clampedScrollTarget(100, 300, 1000, 800); // 400\n * ```\n */\nexport function clampedScrollTarget(\n  offsetBeforeScroll: number,\n  keyboardHeight: number,\n  contentHeight: number,\n  layoutHeight: number,\n): number {\n  \"worklet\";\n\n  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);\n\n  return Math.min(Math.max(offsetBeforeScroll + keyboardHeight, 0), maxScroll);\n}\n\n/**\n * Compute contentOffset.y for iOS lists.\n *\n * @param relativeScroll - Scroll position relative to current inset.\n * @param keyboardHeight - Target keyboard height.\n * @param contentHeight - Total height of the scrollable content.\n * @param layoutHeight - Visible height of the scroll view.\n * @param inverted - Whether the list is inverted.\n * @returns The absolute contentOffset.y to set.\n * @example\n * ```ts\n * computeIOSContentOffset(100, 300, 1000, 800, false); // 400\n * ```\n */\nexport function computeIOSContentOffset(\n  relativeScroll: number,\n  keyboardHeight: number,\n  contentHeight: number,\n  layoutHeight: number,\n  inverted: boolean,\n): number {\n  \"worklet\";\n\n  if (inverted) {\n    const maxScroll = Math.max(contentHeight - layoutHeight, 0);\n\n    return Math.max(\n      Math.min(relativeScroll - keyboardHeight, maxScroll),\n      -keyboardHeight,\n    );\n  }\n\n  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);\n\n  return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,yBAAyB;AAIrD,MAAMC,gBAAgB,GAAG,EAAE;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAChCC,MAAc,EACdC,oBAA4B,EAC5BC,MAAc,EACN;EACR,SAAS;;EAET,IAAIA,MAAM,KAAK,CAAC,IAAID,oBAAoB,KAAK,CAAC,EAAE;IAC9C,OAAOD,MAAM;EACf;EAEA,OAAOH,WAAW,CAChBG,MAAM,EACN,CAAC,CAAC,EAAEC,oBAAoB,CAAC,EACzB,CAAC,CAAC,EAAEE,IAAI,CAACC,GAAG,CAACH,oBAAoB,GAAGC,MAAM,EAAE,CAAC,CAAC,CAChD,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,aAAaA,CAC3BC,YAAoB,EACpBC,YAAoB,EACpBC,aAAqB,EACrBC,QAAiB,GAAG,KAAK,EAChB;EACT,SAAS;;EAET,IAAIA,QAAQ,EAAE;IACZ,OAAOH,YAAY,IAAIR,gBAAgB;EACzC;EAEA,OAAOQ,YAAY,GAAGC,YAAY,IAAIC,aAAa,GAAGV,gBAAgB;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASY,kBAAkBA,CAChCC,QAA8B,EAC9BC,OAAgB,EACP;EACT,SAAS;;EAET,QAAQD,QAAQ;IACd,KAAK,QAAQ;MACX,OAAO,IAAI;IACb,KAAK,OAAO;MACV,OAAO,KAAK;IACd,KAAK,WAAW;MACd,OAAOC,OAAO;IAChB,KAAK,YAAY;MACf,OAAO,IAAI;EACf;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CACjCC,kBAA0B,EAC1BC,cAAsB,EACtBP,aAAqB,EACrBD,YAAoB,EACZ;EACR,SAAS;;EAET,MAAMS,SAAS,GAAGb,IAAI,CAACC,GAAG,CAACI,aAAa,GAAGD,YAAY,GAAGQ,cAAc,EAAE,CAAC,CAAC;EAE5E,OAAOZ,IAAI,CAACc,GAAG,CAACd,IAAI,CAACC,GAAG,CAACU,kBAAkB,GAAGC,cAAc,EAAE,CAAC,CAAC,EAAEC,SAAS,CAAC;AAC9E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,uBAAuBA,CACrCC,cAAsB,EACtBJ,cAAsB,EACtBP,aAAqB,EACrBD,YAAoB,EACpBE,QAAiB,EACT;EACR,SAAS;;EAET,IAAIA,QAAQ,EAAE;IACZ,MAAMO,SAAS,GAAGb,IAAI,CAACC,GAAG,CAACI,aAAa,GAAGD,YAAY,EAAE,CAAC,CAAC;IAE3D,OAAOJ,IAAI,CAACC,GAAG,CACbD,IAAI,CAACc,GAAG,CAACE,cAAc,GAAGJ,cAAc,EAAEC,SAAS,CAAC,EACpD,CAACD,cACH,CAAC;EACH;EAEA,MAAMC,SAAS,GAAGb,IAAI,CAACC,GAAG,CAACI,aAAa,GAAGD,YAAY,GAAGQ,cAAc,EAAE,CAAC,CAAC;EAE5E,OAAOZ,IAAI,CAACc,GAAG,CAACd,IAAI,CAACC,GAAG,CAACW,cAAc,GAAGI,cAAc,EAAE,CAAC,CAAC,EAAEH,SAAS,CAAC;AAC1E","ignoreList":[]}
+{"version":3,"names":["interpolate","AT_END_THRESHOLD","getEffectiveHeight","height","targetKeyboardHeight","offset","Math","max","isScrollAtEnd","scrollOffset","layoutHeight","contentHeight","inverted","shouldShiftContent","behavior","isAtEnd","getVisibleMinimumPaddingFraction","blankSpace","min","pastContentEnd","getMinimumPaddingAbsorbed","extraContentPadding","getScrollEffective","rawEffective","minimumPaddingAbsorbed","clampedScrollTarget","offsetBeforeScroll","keyboardHeight","totalPaddingForMaxScroll","paddingForMax","undefined","maxScroll","computeIOSContentOffset","relativeScroll"],"sources":["helpers.ts"],"sourcesContent":["import { interpolate } from \"react-native-reanimated\";\n\nimport type { KeyboardLiftBehavior } from \"./types\";\n\nconst AT_END_THRESHOLD = 20;\n\n/**\n * Map the current keyboard height to an effective height that accounts for a\n * fixed offset (e.g. Bottom safe-area or tab-bar height)..\n *\n * @param height - Current keyboard height.\n * @param targetKeyboardHeight - Full target keyboard height (captured on keyboard open).\n * @param offset - Fixed distance between the scroll-view bottom and the screen bottom.\n * @returns Effective height after subtracting the offset proportionally.\n * @example\n * ```ts\n * getEffectiveHeight(300, 300, 50); // 250\n * getEffectiveHeight(150, 300, 50); // 125\n * ```\n */\nexport const getEffectiveHeight = (\n  height: number,\n  targetKeyboardHeight: number,\n  offset: number,\n): number => {\n  \"worklet\";\n\n  if (offset === 0 || targetKeyboardHeight === 0) {\n    return height;\n  }\n\n  return interpolate(\n    height,\n    [0, targetKeyboardHeight],\n    [0, Math.max(targetKeyboardHeight - offset, 0)],\n  );\n};\n\n/**\n * Check whether the scroll view is at the end of its content.\n *\n * For non-inverted lists the \"end\" is the bottom of the content.\n * For inverted lists the \"end\" is the top (scroll offset near 0),\n * because that is where the latest messages are displayed.\n *\n * @param scrollOffset - Current vertical scroll offset.\n * @param layoutHeight - Visible height of the scroll view.\n * @param contentHeight - Total height of the scrollable content.\n * @param inverted - Whether the list is inverted.\n * @returns `true` if the scroll position is within the threshold of the content end.\n * @example\n * ```ts\n * const atEnd = isScrollAtEnd(100, 800, 920); // true (100 + 800 >= 920 - 20)\n * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)\n * ```\n */\nexport const isScrollAtEnd = (\n  scrollOffset: number,\n  layoutHeight: number,\n  contentHeight: number,\n  inverted: boolean = false,\n): boolean => {\n  \"worklet\";\n\n  if (inverted) {\n    return scrollOffset <= AT_END_THRESHOLD;\n  }\n\n  return scrollOffset + layoutHeight >= contentHeight - AT_END_THRESHOLD;\n};\n\n/**\n * Decide whether content should be shifted based on the keyboard lift behavior.\n *\n * @param behavior - The configured keyboard lift behavior.\n * @param isAtEnd - Whether the scroll view is currently at the end.\n * @returns `true` if content should be shifted.\n * @example\n * ```ts\n * shouldShiftContent(\"always\", false); // true\n * shouldShiftContent(\"whenAtEnd\", false); // false\n * ```\n */\nexport const shouldShiftContent = (\n  behavior: KeyboardLiftBehavior,\n  isAtEnd: boolean,\n): boolean => {\n  \"worklet\";\n\n  switch (behavior) {\n    case \"always\":\n      return true;\n    case \"never\":\n      return false;\n    case \"whenAtEnd\":\n      return isAtEnd;\n    case \"persistent\":\n      return true;\n  }\n};\n\n/**\n * Compute the fraction of minimum padding space currently visible in the viewport (0–1).\n *\n * The minimum padding space lives in the scroll view's contentInset, NOT in the\n * content itself.  So `contentHeight` (from onContentSizeChange / scroll\n * events) does **not** include it.  The visible portion is how far the\n * viewport extends past the content boundary into the inset area.\n *\n * For non-inverted lists the padding is in contentInset.bottom.\n * For inverted lists the padding is in contentInset.top (negative scroll).\n *\n * @param scrollOffset - Current vertical scroll offset.\n * @param layoutHeight - Visible height of the scroll view.\n * @param contentHeight - Height of the scroll content (excludes insets).\n * @param blankSpace - Size of the minimum padding inset area.\n * @param inverted - Whether the list is inverted.\n * @returns A value between 0 (padding fully off-screen) and 1 (padding fully visible).\n * @example\n * ```ts\n * // Non-inverted: contentHeight=1500, layout=800, blankSpace=300\n * getVisibleMinimumPaddingFraction(1500, 800, 1500, 300, false); // 1   (at end, viewport past content)\n * getVisibleMinimumPaddingFraction(850, 800, 1500, 300, false);  // 0.5 (half padding visible)\n * getVisibleMinimumPaddingFraction(700, 800, 1500, 300, false);  // 0   (padding off-screen)\n * ```\n */\nexport const getVisibleMinimumPaddingFraction = (\n  scrollOffset: number,\n  layoutHeight: number,\n  contentHeight: number,\n  blankSpace: number,\n  inverted: boolean,\n): number => {\n  \"worklet\";\n\n  if (blankSpace <= 0) {\n    return 0;\n  }\n\n  if (inverted) {\n    // Minimum padding is in contentInset.top; visible when scroll < 0\n    return Math.max(0, Math.min(1, -scrollOffset / blankSpace));\n  }\n\n  // Minimum padding is in contentInset.bottom; visible when viewport extends past content\n  const pastContentEnd = scrollOffset + layoutHeight - contentHeight;\n\n  return Math.max(0, Math.min(1, pastContentEnd / blankSpace));\n};\n\n/**\n * Compute how much of the minimum content padding absorbs the keyboard + extraContentPadding.\n *\n * @param blankSpace - Minimum inset floor.\n * @param extraContentPadding - Extra content padding from external elements.\n * @returns The portion of blankSpace that absorbs keyboard displacement.\n * @example\n * ```ts\n * getMinimumPaddingAbsorbed(500, 20); // 480\n * getMinimumPaddingAbsorbed(0, 20);   // 0\n * ```\n */\nexport const getMinimumPaddingAbsorbed = (\n  blankSpace: number,\n  extraContentPadding: number,\n): number => {\n  \"worklet\";\n\n  return Math.max(0, blankSpace - extraContentPadding);\n};\n\n/**\n * Compute the effective scroll displacement after minimum padding absorption.\n *\n * @param rawEffective - Raw effective keyboard height.\n * @param minimumPaddingAbsorbed - Amount absorbed by minimum content padding.\n * @returns The scroll displacement after subtracting the absorbed portion.\n * @example\n * ```ts\n * getScrollEffective(300, 200); // 100\n * getScrollEffective(300, 400); // 0\n * ```\n */\nexport const getScrollEffective = (\n  rawEffective: number,\n  minimumPaddingAbsorbed: number,\n): number => {\n  \"worklet\";\n\n  return Math.max(0, rawEffective - minimumPaddingAbsorbed);\n};\n\n/**\n * Compute the clamped scroll target for non-inverted lists.\n *\n * @param offsetBeforeScroll - Scroll position before keyboard appeared.\n * @param keyboardHeight - Current keyboard height (used for scroll displacement).\n * @param contentHeight - Total height of the scrollable content.\n * @param layoutHeight - Visible height of the scroll view.\n * @param totalPaddingForMaxScroll - Total padding to use for maxScroll calculation. When provided, used instead of keyboardHeight for the scrollable range. Defaults to keyboardHeight.\n * @returns Clamped scroll target between 0 and maxScroll.\n * @example\n * ```ts\n * clampedScrollTarget(100, 300, 1000, 800); // 400\n * clampedScrollTarget(100, 100, 1000, 800, 500); // 200, maxScroll uses 500\n * ```\n */\nexport const clampedScrollTarget = (\n  offsetBeforeScroll: number,\n  keyboardHeight: number,\n  contentHeight: number,\n  layoutHeight: number,\n  totalPaddingForMaxScroll?: number,\n): number => {\n  \"worklet\";\n\n  const paddingForMax =\n    totalPaddingForMaxScroll !== undefined\n      ? totalPaddingForMaxScroll\n      : keyboardHeight;\n  const maxScroll = Math.max(contentHeight - layoutHeight + paddingForMax, 0);\n\n  return Math.min(Math.max(offsetBeforeScroll + keyboardHeight, 0), maxScroll);\n};\n\n/**\n * Compute contentOffset.y for iOS lists.\n *\n * @param relativeScroll - Scroll position relative to current inset.\n * @param keyboardHeight - Target keyboard height (used for scroll displacement).\n * @param contentHeight - Total height of the scrollable content.\n * @param layoutHeight - Visible height of the scroll view.\n * @param inverted - Whether the list is inverted.\n * @param totalPaddingForMaxScroll - Total padding to use for maxScroll calculation. When provided, used instead of keyboardHeight for the scrollable range. Defaults to keyboardHeight.\n * @returns The absolute contentOffset.y to set.\n * @example\n * ```ts\n * computeIOSContentOffset(100, 300, 1000, 800, false); // 400\n * ```\n */\nexport const computeIOSContentOffset = (\n  relativeScroll: number,\n  keyboardHeight: number,\n  contentHeight: number,\n  layoutHeight: number,\n  inverted: boolean,\n  totalPaddingForMaxScroll?: number,\n): number => {\n  \"worklet\";\n\n  const paddingForMax =\n    totalPaddingForMaxScroll !== undefined\n      ? totalPaddingForMaxScroll\n      : keyboardHeight;\n\n  if (inverted) {\n    const maxScroll = Math.max(contentHeight - layoutHeight, 0);\n\n    return Math.max(\n      Math.min(relativeScroll - keyboardHeight, maxScroll),\n      -paddingForMax,\n    );\n  }\n\n  const maxScroll = Math.max(contentHeight - layoutHeight + paddingForMax, 0);\n\n  return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/module/components/KeyboardChatScrollView/useChatKeyboard/index.ios.js

@@ -1,7 +1,7 @@
 import { useSharedValue } from "react-native-reanimated";
 import { useKeyboardHandler } from "../../../hooks";
 import useScrollState from "../../hooks/useScrollState";
-import { computeIOSContentOffset, getEffectiveHeight, isScrollAtEnd, shouldShiftContent } from "./helpers";
+import { computeIOSContentOffset, getEffectiveHeight, getScrollEffective, getVisibleMinimumPaddingFraction, isScrollAtEnd, shouldShiftContent } from "./helpers";
 /**
  * Hook that manages keyboard-driven scrolling for chat-style scroll views.
  * Calculates padding (extra scrollable space) and content shift values,
@@ -23,12 +23,15 @@ function useChatKeyboard(scrollViewRef, options) {
     inverted,
     keyboardLiftBehavior,
     freeze,
-    offset
+    offset,
+    blankSpace,
+    extraContentPadding
   } = options;
   const padding = useSharedValue(0);
   const currentHeight = useSharedValue(0);
   const contentOffsetY = useSharedValue(0);
   const targetKeyboardHeight = useSharedValue(0);
+  const prevAbsorption = useSharedValue(0);
   const {
     layout,
     size,
@@ -50,43 +53,65 @@ function useChatKeyboard(scrollViewRef, options) {
       const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
       const atEnd = isScrollAtEnd(scroll.value, layout.value.height, size.value.height, inverted);
 
-      // persistent mode: when keyboard shrinks, snap to end or hold position
+      // Scale minimum padding absorption by how much of it is visible.
+      // Fully visible → full absorption; fully off-screen → no absorption.
+      const visibleFraction = getVisibleMinimumPaddingFraction(scroll.value, layout.value.height, size.value.height, blankSpace.value, inverted);
+      const visiblePadding = visibleFraction * blankSpace.value;
+      const minimumPaddingAbsorbed = Math.max(0, visiblePadding - extraContentPadding.value);
+      const scrollEffective = getScrollEffective(effective, minimumPaddingAbsorbed);
+      const actualTotalPadding = Math.max(blankSpace.value, effective + extraContentPadding.value);
+
+      // persistent mode: when keyboard shrinks, clamp to valid range
       if (keyboardLiftBehavior === "persistent" && effective < padding.value) {
         padding.value = effective;
-        if (atEnd) {
-          if (inverted) {
-            contentOffsetY.value = -effective;
-          } else {
-            contentOffsetY.value = Math.max(size.value.height - layout.value.height + effective, 0);
-          }
+        prevAbsorption.value = minimumPaddingAbsorbed;
+        if (inverted) {
+          const maxScroll = Math.max(size.value.height - layout.value.height, 0);
+          contentOffsetY.value = Math.max(-actualTotalPadding, Math.min(scroll.value, maxScroll));
         } else {
-          // Preserve current scroll position so the animated props
-          // don't re-apply the stale contentOffset from keyboard open
-          contentOffsetY.value = scroll.value;
+          const maxScroll = Math.max(size.value.height - layout.value.height + actualTotalPadding, 0);
+          contentOffsetY.value = Math.max(0, Math.min(scroll.value, maxScroll));
         }
         return;
       }
 
-      // never mode: when keyboard shrinks and at end, snap to end
+      // never mode: when keyboard shrinks, clamp to valid range
       // to avoid ghost padding
       if (keyboardLiftBehavior === "never" && effective < padding.value && atEnd) {
         padding.value = effective;
+        prevAbsorption.value = minimumPaddingAbsorbed;
         if (inverted) {
-          contentOffsetY.value = -effective;
+          const maxScroll = Math.max(size.value.height - layout.value.height, 0);
+          contentOffsetY.value = Math.max(-actualTotalPadding, Math.min(scroll.value, maxScroll));
         } else {
-          contentOffsetY.value = Math.max(size.value.height - layout.value.height + effective, 0);
+          const maxScroll = Math.max(size.value.height - layout.value.height + actualTotalPadding, 0);
+          contentOffsetY.value = Math.max(0, Math.min(scroll.value, maxScroll));
         }
         return;
       }
-      const relativeScroll = inverted ? scroll.value + padding.value : scroll.value - padding.value;
+
+      // Undo only the scroll displacement that was actually applied
+      // (not the full padding, which includes the absorbed portion).
+      // Use the stored absorption from the previous event so that
+      // the unwind matches the shift that was originally applied.
+      const prevScrollEffective = getScrollEffective(padding.value, prevAbsorption.value);
+      const relativeScroll = inverted ? scroll.value + prevScrollEffective : scroll.value - prevScrollEffective;
       padding.value = effective;
+      prevAbsorption.value = minimumPaddingAbsorbed;
       if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {
         // Preserve current scroll position so animated props
         // don't re-apply a stale contentOffset when padding changes
         contentOffsetY.value = scroll.value;
         return;
       }
-      contentOffsetY.value = computeIOSContentOffset(relativeScroll, effective, size.value.height, layout.value.height, inverted);
+
+      // When blankSpace fully absorbs the keyboard opening, preserve current scroll position
+      // (only when keyboard is open — effective > 0 — not when closing)
+      if (scrollEffective === 0 && minimumPaddingAbsorbed > 0 && effective > 0) {
+        contentOffsetY.value = scroll.value;
+        return;
+      }
+      contentOffsetY.value = computeIOSContentOffset(relativeScroll, scrollEffective, size.value.height, layout.value.height, inverted, actualTotalPadding);
     },
     onMove: () => {
       "worklet";
@@ -102,11 +127,14 @@ function useChatKeyboard(scrollViewRef, options) {
       const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
       padding.value = effective;
     }
-  }, [inverted, keyboardLiftBehavior, freeze, offset]);
+  }, [inverted, keyboardLiftBehavior, freeze, offset, extraContentPadding]);
   return {
     padding,
     currentHeight,
     contentOffsetY,
+    scroll,
+    layout,
+    size,
     onLayout,
     onContentSizeChange
   };

package/lib/module/components/KeyboardChatScrollView/useChatKeyboard/index.ios.js.map

@@ -1 +1 @@
-{"version":3,"names":["useSharedValue","useKeyboardHandler","useScrollState","computeIOSContentOffset","getEffectiveHeight","isScrollAtEnd","shouldShiftContent","useChatKeyboard","scrollViewRef","options","inverted","keyboardLiftBehavior","freeze","offset","padding","currentHeight","contentOffsetY","targetKeyboardHeight","layout","size","scroll","onLayout","onContentSizeChange","onStart","e","height","value","effective","atEnd","Math","max","relativeScroll","onMove","onEnd"],"sources":["index.ios.ts"],"sourcesContent":["import { useSharedValue } from \"react-native-reanimated\";\n\nimport { useKeyboardHandler } from \"../../../hooks\";\nimport useScrollState from \"../../hooks/useScrollState\";\n\nimport {\n  computeIOSContentOffset,\n  getEffectiveHeight,\n  isScrollAtEnd,\n  shouldShiftContent,\n} from \"./helpers\";\n\nimport type { UseChatKeyboardOptions, UseChatKeyboardReturn } from \"./types\";\nimport type { AnimatedRef } from \"react-native-reanimated\";\nimport type Reanimated from \"react-native-reanimated\";\n\n/**\n * Hook that manages keyboard-driven scrolling for chat-style scroll views.\n * Calculates padding (extra scrollable space) and content shift values,\n * using iOS-specific strategy (contentOffset set once in onStart).\n *\n * @param scrollViewRef - Animated ref to the scroll view.\n * @param options - Configuration for inverted and keyboardLiftBehavior.\n * @returns Shared values for padding and contentOffsetY.\n * @example\n * ```tsx\n * const { padding, contentOffsetY } = useChatKeyboard(ref, {\n *   inverted: false,\n *   keyboardLiftBehavior: \"always\",\n * });\n * ```\n */\nfunction useChatKeyboard(\n  scrollViewRef: AnimatedRef<Reanimated.ScrollView>,\n  options: UseChatKeyboardOptions,\n): UseChatKeyboardReturn {\n  const { inverted, keyboardLiftBehavior, freeze, offset } = options;\n\n  const padding = useSharedValue(0);\n  const currentHeight = useSharedValue(0);\n  const contentOffsetY = useSharedValue(0);\n  const targetKeyboardHeight = useSharedValue(0);\n\n  const {\n    layout,\n    size,\n    offset: scroll,\n    onLayout,\n    onContentSizeChange,\n  } = useScrollState(scrollViewRef);\n\n  useKeyboardHandler(\n    {\n      onStart: (e) => {\n        \"worklet\";\n\n        if (freeze) {\n          return;\n        }\n\n        if (e.height > 0) {\n          // eslint-disable-next-line react-compiler/react-compiler\n          targetKeyboardHeight.value = e.height;\n        }\n\n        const effective = getEffectiveHeight(\n          e.height,\n          targetKeyboardHeight.value,\n          offset,\n        );\n\n        const atEnd = isScrollAtEnd(\n          scroll.value,\n          layout.value.height,\n          size.value.height,\n          inverted,\n        );\n\n        // persistent mode: when keyboard shrinks, snap to end or hold position\n        if (\n          keyboardLiftBehavior === \"persistent\" &&\n          effective < padding.value\n        ) {\n          padding.value = effective;\n\n          if (atEnd) {\n            if (inverted) {\n              contentOffsetY.value = -effective;\n            } else {\n              contentOffsetY.value = Math.max(\n                size.value.height - layout.value.height + effective,\n                0,\n              );\n            }\n          } else {\n            // Preserve current scroll position so the animated props\n            // don't re-apply the stale contentOffset from keyboard open\n            contentOffsetY.value = scroll.value;\n          }\n\n          return;\n        }\n\n        // never mode: when keyboard shrinks and at end, snap to end\n        // to avoid ghost padding\n        if (\n          keyboardLiftBehavior === \"never\" &&\n          effective < padding.value &&\n          atEnd\n        ) {\n          padding.value = effective;\n\n          if (inverted) {\n            contentOffsetY.value = -effective;\n          } else {\n            contentOffsetY.value = Math.max(\n              size.value.height - layout.value.height + effective,\n              0,\n            );\n          }\n\n          return;\n        }\n\n        const relativeScroll = inverted\n          ? scroll.value + padding.value\n          : scroll.value - padding.value;\n\n        padding.value = effective;\n\n        if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {\n          // Preserve current scroll position so animated props\n          // don't re-apply a stale contentOffset when padding changes\n          contentOffsetY.value = scroll.value;\n\n          return;\n        }\n\n        contentOffsetY.value = computeIOSContentOffset(\n          relativeScroll,\n          effective,\n          size.value.height,\n          layout.value.height,\n          inverted,\n        );\n      },\n      onMove: () => {\n        \"worklet\";\n\n        // iOS doesn't need per-frame updates (contentOffset handles it)\n      },\n      onEnd: (e) => {\n        \"worklet\";\n\n        if (freeze) {\n          return;\n        }\n\n        const effective = getEffectiveHeight(\n          e.height,\n          targetKeyboardHeight.value,\n          offset,\n        );\n\n        padding.value = effective;\n      },\n    },\n    [inverted, keyboardLiftBehavior, freeze, offset],\n  );\n\n  return {\n    padding,\n    currentHeight,\n    contentOffsetY,\n    onLayout,\n    onContentSizeChange,\n  };\n}\n\nexport { useChatKeyboard };\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["useSharedValue","useKeyboardHandler","useScrollState","computeIOSContentOffset","getEffectiveHeight","getScrollEffective","getVisibleMinimumPaddingFraction","isScrollAtEnd","shouldShiftContent","useChatKeyboard","scrollViewRef","options","inverted","keyboardLiftBehavior","freeze","offset","blankSpace","extraContentPadding","padding","currentHeight","contentOffsetY","targetKeyboardHeight","prevAbsorption","layout","size","scroll","onLayout","onContentSizeChange","onStart","e","height","value","effective","atEnd","visibleFraction","visiblePadding","minimumPaddingAbsorbed","Math","max","scrollEffective","actualTotalPadding","maxScroll","min","prevScrollEffective","relativeScroll","onMove","onEnd"],"sources":["index.ios.ts"],"sourcesContent":["import { useSharedValue } from \"react-native-reanimated\";\n\nimport { useKeyboardHandler } from \"../../../hooks\";\nimport useScrollState from \"../../hooks/useScrollState\";\n\nimport {\n  computeIOSContentOffset,\n  getEffectiveHeight,\n  getScrollEffective,\n  getVisibleMinimumPaddingFraction,\n  isScrollAtEnd,\n  shouldShiftContent,\n} from \"./helpers\";\n\nimport type { UseChatKeyboardOptions, UseChatKeyboardReturn } from \"./types\";\nimport type { AnimatedRef } from \"react-native-reanimated\";\nimport type Reanimated from \"react-native-reanimated\";\n\n/**\n * Hook that manages keyboard-driven scrolling for chat-style scroll views.\n * Calculates padding (extra scrollable space) and content shift values,\n * using iOS-specific strategy (contentOffset set once in onStart).\n *\n * @param scrollViewRef - Animated ref to the scroll view.\n * @param options - Configuration for inverted and keyboardLiftBehavior.\n * @returns Shared values for padding and contentOffsetY.\n * @example\n * ```tsx\n * const { padding, contentOffsetY } = useChatKeyboard(ref, {\n *   inverted: false,\n *   keyboardLiftBehavior: \"always\",\n * });\n * ```\n */\nfunction useChatKeyboard(\n  scrollViewRef: AnimatedRef<Reanimated.ScrollView>,\n  options: UseChatKeyboardOptions,\n): UseChatKeyboardReturn {\n  const {\n    inverted,\n    keyboardLiftBehavior,\n    freeze,\n    offset,\n    blankSpace,\n    extraContentPadding,\n  } = options;\n\n  const padding = useSharedValue(0);\n  const currentHeight = useSharedValue(0);\n  const contentOffsetY = useSharedValue(0);\n  const targetKeyboardHeight = useSharedValue(0);\n  const prevAbsorption = useSharedValue(0);\n\n  const {\n    layout,\n    size,\n    offset: scroll,\n    onLayout,\n    onContentSizeChange,\n  } = useScrollState(scrollViewRef);\n\n  useKeyboardHandler(\n    {\n      onStart: (e) => {\n        \"worklet\";\n\n        if (freeze) {\n          return;\n        }\n\n        if (e.height > 0) {\n          // eslint-disable-next-line react-compiler/react-compiler\n          targetKeyboardHeight.value = e.height;\n        }\n\n        const effective = getEffectiveHeight(\n          e.height,\n          targetKeyboardHeight.value,\n          offset,\n        );\n\n        const atEnd = isScrollAtEnd(\n          scroll.value,\n          layout.value.height,\n          size.value.height,\n          inverted,\n        );\n\n        // Scale minimum padding absorption by how much of it is visible.\n        // Fully visible → full absorption; fully off-screen → no absorption.\n        const visibleFraction = getVisibleMinimumPaddingFraction(\n          scroll.value,\n          layout.value.height,\n          size.value.height,\n          blankSpace.value,\n          inverted,\n        );\n        const visiblePadding = visibleFraction * blankSpace.value;\n        const minimumPaddingAbsorbed = Math.max(\n          0,\n          visiblePadding - extraContentPadding.value,\n        );\n        const scrollEffective = getScrollEffective(\n          effective,\n          minimumPaddingAbsorbed,\n        );\n        const actualTotalPadding = Math.max(\n          blankSpace.value,\n          effective + extraContentPadding.value,\n        );\n\n        // persistent mode: when keyboard shrinks, clamp to valid range\n        if (\n          keyboardLiftBehavior === \"persistent\" &&\n          effective < padding.value\n        ) {\n          padding.value = effective;\n          prevAbsorption.value = minimumPaddingAbsorbed;\n\n          if (inverted) {\n            const maxScroll = Math.max(\n              size.value.height - layout.value.height,\n              0,\n            );\n\n            contentOffsetY.value = Math.max(\n              -actualTotalPadding,\n              Math.min(scroll.value, maxScroll),\n            );\n          } else {\n            const maxScroll = Math.max(\n              size.value.height - layout.value.height + actualTotalPadding,\n              0,\n            );\n\n            contentOffsetY.value = Math.max(\n              0,\n              Math.min(scroll.value, maxScroll),\n            );\n          }\n\n          return;\n        }\n\n        // never mode: when keyboard shrinks, clamp to valid range\n        // to avoid ghost padding\n        if (\n          keyboardLiftBehavior === \"never\" &&\n          effective < padding.value &&\n          atEnd\n        ) {\n          padding.value = effective;\n          prevAbsorption.value = minimumPaddingAbsorbed;\n\n          if (inverted) {\n            const maxScroll = Math.max(\n              size.value.height - layout.value.height,\n              0,\n            );\n\n            contentOffsetY.value = Math.max(\n              -actualTotalPadding,\n              Math.min(scroll.value, maxScroll),\n            );\n          } else {\n            const maxScroll = Math.max(\n              size.value.height - layout.value.height + actualTotalPadding,\n              0,\n            );\n\n            contentOffsetY.value = Math.max(\n              0,\n              Math.min(scroll.value, maxScroll),\n            );\n          }\n\n          return;\n        }\n\n        // Undo only the scroll displacement that was actually applied\n        // (not the full padding, which includes the absorbed portion).\n        // Use the stored absorption from the previous event so that\n        // the unwind matches the shift that was originally applied.\n        const prevScrollEffective = getScrollEffective(\n          padding.value,\n          prevAbsorption.value,\n        );\n        const relativeScroll = inverted\n          ? scroll.value + prevScrollEffective\n          : scroll.value - prevScrollEffective;\n\n        padding.value = effective;\n        prevAbsorption.value = minimumPaddingAbsorbed;\n\n        if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {\n          // Preserve current scroll position so animated props\n          // don't re-apply a stale contentOffset when padding changes\n          contentOffsetY.value = scroll.value;\n\n          return;\n        }\n\n        // When blankSpace fully absorbs the keyboard opening, preserve current scroll position\n        // (only when keyboard is open — effective > 0 — not when closing)\n        if (\n          scrollEffective === 0 &&\n          minimumPaddingAbsorbed > 0 &&\n          effective > 0\n        ) {\n          contentOffsetY.value = scroll.value;\n\n          return;\n        }\n\n        contentOffsetY.value = computeIOSContentOffset(\n          relativeScroll,\n          scrollEffective,\n          size.value.height,\n          layout.value.height,\n          inverted,\n          actualTotalPadding,\n        );\n      },\n      onMove: () => {\n        \"worklet\";\n\n        // iOS doesn't need per-frame updates (contentOffset handles it)\n      },\n      onEnd: (e) => {\n        \"worklet\";\n\n        if (freeze) {\n          return;\n        }\n\n        const effective = getEffectiveHeight(\n          e.height,\n          targetKeyboardHeight.value,\n          offset,\n        );\n\n        padding.value = effective;\n      },\n    },\n    [inverted, keyboardLiftBehavior, freeze, offset, extraContentPadding],\n  );\n\n  return {\n    padding,\n    currentHeight,\n    contentOffsetY,\n    scroll,\n    layout,\n    size,\n    onLayout,\n    onContentSizeChange,\n  };\n}\n\nexport { useChatKeyboard };\n"],"mappings":"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","ignoreList":[]}

package/lib/module/components/KeyboardChatScrollView/useChatKeyboard/index.js

@@ -1,7 +1,7 @@
 import { scrollTo, useSharedValue } from "react-native-reanimated";
 import { useKeyboardHandler } from "../../../hooks";
 import useScrollState from "../../hooks/useScrollState";
-import { clampedScrollTarget, getEffectiveHeight, isScrollAtEnd, shouldShiftContent } from "./helpers";
+import { clampedScrollTarget, getEffectiveHeight, getMinimumPaddingAbsorbed, getScrollEffective, getVisibleMinimumPaddingFraction, isScrollAtEnd, shouldShiftContent } from "./helpers";
 /**
  * Hook that manages keyboard-driven scrolling for chat-style scroll views.
  * Calculates padding (extra scrollable space) and content shift values,
@@ -12,10 +12,7 @@ import { clampedScrollTarget, getEffectiveHeight, isScrollAtEnd, shouldShiftCont
  * @returns Shared values for padding and contentOffsetY (always `undefined`).
  * @example
  * ```tsx
- * const { padding, contentOffsetY } = useChatKeyboard(ref, {
- *   inverted: false,
- *   keyboardLiftBehavior: "always",
- * });
+ * const { padding } = useChatKeyboard(ref, { inverted: false, keyboardLiftBehavior: "always" });
  * ```
  */
 function useChatKeyboard(scrollViewRef, options) {
@@ -23,13 +20,17 @@ function useChatKeyboard(scrollViewRef, options) {
     inverted,
     keyboardLiftBehavior,
     freeze,
-    offset
+    offset,
+    blankSpace,
+    extraContentPadding
   } = options;
   const padding = useSharedValue(0);
   const currentHeight = useSharedValue(0);
   const offsetBeforeScroll = useSharedValue(0);
   const targetKeyboardHeight = useSharedValue(0);
   const closing = useSharedValue(false);
+  const minimumPaddingFractionOnOpen = useSharedValue(0);
+  const actualOpenShift = useSharedValue(0);
   const {
     layout,
     size,
@@ -37,10 +38,11 @@ function useChatKeyboard(scrollViewRef, options) {
     onLayout,
     onContentSizeChange
   } = useScrollState(scrollViewRef);
-  const clampScrollIfNeeded = effective => {
+  const clampScrollIfNeeded = (effective, totalPaddingForMaxScroll) => {
     "worklet";
 
-    const maxScroll = Math.max(size.value.height - layout.value.height + effective, 0);
+    const paddingForMax = totalPaddingForMaxScroll !== undefined ? totalPaddingForMaxScroll : effective;
+    const maxScroll = Math.max(size.value.height - layout.value.height + paddingForMax, 0);
     if (scroll.value > maxScroll) {
       scrollTo(scrollViewRef, 0, maxScroll, false);
     }
@@ -61,6 +63,12 @@ function useChatKeyboard(scrollViewRef, options) {
       }
       const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
       const atEnd = isScrollAtEnd(scroll.value, layout.value.height, size.value.height, inverted);
+
+      // Scale minimum padding absorption by how much of it is visible.
+      // Fully visible → full absorption; fully off-screen → no absorption.
+      const visibleFraction = getVisibleMinimumPaddingFraction(scroll.value, layout.value.height, size.value.height, blankSpace.value, inverted);
+      const minimumPaddingAbsorbed = visibleFraction >= 1 ? getMinimumPaddingAbsorbed(blankSpace.value, extraContentPadding.value) : 0;
+      const scrollEffective = getScrollEffective(effective, minimumPaddingAbsorbed);
       if (inverted && e.duration === -1) {
         // Android inverted: skip post-interactive snap-back events
         // (duration === -1 means the keyboard is re-establishing its
@@ -68,11 +76,18 @@ function useChatKeyboard(scrollViewRef, options) {
         return;
       } else if (e.height > 0) {
         // Android: keyboard opening — set padding + capture scroll position
+        minimumPaddingFractionOnOpen.value = visibleFraction >= 1 ? 1 : 0;
         padding.value = effective;
         offsetBeforeScroll.value = scroll.value;
         if (!inverted && keyboardLiftBehavior === "whenAtEnd" && !atEnd) {
           // Sentinel: don't scroll in onMove (non-inverted only)
           offsetBeforeScroll.value = -1;
+        } else if (!inverted && scrollEffective === 0) {
+          // blankSpace fully absorbs the keyboard — prevent scroll
+          offsetBeforeScroll.value = -1;
+        } else if (inverted && scrollEffective === 0) {
+          // blankSpace fully absorbs the keyboard — guard for inverted
+          offsetBeforeScroll.value = scroll.value;
         }
       } else {
         // Android: keyboard closing — re-capture scroll position
@@ -81,9 +96,9 @@ function useChatKeyboard(scrollViewRef, options) {
         } else {
           // Preserve "whenAtEnd" sentinel: if open didn't shift, close shouldn't either
           if (offsetBeforeScroll.value !== -1) {
-            // Non-inverted: subtract padding to get the "natural" position
-            // so onMove smoothly scrolls back from where the user is now
-            offsetBeforeScroll.value = scroll.value - padding.value;
+            // Use the actual displacement recorded at end of open animation
+            // (not the theoretical value) so close is symmetric with open
+            offsetBeforeScroll.value = scroll.value - actualOpenShift.value;
           }
         }
       }
@@ -101,6 +116,9 @@ function useChatKeyboard(scrollViewRef, options) {
           return;
         }
         const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
+        const minimumPaddingAbsorbed = getMinimumPaddingAbsorbed(blankSpace.value, extraContentPadding.value) * minimumPaddingFractionOnOpen.value;
+        const scrollEffective = getScrollEffective(effective, minimumPaddingAbsorbed);
+        const actualTotalPadding = Math.max(blankSpace.value, effective + extraContentPadding.value);
 
         // Check if we should shift content based on position when keyboard started
         const wasAtEnd = isScrollAtEnd(offsetBeforeScroll.value, layout.value.height, size.value.height, inverted);
@@ -108,6 +126,9 @@ function useChatKeyboard(scrollViewRef, options) {
         // "never" at end: scroll along when keyboard closes to avoid jump
         if (keyboardLiftBehavior === "never" && wasAtEnd && effective < padding.value) {
           padding.value = effective;
+          if (scrollEffective === 0 && minimumPaddingAbsorbed > 0) {
+            return;
+          }
           scrollTo(scrollViewRef, 0, 0, false);
           return;
         }
@@ -115,11 +136,16 @@ function useChatKeyboard(scrollViewRef, options) {
           // Closing, not shifting: reduce padding to avoid gap
           if (closing.value && effective < padding.value) {
             padding.value = effective;
-            clampScrollIfNeeded(effective);
+            clampScrollIfNeeded(effective, actualTotalPadding);
           }
           return;
         }
 
+        // When blankSpace fully absorbs the keyboard, skip scroll
+        if (scrollEffective === 0 && minimumPaddingAbsorbed > 0) {
+          return;
+        }
+
         // Persistent: don't let shift decrease
         if (keyboardLiftBehavior === "persistent") {
           const currentShift = offsetBeforeScroll.value + padding.value - scroll.value;
@@ -131,37 +157,33 @@ function useChatKeyboard(scrollViewRef, options) {
             } else if (closing.value) {
               // Not at end: reduce padding to avoid gap
               padding.value = effective;
-              clampScrollIfNeeded(effective);
+              clampScrollIfNeeded(effective, actualTotalPadding);
             }
             return;
           }
         }
-        const target = offsetBeforeScroll.value + padding.value - effective;
+        const target = offsetBeforeScroll.value + padding.value - scrollEffective;
         scrollTo(scrollViewRef, 0, target, false);
       } else {
         const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
+        const minimumPaddingAbsorbed = getMinimumPaddingAbsorbed(blankSpace.value, extraContentPadding.value) * minimumPaddingFractionOnOpen.value;
+        const scrollEffective = getScrollEffective(effective, minimumPaddingAbsorbed);
+        const actualTotalPadding = Math.max(blankSpace.value, effective + extraContentPadding.value);
 
-        // "never" closing: scroll along when at end to avoid jump
+        // "never" closing: clamp scroll to valid range as inset shrinks
         if (keyboardLiftBehavior === "never" && closing.value && effective < padding.value) {
-          const wasAtEnd = isScrollAtEnd(offsetBeforeScroll.value + padding.value, layout.value.height, size.value.height, false);
-          if (wasAtEnd) {
-            const target = clampedScrollTarget(offsetBeforeScroll.value, effective, size.value.height, layout.value.height);
-            scrollTo(scrollViewRef, 0, target, false);
-          } else {
-            // Clamp to valid range as padding shrinks
-            clampScrollIfNeeded(effective);
-          }
+          clampScrollIfNeeded(effective, actualTotalPadding);
           return;
         }
         if (!shouldShiftContent(keyboardLiftBehavior, true)) {
           return;
         }
 
-        // "whenAtEnd" sentinel check
+        // "whenAtEnd" sentinel check (also used for blankSpace full absorption)
         if (offsetBeforeScroll.value === -1) {
           if (closing.value) {
             // Keyboard didn't shift on open; ensure valid position on close
-            clampScrollIfNeeded(effective);
+            clampScrollIfNeeded(effective, actualTotalPadding);
           }
           return;
         }
@@ -169,12 +191,17 @@ function useChatKeyboard(scrollViewRef, options) {
         // "persistent" closing: maintain position, clamped to valid range
         if (keyboardLiftBehavior === "persistent" && closing.value) {
           const keepAt = offsetBeforeScroll.value + padding.value;
-          const maxScroll = Math.max(size.value.height - layout.value.height + effective, 0);
+          const maxScroll = Math.max(size.value.height - layout.value.height + actualTotalPadding, 0);
           scrollTo(scrollViewRef, 0, Math.min(keepAt, maxScroll), false);
           return;
         }
-        const target = clampedScrollTarget(offsetBeforeScroll.value, effective, size.value.height, layout.value.height);
+        const target = clampedScrollTarget(offsetBeforeScroll.value, scrollEffective, size.value.height, layout.value.height, actualTotalPadding);
         scrollTo(scrollViewRef, 0, target, false);
+
+        // Track actual (clamped) displacement during open for symmetric close
+        if (!closing.value) {
+          actualOpenShift.value = target - offsetBeforeScroll.value;
+        }
       }
     },
     onEnd: e => {
@@ -185,12 +212,20 @@ function useChatKeyboard(scrollViewRef, options) {
       }
       const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
       padding.value = effective;
+
+      // Record actual scroll displacement so close can be symmetric
+      if (effective > 0 && offsetBeforeScroll.value !== -1) {
+        actualOpenShift.value = scroll.value - offsetBeforeScroll.value;
+      }
     }
   }, [inverted, keyboardLiftBehavior, freeze, offset]);
   return {
     padding,
     currentHeight,
     contentOffsetY: undefined,
+    scroll,
+    layout,
+    size,
     onLayout,
     onContentSizeChange
   };