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

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

@@ -0,0 +1,221 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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)..
+ *
+ * @param height - Current keyboard height.
+ * @param targetKeyboardHeight - Full target keyboard height (captured on keyboard open).
+ * @param offset - Fixed distance between the scroll-view bottom and the screen bottom.
+ * @returns Effective height after subtracting the offset proportionally.
+ * @example
+ * ```ts
+ * getEffectiveHeight(300, 300, 50); // 250
+ * getEffectiveHeight(150, 300, 50); // 125
+ * ```
+ */
+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.
+ *
+ * For non-inverted lists the "end" is the bottom of the content.
+ * For inverted lists the "end" is the top (scroll offset near 0),
+ * because that is where the latest messages are displayed.
+ *
+ * @param scrollOffset - Current vertical scroll offset.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param contentHeight - Total height of the scrollable content.
+ * @param inverted - Whether the list is inverted.
+ * @returns `true` if the scroll position is within the threshold of the content end.
+ * @example
+ * ```ts
+ * const atEnd = isScrollAtEnd(100, 800, 920); // true (100 + 800 >= 920 - 20)
+ * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)
+ * ```
+ */
+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.
+ *
+ * @param behavior - The configured keyboard lift behavior.
+ * @param isAtEnd - Whether the scroll view is currently at the end.
+ * @returns `true` if content should be shifted.
+ * @example
+ * ```ts
+ * shouldShiftContent("always", false); // true
+ * shouldShiftContent("whenAtEnd", false); // false
+ * ```
+ */
+exports.isScrollAtEnd = isScrollAtEnd;
+const shouldShiftContent = (behavior, isAtEnd) => {
+  "worklet";
+
+  switch (behavior) {
+    case "always":
+      return true;
+    case "never":
+      return false;
+    case "whenAtEnd":
+      return 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 (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
+ * ```
+ */
+exports.getScrollEffective = getScrollEffective;
+const clampedScrollTarget = (offsetBeforeScroll, keyboardHeight, contentHeight, layoutHeight, totalPaddingForMaxScroll) => {
+  "worklet";
+
+  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 (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
+ * ```
+ */
+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), -paddingForMax);
+  }
+  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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChatKeyboard = useChatKeyboard;
+var _reactNativeReanimated = require("react-native-reanimated");
+var _hooks = require("../../../hooks");
+var _useScrollState = _interopRequireDefault(require("../../hooks/useScrollState"));
+var _helpers = require("./helpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * using iOS-specific strategy (contentOffset set once in onStart).
+ *
+ * @param scrollViewRef - Animated ref to the scroll view.
+ * @param options - Configuration for inverted and keyboardLiftBehavior.
+ * @returns Shared values for padding and contentOffsetY.
+ * @example
+ * ```tsx
+ * const { padding, contentOffsetY } = useChatKeyboard(ref, {
+ *   inverted: false,
+ *   keyboardLiftBehavior: "always",
+ * });
+ * ```
+ */
+function useChatKeyboard(scrollViewRef, options) {
+  const {
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+    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,
+    offset: scroll,
+    onLayout,
+    onContentSizeChange
+  } = (0, _useScrollState.default)(scrollViewRef);
+  (0, _hooks.useKeyboardHandler)({
+    onStart: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      if (e.height > 0) {
+        // eslint-disable-next-line react-compiler/react-compiler
+        targetKeyboardHeight.value = e.height;
+      }
+      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 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;
+        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 {
+          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, clamp to valid range
+      // to avoid ghost padding
+      if (keyboardLiftBehavior === "never" && effective < padding.value && atEnd) {
+        padding.value = effective;
+        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 {
+          const maxScroll = Math.max(size.value.height - layout.value.height + actualTotalPadding, 0);
+          contentOffsetY.value = Math.max(0, Math.min(scroll.value, maxScroll));
+        }
+        return;
+      }
+
+      // 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;
+      }
+
+      // 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";
+
+      // iOS doesn't need per-frame updates (contentOffset handles it)
+    },
+    onEnd: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      const effective = (0, _helpers.getEffectiveHeight)(e.height, targetKeyboardHeight.value, offset);
+      padding.value = effective;
+    }
+  }, [inverted, keyboardLiftBehavior, freeze, offset, extraContentPadding]);
+  return {
+    padding,
+    currentHeight,
+    contentOffsetY,
+    scroll,
+    layout,
+    size,
+    onLayout,
+    onContentSizeChange
+  };
+}
+//# sourceMappingURL=index.ios.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,240 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChatKeyboard = useChatKeyboard;
+var _reactNativeReanimated = require("react-native-reanimated");
+var _hooks = require("../../../hooks");
+var _useScrollState = _interopRequireDefault(require("../../hooks/useScrollState"));
+var _helpers = require("./helpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * using per-frame scrollTo updates (Android and other platforms).
+ *
+ * @param scrollViewRef - Animated ref to the scroll view.
+ * @param options - Configuration for inverted and keyboardLiftBehavior.
+ * @returns Shared values for padding and contentOffsetY (always `undefined`).
+ * @example
+ * ```tsx
+ * const { padding } = useChatKeyboard(ref, { inverted: false, keyboardLiftBehavior: "always" });
+ * ```
+ */
+function useChatKeyboard(scrollViewRef, options) {
+  const {
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+    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,
+    offset: scroll,
+    onLayout,
+    onContentSizeChange
+  } = (0, _useScrollState.default)(scrollViewRef);
+  const clampScrollIfNeeded = (effective, totalPaddingForMaxScroll) => {
+    "worklet";
+
+    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);
+    }
+  };
+  (0, _hooks.useKeyboardHandler)({
+    onStart: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      if (e.height > 0) {
+        // eslint-disable-next-line react-compiler/react-compiler
+        targetKeyboardHeight.value = e.height;
+        closing.value = false;
+      } else {
+        closing.value = true;
+      }
+      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
+        // position after an interactive gesture, not a real animation)
+        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
+        if (inverted) {
+          offsetBeforeScroll.value = scroll.value;
+        } else {
+          // Preserve "whenAtEnd" sentinel: if open didn't shift, close shouldn't either
+          if (offsetBeforeScroll.value !== -1) {
+            // 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;
+          }
+        }
+      }
+    },
+    onMove: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      currentHeight.value = e.height;
+      if (inverted) {
+        // Skip post-interactive snap-back (duration === -1)
+        if (e.duration === -1) {
+          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);
+
+        // "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;
+        }
+        if (!(0, _helpers.shouldShiftContent)(keyboardLiftBehavior, wasAtEnd)) {
+          // Closing, not shifting: reduce padding to avoid gap
+          if (closing.value && effective < padding.value) {
+            padding.value = 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;
+          if (effective < currentShift) {
+            // When at end, allow scrolling back (snap to end + reduce padding)
+            if (wasAtEnd) {
+              padding.value = effective;
+              (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, 0, false);
+            } else if (closing.value) {
+              // Not at end: reduce padding to avoid gap
+              padding.value = effective;
+              clampScrollIfNeeded(effective, actualTotalPadding);
+            }
+            return;
+          }
+        }
+        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: clamp scroll to valid range as inset shrinks
+        if (keyboardLiftBehavior === "never" && closing.value && effective < padding.value) {
+          clampScrollIfNeeded(effective, actualTotalPadding);
+          return;
+        }
+        if (!(0, _helpers.shouldShiftContent)(keyboardLiftBehavior, true)) {
+          return;
+        }
+
+        // "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, actualTotalPadding);
+          }
+          return;
+        }
+
+        // "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 + actualTotalPadding, 0);
+          (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, Math.min(keepAt, maxScroll), false);
+          return;
+        }
+        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 => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      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
+  };
+}
+//# sourceMappingURL=index.js.map