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

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

@@ -3,17 +3,13 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.clampedScrollTarget = clampedScrollTarget;
-exports.computeIOSContentOffset = computeIOSContentOffset;
-exports.getEffectiveHeight = getEffectiveHeight;
-exports.isScrollAtEnd = isScrollAtEnd;
-exports.shouldShiftContent = shouldShiftContent;
+exports.shouldShiftContent = exports.isScrollAtEnd = exports.getVisibleMinimumPaddingFraction = exports.getScrollEffective = exports.getMinimumPaddingAbsorbed = exports.getEffectiveHeight = exports.computeIOSContentOffset = exports.clampedScrollTarget = void 0;
 var _reactNativeReanimated = require("react-native-reanimated");
 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).
@@ -25,14 +21,14 @@ const AT_END_THRESHOLD = 20;
  * getEffectiveHeight(150, 300, 50); // 125
  * ```
  */
-function getEffectiveHeight(height, targetKeyboardHeight, offset) {
+const getEffectiveHeight = (height, targetKeyboardHeight, offset) => {
   "worklet";
 
   if (offset === 0 || targetKeyboardHeight === 0) {
     return height;
   }
   return (0, _reactNativeReanimated.interpolate)(height, [0, targetKeyboardHeight], [0, Math.max(targetKeyboardHeight - offset, 0)]);
-}
+};
 
 /**
  * Check whether the scroll view is at the end of its content.
@@ -52,14 +48,15 @@ function getEffectiveHeight(height, targetKeyboardHeight, offset) {
  * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)
  * ```
  */
-function isScrollAtEnd(scrollOffset, layoutHeight, contentHeight, inverted = false) {
+exports.getEffectiveHeight = getEffectiveHeight;
+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.
@@ -73,7 +70,8 @@ function isScrollAtEnd(scrollOffset, layoutHeight, contentHeight, inverted = fal
  * shouldShiftContent("whenAtEnd", false); // false
  * ```
  */
-function shouldShiftContent(behavior, isAtEnd) {
+exports.isScrollAtEnd = isScrollAtEnd;
+const shouldShiftContent = (behavior, isAtEnd) => {
   "worklet";
 
   switch (behavior) {
@@ -86,50 +84,138 @@ 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)
+ * ```
+ */
+exports.shouldShiftContent = shouldShiftContent;
+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
+ * ```
+ */
+exports.getVisibleMinimumPaddingFraction = getVisibleMinimumPaddingFraction;
+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
+ * ```
+ */
+exports.getMinimumPaddingAbsorbed = getMinimumPaddingAbsorbed;
+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
  * ```
  */
-function clampedScrollTarget(offsetBeforeScroll, keyboardHeight, contentHeight, layoutHeight) {
+exports.getScrollEffective = getScrollEffective;
+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
  * ```
  */
-function computeIOSContentOffset(relativeScroll, keyboardHeight, contentHeight, layoutHeight, inverted) {
+exports.clampedScrollTarget = clampedScrollTarget;
+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);
-}
+};
+exports.computeIOSContentOffset = computeIOSContentOffset;
 //# sourceMappingURL=helpers.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeReanimated","require","AT_END_THRESHOLD","getEffectiveHeight","height","targetKeyboardHeight","offset","interpolate","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,IAAAA,sBAAA,GAAAC,OAAA;AAIA,MAAMC,gBAAgB,GAAG,EAAE;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,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,OAAO,IAAAG,kCAAW,EAChBH,MAAM,EACN,CAAC,CAAC,EAAEC,oBAAoB,CAAC,EACzB,CAAC,CAAC,EAAEG,IAAI,CAACC,GAAG,CAACJ,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;AACO,SAASI,aAAaA,CAC3BC,YAAoB,EACpBC,YAAoB,EACpBC,aAAqB,EACrBC,QAAiB,GAAG,KAAK,EAChB;EACT,SAAS;;EAET,IAAIA,QAAQ,EAAE;IACZ,OAAOH,YAAY,IAAIT,gBAAgB;EACzC;EAEA,OAAOS,YAAY,GAAGC,YAAY,IAAIC,aAAa,GAAGX,gBAAgB;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASa,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;AACO,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;AACO,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":["_reactNativeReanimated","require","AT_END_THRESHOLD","getEffectiveHeight","height","targetKeyboardHeight","offset","interpolate","Math","max","exports","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/commonjs/components/KeyboardChatScrollView/useChatKeyboard/index.ios.js

