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

package/ios/animations/KeyboardAnimation.swift

@@ -26,7 +26,7 @@ public class KeyboardAnimation: KeyboardAnimationProtocol {
   let duration: Double
   let speed: Double
   let timestamp: CFTimeInterval
-  /// internal state
+  // internal state
   var lastValue: Double
 
   init(fromValue: Double, toValue: Double, animation: CAMediaTiming, duration: Double) {
@@ -39,7 +39,7 @@ public class KeyboardAnimation: KeyboardAnimationProtocol {
     timestamp = CACurrentMediaTime()
   }
 
-  /// public getters
+  // public getters
   var startTime: CFTimeInterval {
     // when concurrent animation happens, then `.beginTime` remains the same
     return max(animation?.beginTime ?? timestamp, timestamp)

package/ios/animations/SpringAnimation.swift

@@ -60,7 +60,7 @@ public final class SpringAnimation: KeyboardAnimation {
     super.init(fromValue: fromValue, toValue: toValue, animation: animation, duration: animation.settlingDuration)
   }
 
-  /// public functions
+  // public functions
   override func valueAt(time: Double) -> Double {
     let t = time * speed
 

package/ios/animations/TimingAnimation.swift

@@ -56,7 +56,9 @@ public final class TimingAnimation: KeyboardAnimation {
     let x = bezierX(t: t)
 
     let duration = animation?.duration ?? 0.0
-    return x * duration / speed
+    let time = x * duration / speed
+
+    return time
   }
 
   // private functions

package/ios/delegates/KCTextInputCompositeDelegate.swift

@@ -51,7 +51,7 @@ class KCTextInputCompositeDelegate: NSObject, UITextViewDelegate, UITextFieldDel
   weak var textViewDelegate: UITextViewDelegate?
   weak var textFieldDelegate: UITextFieldDelegate?
 
-  /// Keep track of which textField we’re observing (iOS < 13 only)
+  // Keep track of which textField we’re observing (iOS < 13 only)
   private weak var observedTextFieldForSelection: UITextField?
 
   init(
@@ -111,7 +111,7 @@ class KCTextInputCompositeDelegate: NSObject, UITextViewDelegate, UITextFieldDel
     return true
   }
 
-  /// Getter for the active delegate
+  // Getter for the active delegate
   var activeDelegate: AnyObject? {
     return textViewDelegate ?? textFieldDelegate
   }

package/ios/extensions/CGFloat.swift

@@ -16,6 +16,8 @@ public extension CGFloat {
     let outputMax = outputRange.max() ?? 1
 
     let normalizedValue = (currentValue - inputMin) / (inputMax - inputMin)
-    return outputMin + (outputMax - outputMin) * normalizedValue
+    let interpolatedValue = outputMin + (outputMax - outputMin) * normalizedValue
+
+    return interpolatedValue
   }
 }

package/ios/interactive/KeyboardAreaExtender.swift

@@ -55,8 +55,7 @@ class KeyboardAreaExtender: NSObject {
     let responder = UIResponder.current
     if let activeTextInput = responder as? TextInput,
        let offset = KeyboardOffsetProvider.shared.getOffset(
-         forTextInputNativeID: responder.nativeID
-       ),
+         forTextInputNativeID: responder.nativeID),
        responder?.inputAccessoryView == nil
     {
       currentInputAccessoryView = InvisibleInputAccessoryView(height: CGFloat(truncating: offset))

package/ios/observers/FocusedInputObserver.swift

@@ -32,7 +32,7 @@ public class FocusedInputObserver: NSObject {
   var onFocusDidSet: (NSDictionary) -> Void
   /// delegates
   var delegate: KCTextInputCompositeDelegate
-  /// state variables
+  // state variables
   private var isMounted = false
   // input tracking
   private var currentInput: UIView?
@@ -142,9 +142,7 @@ public class FocusedInputObserver: NSObject {
     setupObservers()
     // dispatch onSelectionChange on focus
     if let textInput = responder as? UITextInput {
-      DispatchQueue.main.async {
-        updateSelectionPosition(textInput: textInput, sendEvent: self.onSelectionChange)
-      }
+      updateSelectionPosition(textInput: textInput, sendEvent: onSelectionChange)
     }
 
     syncUpLayout()

package/ios/observers/movement/KeyboardTrackingView.swift

@@ -12,10 +12,7 @@ import UIKit
  * and uses `keyboardLayoutGuide` on iOS 26+.
  */
 public final class KeyboardTrackingView: UIView {
-  private var keyboardView: UIView? {
-    KeyboardViewLocator.shared.resolve()
-  }
-
+  private var keyboardView: UIView? { KeyboardViewLocator.shared.resolve() }
   private var keyboardHeight = 0.0
   private weak var currentAttachedView: UIView?
   private var isAttaching = false

package/ios/protocols/TextInput.swift

@@ -15,7 +15,7 @@ public protocol TextInput: UIView {
   var inputView: UIView? { get set }
   var keyboardType: UIKeyboardType { get }
   var keyboardAppearance: UIKeyboardAppearance { get }
-  /// custom methods/properties
+  // custom methods/properties
   func focus()
 }
 

package/ios/swizzling/UIResponderSwizzle.swift

@@ -94,7 +94,8 @@ extension UIResponder {
     let castOriginalResignFirstResponder = unsafeBitCast(
       originalResignFirstResponder, to: Function.self
     )
-    return castOriginalResignFirstResponder(self, selector)
+    let result = castOriginalResignFirstResponder(self, selector)
+    return result
   }
 
   private func callOriginalBecomeFirstResponder(_ selector: Selector) -> Bool {
@@ -103,6 +104,7 @@ extension UIResponder {
     let castOriginalBecomeFirstResponder = unsafeBitCast(
       originalBecomeFirstResponder, to: Function.self
     )
-    return castOriginalBecomeFirstResponder(self, selector)
+    let result = castOriginalBecomeFirstResponder(self, selector)
+    return result
   }
 }

package/ios/traversal/FocusedInputHolder.swift

@@ -11,10 +11,10 @@ import Foundation
 class FocusedInputHolder {
   static let shared = FocusedInputHolder()
 
-  /// Using TextInput protocol as the type for currentFocusedInput
+  // Using TextInput protocol as the type for currentFocusedInput
   private weak var currentFocusedInput: TextInput?
 
-  /// Sets the currentFocusedInput to the passed instance conforming to TextInput or clears it if nil is passed
+  // Sets the currentFocusedInput to the passed instance conforming to TextInput or clears it if nil is passed
   func set(_ input: TextInput?) {
     currentFocusedInput = input
   }
@@ -23,7 +23,7 @@ class FocusedInputHolder {
     return currentFocusedInput
   }
 
-  /// Requests focus for the currentFocusedInput if it's set
+  // Requests focus for the currentFocusedInput if it's set
   func focus() {
     currentFocusedInput?.focus()
   }

package/ios/traversal/KeyboardView.swift

@@ -13,7 +13,7 @@ enum KeyboardView {
   private static let windowPrefix = "<UITextEffectsWindow"
   private static let containerPrefixes = ["<UIInputSetContainerView", "<UITrackingWindowView"]
   private static let hostPrefixes = ["<UIInputSetHostView", "<UIKeyboardItemContainerView"]
-  /// inspired by https://stackoverflow.com/questions/32598490/show-uiview-with-buttons-over-keyboard-like-in-skype-viber-messengers-swift-i
+  // inspired by https://stackoverflow.com/questions/32598490/show-uiview-with-buttons-over-keyboard-like-in-skype-viber-messengers-swift-i
   static func find() -> UIView? {
     let windows = UIApplication.shared.windows
     for window in windows {

package/ios/traversal/ViewHierarchyNavigator.swift

@@ -36,7 +36,7 @@ public class ViewHierarchyNavigator: NSObject {
       return []
     }
 
-    /// Helper function to recursively search for TextInput views
+    // Helper function to recursively search for TextInput views
     func findTextInputs(in view: UIView?) {
       guard let view = view else { return }
 
@@ -104,7 +104,7 @@ public class ViewHierarchyNavigator: NSObject {
     return nil // No valid UITextField or UITextView found
   }
 
-  /// Function to check if the view is a valid text field or text view
+  // Function to check if the view is a valid text field or text view
   private static func isValidTextInput(_ view: UIView) -> TextInput? {
     if let textField = view as? UITextField, textField.isEnabled {
       return textField

package/ios/views/KeyboardControllerViewManager.swift

@@ -27,7 +27,7 @@ class KeyboardControllerView: UIView {
   var inputObserver: FocusedInputObserver?
   private var eventDispatcher: RCTEventDispatcherProtocol
   private var bridge: RCTBridge
-  /// internal state
+  // internal state
   private var lastScreenSize: CGSize = .zero
   // react callbacks
   /// keyboard
@@ -39,7 +39,7 @@ class KeyboardControllerView: UIView {
   @objc var onFocusedInputLayoutChanged: RCTDirectEventBlock?
   @objc var onFocusedInputTextChanged: RCTDirectEventBlock?
   @objc var onFocusedInputSelectionChanged: RCTDirectEventBlock?
-  /// react props
+  // react props
   @objc var enabled: ObjCBool = true {
     didSet {
       if enabled.boolValue {
@@ -83,9 +83,9 @@ class KeyboardControllerView: UIView {
     fatalError("init(coder:) has not been implemented")
   }
 
-  /// for mounting/unmounting observers for lifecycle events we're using willMove(toSuperview) method
-  /// not willMove(toWindow)
-  /// see https://github.com/kirillzyusko/react-native-keyboard-controller/issues/271
+  // for mounting/unmounting observers for lifecycle events we're using willMove(toSuperview) method
+  // not willMove(toWindow)
+  // see https://github.com/kirillzyusko/react-native-keyboard-controller/issues/271
   override func willMove(toSuperview newSuperview: UIView?) {
     super.willMove(toSuperview: newSuperview)
 

package/jest/index.js

@@ -120,6 +120,9 @@ const mock = {
   KeyboardAvoidingView: View,
   KeyboardAwareScrollView: ScrollView,
   KeyboardToolbar: View,
+  ChatKit: {
+    ScrollView: ScrollView,
+  },
   // themes
   DefaultKeyboardToolbarTheme,
 };

package/lib/commonjs/components/ChatKit/TODO.md

@@ -0,0 +1,20 @@
+# Findings
+
+1. We can not translate whole `ScrollView` because interactive dismissal will have double scroll if we move it by `translateY` or content will be truncated if we don't do it (same with external container).
+2. So we need to move only content inside `ScrollView`.
+3. If we use a separate `scrollTo` we still may have a random jump. The only one way is to use `contentOffset` + `padding` on `ScrollView`.
+4. Input must be always in `KeyboardStickyView` because it's always pushing above the keyboard (unlike content, which may stay in place).
+5. Changing `contentOffset` on `ScrollView` will not work. On iOS it works, but on Android sometimes it doesn't scroll to correct position (when you scroll list to the end) and on paper architecture it is flickering.
+6. Next idea is to use `contentInset` on iOS and create custom `ClippingScrollView` on Android (with polyfill `contentInsetBottom` prop).
+
+## To Do
+
+- [x] check how `ClippingScrollView` works in `KeyboardAwareScrollView` on Android (seems to be working well)
+- [x] introduce `useCombinedRef` hook in separate PR
+- [x] make sure, that style property doesn't affect the behavior with/without `ClippingScrollView` (test on a ScrollView that doesn't tke full screen?) <-- tested by comparing iOS with Android + `ClippingScrollView` (`contentInsetBottom` never override `paddingBottom` from `style`/`contentContainerStyle` even if ScrollView has `maxHeight=150` and we have only 2 inputs limitation + also tested `ScrollView` without height restrictions, in this case `paddingBottom` on `style` is not getting applied (it doesn't have an effect on both iOS/Android), but `contentContainerStyle` + `paddingBottom` works as expected and if I add `contentInsetBottom` to `ClippingScrollView` it doesn't overwrite a padding and increases scrollable area)
+- [x] `ClippingScrollView` + `KeyboardAwareScrollView` check by e2e tests (seems to be working, though on Android emulator + e2e tests sometimes when keyboard disappear we still have keyboard space)
+- [x] introduce `ClippingScrollView` in separate PR
+- [x] create a polyfill-version of ScrollView `that` can add scrollable padding in the bottom of the content? How to wrap custom `ScrollView` with it (cause we may pass one from react-native-gesture-handler)? Should just adjust `contentInset` (scroll management should belong to `KeyboardAwareScrollView`) (ScrollViewWithKeyboardPadding/ScrollViewWithKeyboardSpace)
+- [x] use `ClippingScrollView` in `KeyboardAwareScrollView` in separate PR
+- [-] introduce `ChatKit`
+- [] create issue in reanimated repo about `scrollTo` performance regression

package/lib/commonjs/components/ChatKit/hooks.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useChatKeyboard", {
+  enumerable: true,
+  get: function () {
+    return _useChatKeyboard.useChatKeyboard;
+  }
+});
+var _useChatKeyboard = require("./useChatKeyboard");
+//# sourceMappingURL=hooks.js.map

package/lib/commonjs/components/ChatKit/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_useChatKeyboard","require"],"sources":["hooks.ts"],"sourcesContent":["export { useChatKeyboard } from \"./useChatKeyboard\";\nexport type { KeyboardLiftBehavior } from \"./useChatKeyboard\";\n"],"mappings":";;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA","ignoreList":[]}

package/lib/commonjs/components/ChatKit/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _reactNativeReanimated = _interopRequireWildcard(require("react-native-reanimated"));
+var _useCombinedRef = _interopRequireDefault(require("../hooks/useCombinedRef"));
+var _ScrollViewWithBottomPadding = _interopRequireDefault(require("../ScrollViewWithBottomPadding"));
+var _useChatKeyboard = require("./useChatKeyboard");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+const ChatScrollView = /*#__PURE__*/(0, _react.forwardRef)(({
+  children,
+  ScrollViewComponent = _reactNativeReanimated.default.ScrollView,
+  inverted = false,
+  keyboardLiftBehavior = "always",
+  freeze = false,
+  offset = 0,
+  ...rest
+}, ref) => {
+  const scrollViewRef = (0, _reactNativeReanimated.useAnimatedRef)();
+  const onRef = (0, _useCombinedRef.default)(ref, scrollViewRef);
+  const {
+    padding,
+    contentOffsetY,
+    containerTranslateY
+  } = (0, _useChatKeyboard.useChatKeyboard)(scrollViewRef, {
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+    offset
+  });
+  const containerStyle = (0, _reactNativeReanimated.useAnimatedStyle)(() => ({
+    transform: [{
+      translateY: containerTranslateY.value
+    }]
+  }), []);
+  return /*#__PURE__*/_react.default.createElement(_ScrollViewWithBottomPadding.default, _extends({
+    ref: onRef
+  }, rest, {
+    bottomPadding: padding,
+    containerStyle: containerStyle,
+    contentOffsetY: contentOffsetY,
+    inverted: inverted,
+    ScrollViewComponent: ScrollViewComponent
+  }), children);
+});
+const ChatKit = {
+  ScrollView: ChatScrollView
+};
+var _default = exports.default = ChatKit;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/components/ChatKit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNativeReanimated","_useCombinedRef","_interopRequireDefault","_ScrollViewWithBottomPadding","_useChatKeyboard","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","_extends","assign","bind","arguments","length","apply","ChatScrollView","forwardRef","children","ScrollViewComponent","Reanimated","ScrollView","inverted","keyboardLiftBehavior","freeze","offset","rest","ref","scrollViewRef","useAnimatedRef","onRef","useCombinedRef","padding","contentOffsetY","containerTranslateY","useChatKeyboard","containerStyle","useAnimatedStyle","transform","translateY","value","createElement","bottomPadding","ChatKit","_default","exports"],"sources":["index.tsx"],"sourcesContent":["import React, { forwardRef } from \"react\";\nimport { useAnimatedRef, useAnimatedStyle } from \"react-native-reanimated\";\nimport Reanimated from \"react-native-reanimated\";\n\nimport useCombinedRef from \"../hooks/useCombinedRef\";\nimport ScrollViewWithBottomPadding from \"../ScrollViewWithBottomPadding\";\n\nimport { useChatKeyboard } from \"./useChatKeyboard\";\n\nimport type { ChatKitScrollViewProps } from \"./types\";\n\nconst ChatScrollView = forwardRef<\n  Reanimated.ScrollView,\n  React.PropsWithChildren<ChatKitScrollViewProps>\n>(\n  (\n    {\n      children,\n      ScrollViewComponent = Reanimated.ScrollView,\n      inverted = false,\n      keyboardLiftBehavior = \"always\",\n      freeze = false,\n      offset = 0,\n      ...rest\n    },\n    ref,\n  ) => {\n    const scrollViewRef = useAnimatedRef<Reanimated.ScrollView>();\n    const onRef = useCombinedRef(ref, scrollViewRef);\n\n    const { padding, contentOffsetY, containerTranslateY } = useChatKeyboard(\n      scrollViewRef,\n      { inverted, keyboardLiftBehavior, freeze, offset },\n    );\n\n    const containerStyle = useAnimatedStyle(\n      () => ({\n        transform: [{ translateY: containerTranslateY.value }],\n      }),\n      [],\n    );\n\n    return (\n      <ScrollViewWithBottomPadding\n        ref={onRef}\n        {...rest}\n        bottomPadding={padding}\n        containerStyle={containerStyle}\n        contentOffsetY={contentOffsetY}\n        inverted={inverted}\n        ScrollViewComponent={ScrollViewComponent}\n      >\n        {children}\n      </ScrollViewWithBottomPadding>\n    );\n  },\n);\n\nconst ChatKit = {\n  ScrollView: ChatScrollView,\n};\n\nexport default ChatKit;\n"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/components/ChatKit/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/lib/commonjs/components/ChatKit/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { AnimatedScrollViewComponent } from \"../ScrollViewWithBottomPadding\";\nimport type { ScrollViewProps } from \"react-native\";\n\ntype KeyboardLiftBehavior = \"always\" | \"whenAtEnd\" | \"persistent\" | \"never\";\n\nexport type ChatKitScrollViewProps = {\n  /** Custom component for `ScrollView`. Default is `ScrollView`. */\n  ScrollViewComponent: AnimatedScrollViewComponent;\n  /** Whether list are using `inverted` prop. Default is `false`. */\n  inverted?: boolean;\n  /**\n   * The distance (in pixels) between the bottom of the screen and the `ScrollView`.\n   * When the keyboard appears, the scroll view will only push content by the effective\n   * distance (`keyboardHeight - offset`) instead of the full keyboard height.\n   *\n   * Useful when the input is not at the very bottom of the screen (e.g., above safe area, above\n   * bottom tabs, etc. - in this case offset should be equal to the height of the elements between\n   * `ScrollView` and bottom of the screen).\n   *\n   * Default is `0`.\n   */\n  offset?: number;\n  /**\n   * Determines how the chat content should behave when the keyboard appears, specifically whether\n   * the scroll view should automatically lift its content to keep it visible above the keyboard.\n   *\n   * Possible values:\n   * - `'always'`: The content always lifts along with the keyboard, ensuring the messages from the bottom part of screen\n   * remain visible regardless of the current scroll position. This is the default behavior for most chat applications (used in Telegram).\n   * - `'whenAtEnd'`: The content lifts only if the scroll view is at the end (i.e., the last message\n   * is visible or near the bottom). This prevents unnecessary adjustments when the user is scrolling\n   * through older messages (ChatGPT mobile app behavior).\n   * - `'persistent'`: The content always lifts when the keyboard appears (similar to `'always'`), but\n   * does not reset (lower) when the keyboard hides. This mimics behaviors where the view remains adjusted\n   * after keyboard dismissal to maintain focus on the latest content without shifting back (Claude mobile app behavior).\n   * - `'never'`: The content does not lift at all when the keyboard appears. Use this for scenarios\n   * when you don't want to disturb user attention with animations (Perplexity mobile app behavior).\n   *\n   * Default is `'always'`.\n   */\n  keyboardLiftBehavior?: KeyboardLiftBehavior;\n  /**\n   * When `true`, freezes all keyboard-driven layout changes (padding, content offset, scroll position).\n   * Useful when dismissing the keyboard to open a bottom sheet — prevents visual disruption\n   * while the sheet is visible.\n   *\n   * Default is `false`.\n   */\n  freeze?: boolean;\n} & ScrollViewProps;\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clampedScrollTarget = clampedScrollTarget;
+exports.computeIOSContentOffset = computeIOSContentOffset;
+exports.isScrollAtEnd = isScrollAtEnd;
+exports.shouldShiftContent = shouldShiftContent;
+const AT_END_THRESHOLD = 20;
+
+/**
+ * Check whether the scroll view is at the end of its content.
+ *
+ * @param scrollOffset - Current vertical scroll offset.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param contentHeight - Total height of the scrollable content.
+ * @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)
+ * ```
+ */
+function isScrollAtEnd(scrollOffset, layoutHeight, contentHeight) {
+  "worklet";
+
+  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
+ * ```
+ */
+function shouldShiftContent(behavior, isAtEnd) {
+  "worklet";
+
+  switch (behavior) {
+    case "always":
+      return true;
+    case "never":
+      return false;
+    case "whenAtEnd":
+      return isAtEnd;
+    case "persistent":
+      return true;
+  }
+}
+
+/**
+ * Compute the clamped scroll target for non-inverted lists.
+ *
+ * @param offsetBeforeScroll - Scroll position before keyboard appeared.
+ * @param keyboardHeight - Current keyboard height.
+ * @param contentHeight - Total height of the scrollable content.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @returns Clamped scroll target between 0 and maxScroll.
+ * @example
+ * ```ts
+ * clampedScrollTarget(100, 300, 1000, 800); // 400
+ * ```
+ */
+function clampedScrollTarget(offsetBeforeScroll, keyboardHeight, contentHeight, layoutHeight) {
+  "worklet";
+
+  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 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 contentHeight - Total height of the scrollable content.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param inverted - Whether the list is inverted.
+ * @returns The absolute contentOffset.y to set.
+ * @example
+ * ```ts
+ * computeIOSContentOffset(100, 300, 1000, 800, false); // 400
+ * ```
+ */
+function computeIOSContentOffset(relativeScroll, keyboardHeight, contentHeight, layoutHeight, inverted) {
+  "worklet";
+
+  if (inverted) {
+    const maxScroll = Math.max(contentHeight - layoutHeight, 0);
+    return Math.max(Math.min(relativeScroll - keyboardHeight, maxScroll), -keyboardHeight);
+  }
+  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);
+  return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);
+}
+//# sourceMappingURL=helpers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["AT_END_THRESHOLD","isScrollAtEnd","scrollOffset","layoutHeight","contentHeight","shouldShiftContent","behavior","isAtEnd","clampedScrollTarget","offsetBeforeScroll","keyboardHeight","maxScroll","Math","max","min","computeIOSContentOffset","relativeScroll","inverted"],"sources":["helpers.ts"],"sourcesContent":["type KeyboardLiftBehavior = \"always\" | \"whenAtEnd\" | \"persistent\" | \"never\";\n\nconst AT_END_THRESHOLD = 20;\n\n/**\n * Check whether the scroll view is at the end of its content.\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 * @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 * ```\n */\nexport function isScrollAtEnd(\n  scrollOffset: number,\n  layoutHeight: number,\n  contentHeight: number,\n): boolean {\n  \"worklet\";\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":";;;;;;;;;AAEA,MAAMA,gBAAgB,GAAG,EAAE;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CAC3BC,YAAoB,EACpBC,YAAoB,EACpBC,aAAqB,EACZ;EACT,SAAS;;EAET,OAAOF,YAAY,GAAGC,YAAY,IAAIC,aAAa,GAAGJ,gBAAgB;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASK,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,EACtBN,aAAqB,EACrBD,YAAoB,EACZ;EACR,SAAS;;EAET,MAAMQ,SAAS,GAAGC,IAAI,CAACC,GAAG,CAACT,aAAa,GAAGD,YAAY,GAAGO,cAAc,EAAE,CAAC,CAAC;EAE5E,OAAOE,IAAI,CAACE,GAAG,CAACF,IAAI,CAACC,GAAG,CAACJ,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,SAASI,uBAAuBA,CACrCC,cAAsB,EACtBN,cAAsB,EACtBN,aAAqB,EACrBD,YAAoB,EACpBc,QAAiB,EACT;EACR,SAAS;;EAET,IAAIA,QAAQ,EAAE;IACZ,MAAMN,SAAS,GAAGC,IAAI,CAACC,GAAG,CAACT,aAAa,GAAGD,YAAY,EAAE,CAAC,CAAC;IAE3D,OAAOS,IAAI,CAACC,GAAG,CACbD,IAAI,CAACE,GAAG,CAACE,cAAc,GAAGN,cAAc,EAAEC,SAAS,CAAC,EACpD,CAACD,cACH,CAAC;EACH;EAEA,MAAMC,SAAS,GAAGC,IAAI,CAACC,GAAG,CAACT,aAAa,GAAGD,YAAY,GAAGO,cAAc,EAAE,CAAC,CAAC;EAE5E,OAAOE,IAAI,CAACE,GAAG,CAACF,IAAI,CAACC,GAAG,CAACH,cAAc,GAAGM,cAAc,EAAE,CAAC,CAAC,EAAEL,SAAS,CAAC;AAC1E","ignoreList":[]}

package/lib/commonjs/components/ChatKit/useChatKeyboard/index.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChatKeyboard = useChatKeyboard;
+var _reactNative = require("react-native");
+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 }; }
+const OS = _reactNative.Platform.OS;
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * using the optimal strategy per platform.
+ *
+ * @param scrollViewRef - Animated ref to the scroll view.
+ * @param options - Configuration for inverted and keyboardLiftBehavior.
+ * @returns Shared values for padding, contentOffsetY (iOS), and containerTranslateY (Android inverted).
+ * @example
+ * ```tsx
+ * const { padding, contentOffsetY, containerTranslateY } = useChatKeyboard(ref, {
+ *   inverted: false,
+ *   keyboardLiftBehavior: "always",
+ * });
+ * ```
+ */
+function useChatKeyboard(scrollViewRef, options) {
+  const {
+    inverted,
+    keyboardLiftBehavior,
+    freeze,
+    offset
+  } = options;
+  const padding = (0, _reactNativeReanimated.useSharedValue)(0);
+  const contentOffsetY = (0, _reactNativeReanimated.useSharedValue)(0);
+  const containerTranslateY = (0, _reactNativeReanimated.useSharedValue)(0);
+  const offsetBeforeScroll = (0, _reactNativeReanimated.useSharedValue)(0);
+  const targetKeyboardHeight = (0, _reactNativeReanimated.useSharedValue)(0);
+  const {
+    layout,
+    size,
+    offset: scroll
+  } = (0, _useScrollState.default)(scrollViewRef);
+  const getEffectiveHeight = height => {
+    "worklet";
+
+    if (offset === 0 || targetKeyboardHeight.value === 0) {
+      return height;
+    }
+    return (0, _reactNativeReanimated.interpolate)(height, [0, targetKeyboardHeight.value], [0, Math.max(targetKeyboardHeight.value - offset, 0)]);
+  };
+  (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 = getEffectiveHeight(e.height);
+      const atEnd = (0, _helpers.isScrollAtEnd)(scroll.value, layout.value.height, size.value.height);
+      if (OS === "ios") {
+        // iOS: set padding + contentOffset once in onStart
+        const relativeScroll = inverted ? scroll.value + padding.value : scroll.value - padding.value;
+        padding.value = effective;
+        if (!(0, _helpers.shouldShiftContent)(keyboardLiftBehavior, atEnd)) {
+          return;
+        }
+        if (keyboardLiftBehavior === "persistent" && effective < padding.value) {
+          return;
+        }
+        contentOffsetY.value = (0, _helpers.computeIOSContentOffset)(relativeScroll, effective, size.value.height, layout.value.height, inverted);
+      } else if (e.height > 0) {
+        // Android: keyboard opening — set padding + capture scroll position
+        padding.value = effective;
+        offsetBeforeScroll.value = scroll.value;
+        if (keyboardLiftBehavior === "whenAtEnd" && !atEnd) {
+          // Sentinel: don't scroll in onMove
+          offsetBeforeScroll.value = -1;
+        }
+      } else {
+        // Android: keyboard closing — re-capture from current position
+        // so onMove smoothly scrolls back from where the user is now
+        offsetBeforeScroll.value = scroll.value - padding.value;
+      }
+    },
+    onMove: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+
+      // iOS doesn't need per-frame updates (contentOffset handles it)
+      if (OS === "ios") {
+        return;
+      }
+      if (!(0, _helpers.shouldShiftContent)(keyboardLiftBehavior, true)) {
+        return;
+      }
+
+      // "whenAtEnd" sentinel check
+      if (offsetBeforeScroll.value === -1) {
+        return;
+      }
+      const effective = getEffectiveHeight(e.height);
+      if (inverted) {
+        // Android inverted: translateY on container
+        if (keyboardLiftBehavior === "persistent" && effective < Math.abs(containerTranslateY.value)) {
+          return;
+        }
+        containerTranslateY.value = -effective;
+      } else {
+        // Android non-inverted: scrollTo per-frame
+        if (keyboardLiftBehavior === "persistent" && effective < scroll.value - offsetBeforeScroll.value) {
+          return;
+        }
+        const target = (0, _helpers.clampedScrollTarget)(offsetBeforeScroll.value, effective, size.value.height, layout.value.height);
+        (0, _reactNativeReanimated.scrollTo)(scrollViewRef, 0, target, false);
+      }
+    },
+    onEnd: e => {
+      "worklet";
+
+      if (freeze) {
+        return;
+      }
+      const effective = getEffectiveHeight(e.height);
+      padding.value = effective;
+      if (OS !== "ios" && inverted && e.height === 0 && keyboardLiftBehavior !== "persistent") {
+        containerTranslateY.value = 0;
+      }
+    }
+  }, [inverted, keyboardLiftBehavior, freeze, offset]);
+  return {
+    padding,
+    contentOffsetY: OS === "ios" ? contentOffsetY : undefined,
+    containerTranslateY
+  };
+}
+//# sourceMappingURL=index.js.map