@@ -30,12 +30,15 @@ function useChatKeyboard(scrollViewRef, options) {
     inverted,
     keyboardLiftBehavior,
     freeze,
-    offset
+    offset,
+    blankSpace,
+    extraContentPadding
   } = options;
   const padding = (0, _reactNativeReanimated.useSharedValue)(0);
   const currentHeight = (0, _reactNativeReanimated.useSharedValue)(0);
   const contentOffsetY = (0, _reactNativeReanimated.useSharedValue)(0);
   const targetKeyboardHeight = (0, _reactNativeReanimated.useSharedValue)(0);
+  const prevAbsorption = (0, _reactNativeReanimated.useSharedValue)(0);
   const {
     layout,
     size,
@@ -57,43 +60,65 @@ function useChatKeyboard(scrollViewRef, options) {
       const effective = (0, _helpers.getEffectiveHeight)(e.height, targetKeyboardHeight.value, offset);
       const atEnd = (0, _helpers.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 = (0, _helpers.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 = (0, _helpers.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 = (0, _helpers.getScrollEffective)(padding.value, prevAbsorption.value);
+      const relativeScroll = inverted ? scroll.value + prevScrollEffective : scroll.value - prevScrollEffective;
       padding.value = effective;
+      prevAbsorption.value = minimumPaddingAbsorbed;
       if (!(0, _helpers.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 = (0, _helpers.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 = (0, _helpers.computeIOSContentOffset)(relativeScroll, scrollEffective, size.value.height, layout.value.height, inverted, actualTotalPadding);
     },
     onMove: () => {
       "worklet";
@@ -109,11 +134,14 @@ function useChatKeyboard(scrollViewRef, options) {
       const effective = (0, _helpers.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/commonjs/components/KeyboardChatScrollView/useChatKeyboard/index.ios.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeReanimated","require","_hooks","_useScrollState","_interopRequireDefault","_helpers","e","__esModule","default","useChatKeyboard","scrollViewRef","options","inverted","keyboardLiftBehavior","freeze","offset","padding","useSharedValue","currentHeight","contentOffsetY","targetKeyboardHeight","layout","size","scroll","onLayout","onContentSizeChange","useScrollState","useKeyboardHandler","onStart","height","value","effective","getEffectiveHeight","atEnd","isScrollAtEnd","Math","max","relativeScroll","shouldShiftContent","computeIOSContentOffset","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":["_reactNativeReanimated","require","_hooks","_useScrollState","_interopRequireDefault","_helpers","e","__esModule","default","useChatKeyboard","scrollViewRef","options","inverted","keyboardLiftBehavior","freeze","offset","blankSpace","extraContentPadding","padding","useSharedValue","currentHeight","contentOffsetY","targetKeyboardHeight","prevAbsorption","layout","size","scroll","onLayout","onContentSizeChange","useScrollState","useKeyboardHandler","onStart","height","value","effective","getEffectiveHeight","atEnd","isScrollAtEnd","visibleFraction","getVisibleMinimumPaddingFraction","visiblePadding","minimumPaddingAbsorbed","Math","max","scrollEffective","getScrollEffective","actualTotalPadding","maxScroll","min","prevScrollEffective","relativeScroll","shouldShiftContent","computeIOSContentOffset","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/commonjs/components/KeyboardChatScrollView/useChatKeyboard/index.js

@@ -19,10 +19,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * @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) {
@@ -30,13 +27,17 @@ function useChatKeyboard(scrollViewRef, options) {
     inverted,
     keyboardLiftBehavior,
     freeze,
-    offset
+    offset,
+    blankSpace,
+    extraContentPadding
   } = options;
   const padding = (0, _reactNativeReanimated.useSharedValue)(0);
   const currentHeight = (0, _reactNativeReanimated.useSharedValue)(0);
   const offsetBeforeScroll = (0, _reactNativeReanimated.useSharedValue)(0);
   const targetKeyboardHeight = (0, _reactNativeReanimated.useSharedValue)(0);
   const closing = (0, _reactNativeReanimated.useSharedValue)(false);
+  const minimumPaddingFractionOnOpen = (0, _reactNativeReanimated.useSharedValue)(0);
+  const actualOpenShift = (0, _reactNativeReanimated.useSharedValue)(0);
   const {
     layout,
     size,
@@ -44,10 +45,11 @@ function useChatKeyboard(scrollViewRef, options) {
     onLayout,
     onContentSizeChange
   } = (0, _useScrollState.default)(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) {
       (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, maxScroll, false);
     }
@@ -68,6 +70,12 @@ function useChatKeyboard(scrollViewRef, options) {
       }
       const effective = (0, _helpers.getEffectiveHeight)(e.height, targetKeyboardHeight.value, offset);
       const atEnd = (0, _helpers.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 = (0, _helpers.getVisibleMinimumPaddingFraction)(scroll.value, layout.value.height, size.value.height, blankSpace.value, inverted);
+      const minimumPaddingAbsorbed = visibleFraction >= 1 ? (0, _helpers.getMinimumPaddingAbsorbed)(blankSpace.value, extraContentPadding.value) : 0;
+      const scrollEffective = (0, _helpers.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
@@ -75,11 +83,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
@@ -88,9 +103,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;
           }
         }
       }
@@ -108,6 +123,9 @@ function useChatKeyboard(scrollViewRef, options) {
           return;
         }
         const effective = (0, _helpers.getEffectiveHeight)(e.height, targetKeyboardHeight.value, offset);
+        const minimumPaddingAbsorbed = (0, _helpers.getMinimumPaddingAbsorbed)(blankSpace.value, extraContentPadding.value) * minimumPaddingFractionOnOpen.value;
+        const scrollEffective = (0, _helpers.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 = (0, _helpers.isScrollAtEnd)(offsetBeforeScroll.value, layout.value.height, size.value.height, inverted);
@@ -115,6 +133,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;
+          }
           (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, 0, false);
           return;
         }
@@ -122,11 +143,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;
@@ -138,37 +164,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;
         (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, target, false);
       } else {
         const effective = (0, _helpers.getEffectiveHeight)(e.height, targetKeyboardHeight.value, offset);
+        const minimumPaddingAbsorbed = (0, _helpers.getMinimumPaddingAbsorbed)(blankSpace.value, extraContentPadding.value) * minimumPaddingFractionOnOpen.value;
+        const scrollEffective = (0, _helpers.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 = (0, _helpers.isScrollAtEnd)(offsetBeforeScroll.value + padding.value, layout.value.height, size.value.height, false);
-          if (wasAtEnd) {
-            const target = (0, _helpers.clampedScrollTarget)(offsetBeforeScroll.value, effective, size.value.height, layout.value.height);
-            (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, target, false);
-          } else {
-            // Clamp to valid range as padding shrinks
-            clampScrollIfNeeded(effective);
-          }
+          clampScrollIfNeeded(effective, actualTotalPadding);
           return;
         }
         if (!(0, _helpers.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;
         }
@@ -176,12 +198,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);
           (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, Math.min(keepAt, maxScroll), false);
           return;
         }
-        const target = (0, _helpers.clampedScrollTarget)(offsetBeforeScroll.value, effective, size.value.height, layout.value.height);
+        const target = (0, _helpers.clampedScrollTarget)(offsetBeforeScroll.value, scrollEffective, size.value.height, layout.value.height, actualTotalPadding);
         (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, target, false);
+
+        // Track actual (clamped) displacement during open for symmetric close
+        if (!closing.value) {
+          actualOpenShift.value = target - offsetBeforeScroll.value;
+        }
       }
     },
     onEnd: e => {
@@ -192,12 +219,20 @@ function useChatKeyboard(scrollViewRef, options) {
       }
       const effective = (0, _helpers.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
   };