@react-native-ohos/react-native-keyboard-controller 1.17.0-beta.2 → 1.17.0

package/lib/module/components/KeyboardChatScrollView/hooks.js

@@ -0,0 +1,2 @@
+export { useChatKeyboard } from "./useChatKeyboard";
+//# sourceMappingURL=hooks.js.map

package/lib/module/components/KeyboardChatScrollView/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useChatKeyboard"],"sources":["hooks.ts"],"sourcesContent":["export { useChatKeyboard } from \"./useChatKeyboard\";\nexport type { KeyboardLiftBehavior } from \"./useChatKeyboard/types\";\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,mBAAmB","ignoreList":[]}

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

@@ -0,0 +1,115 @@
+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); }
+import React, { forwardRef, useCallback, useMemo } from "react";
+import { StyleSheet } from "react-native";
+import { makeMutable, useAnimatedRef, useAnimatedStyle, useDerivedValue } from "react-native-reanimated";
+import Reanimated from "react-native-reanimated";
+import useCombinedRef from "../hooks/useCombinedRef";
+import ScrollViewWithBottomPadding from "../ScrollViewWithBottomPadding";
+import { useChatKeyboard } from "./useChatKeyboard";
+import { useEndVisible } from "./useEndVisible";
+import { useExtraContentPadding } from "./useExtraContentPadding";
+const ZERO_CONTENT_PADDING = makeMutable(0);
+const ZERO_BLANK_SPACE = makeMutable(0);
+const KeyboardChatScrollView = /*#__PURE__*/forwardRef(({
+  children,
+  ScrollViewComponent = Reanimated.ScrollView,
+  inverted = false,
+  keyboardLiftBehavior = "always",
+  freeze = false,
+  offset = 0,
+  extraContentPadding = ZERO_CONTENT_PADDING,
+  blankSpace = ZERO_BLANK_SPACE,
+  applyWorkaroundForContentInsetHitTestBug = false,
+  onLayout: onLayoutProp,
+  onContentSizeChange: onContentSizeChangeProp,
+  onEndVisible,
+  ...rest
+}, ref) => {
+  const scrollViewRef = useAnimatedRef();
+  const onRef = useCombinedRef(ref, scrollViewRef);
+  const freezeSV = useDerivedValue(() => typeof freeze === "boolean" ? freeze : freeze.value);
+  const {
+    padding,
+    currentHeight,
+    contentOffsetY,
+    scroll,
+    layout,
+    size,
+    onLayout: onLayoutInternal,
+    onContentSizeChange: onContentSizeChangeInternal
+  } = useChatKeyboard(scrollViewRef, {
+    inverted,
+    keyboardLiftBehavior,
+    freeze: freezeSV,
+    offset,
+    blankSpace,
+    extraContentPadding
+  });
+  useExtraContentPadding({
+    scrollViewRef,
+    extraContentPadding,
+    keyboardPadding: padding,
+    blankSpace,
+    scroll,
+    layout,
+    size,
+    contentOffsetY,
+    inverted,
+    keyboardLiftBehavior,
+    freeze: freezeSV
+  });
+  useEndVisible({
+    scroll,
+    layout,
+    size,
+    inverted,
+    onEndVisible
+  });
+  const totalPadding = useDerivedValue(() => Math.max(blankSpace.value, padding.value + extraContentPadding.value));
+
+  // Scroll indicator inset = keyboard + extraContentPadding (excludes blankSpace).
+  // Apps that render into the unsafe area can supply a negative
+  // scrollIndicatorInsets adjustment at the application layer.
+  const indicatorPadding = useDerivedValue(() => padding.value + extraContentPadding.value);
+  const onLayout = useCallback(e => {
+    onLayoutInternal(e);
+    onLayoutProp === null || onLayoutProp === void 0 || onLayoutProp(e);
+  }, [onLayoutInternal, onLayoutProp]);
+  const onContentSizeChange = useCallback((w, h) => {
+    onContentSizeChangeInternal(w, h);
+    onContentSizeChangeProp === null || onContentSizeChangeProp === void 0 || onContentSizeChangeProp(w, h);
+  }, [onContentSizeChangeInternal, onContentSizeChangeProp]);
+
+  // Invisible view whose animated style changes every frame during keyboard
+  // animation. On Fabric, this forces Reanimated to schedule a commit,
+  // which flushes the scrollTo call in the same frame (fixing de-synchronization).
+  // see https://github.com/software-mansion/react-native-reanimated/issues/9000
+  const commitStyle = useAnimatedStyle(() => ({
+    transform: [{
+      translateY: -currentHeight.value
+    }]
+  }), []);
+  const commit = useMemo(() => [styles.commitView, commitStyle], [commitStyle]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ScrollViewWithBottomPadding, _extends({
+    ref: onRef
+  }, rest, {
+    applyWorkaroundForContentInsetHitTestBug: applyWorkaroundForContentInsetHitTestBug,
+    bottomPadding: totalPadding,
+    contentOffsetY: contentOffsetY,
+    inverted: inverted,
+    scrollIndicatorPadding: indicatorPadding,
+    ScrollViewComponent: ScrollViewComponent,
+    onContentSizeChange: onContentSizeChange,
+    onLayout: onLayout
+  }), children), /*#__PURE__*/React.createElement(Reanimated.View, {
+    style: commit
+  }));
+});
+const styles = StyleSheet.create({
+  commitView: {
+    display: "none",
+    position: "absolute"
+  }
+});
+export default KeyboardChatScrollView;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["React","forwardRef","useCallback","useMemo","StyleSheet","makeMutable","useAnimatedRef","useAnimatedStyle","useDerivedValue","Reanimated","useCombinedRef","ScrollViewWithBottomPadding","useChatKeyboard","useEndVisible","useExtraContentPadding","ZERO_CONTENT_PADDING","ZERO_BLANK_SPACE","KeyboardChatScrollView","children","ScrollViewComponent","ScrollView","inverted","keyboardLiftBehavior","freeze","offset","extraContentPadding","blankSpace","applyWorkaroundForContentInsetHitTestBug","onLayout","onLayoutProp","onContentSizeChange","onContentSizeChangeProp","onEndVisible","rest","ref","scrollViewRef","onRef","freezeSV","value","padding","currentHeight","contentOffsetY","scroll","layout","size","onLayoutInternal","onContentSizeChangeInternal","keyboardPadding","totalPadding","Math","max","indicatorPadding","e","w","h","commitStyle","transform","translateY","commit","styles","commitView","createElement","Fragment","_extends","bottomPadding","scrollIndicatorPadding","View","style","create","display","position"],"sources":["index.tsx"],"sourcesContent":["import React, { forwardRef, useCallback, useMemo } from \"react\";\nimport { StyleSheet } from \"react-native\";\nimport {\n  makeMutable,\n  useAnimatedRef,\n  useAnimatedStyle,\n  useDerivedValue,\n} 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\";\nimport { useEndVisible } from \"./useEndVisible\";\nimport { useExtraContentPadding } from \"./useExtraContentPadding\";\n\nimport type { KeyboardChatScrollViewProps } from \"./types\";\nimport type { LayoutChangeEvent } from \"react-native\";\n\nconst ZERO_CONTENT_PADDING = makeMutable(0);\nconst ZERO_BLANK_SPACE = makeMutable(0);\n\nconst KeyboardChatScrollView = forwardRef<\n  Reanimated.ScrollView,\n  React.PropsWithChildren<KeyboardChatScrollViewProps>\n>(\n  (\n    {\n      children,\n      ScrollViewComponent = Reanimated.ScrollView,\n      inverted = false,\n      keyboardLiftBehavior = \"always\",\n      freeze = false,\n      offset = 0,\n      extraContentPadding = ZERO_CONTENT_PADDING,\n      blankSpace = ZERO_BLANK_SPACE,\n      applyWorkaroundForContentInsetHitTestBug = false,\n      onLayout: onLayoutProp,\n      onContentSizeChange: onContentSizeChangeProp,\n      onEndVisible,\n      ...rest\n    },\n    ref,\n  ) => {\n    const scrollViewRef = useAnimatedRef<Reanimated.ScrollView>();\n    const onRef = useCombinedRef(ref, scrollViewRef);\n    const freezeSV = useDerivedValue(() =>\n      typeof freeze === \"boolean\" ? freeze : freeze.value,\n    );\n    const {\n      padding,\n      currentHeight,\n      contentOffsetY,\n      scroll,\n      layout,\n      size,\n      onLayout: onLayoutInternal,\n      onContentSizeChange: onContentSizeChangeInternal,\n    } = useChatKeyboard(scrollViewRef, {\n      inverted,\n      keyboardLiftBehavior,\n      freeze: freezeSV,\n      offset,\n      blankSpace,\n      extraContentPadding,\n    });\n\n    useExtraContentPadding({\n      scrollViewRef,\n      extraContentPadding,\n      keyboardPadding: padding,\n      blankSpace,\n      scroll,\n      layout,\n      size,\n      contentOffsetY,\n      inverted,\n      keyboardLiftBehavior,\n      freeze: freezeSV,\n    });\n\n    useEndVisible({\n      scroll,\n      layout,\n      size,\n      inverted,\n      onEndVisible,\n    });\n\n    const totalPadding = useDerivedValue(() =>\n      Math.max(blankSpace.value, padding.value + extraContentPadding.value),\n    );\n\n    // Scroll indicator inset = keyboard + extraContentPadding (excludes blankSpace).\n    // Apps that render into the unsafe area can supply a negative\n    // scrollIndicatorInsets adjustment at the application layer.\n    const indicatorPadding = useDerivedValue(\n      () => padding.value + extraContentPadding.value,\n    );\n\n    const onLayout = useCallback(\n      (e: LayoutChangeEvent) => {\n        onLayoutInternal(e);\n        onLayoutProp?.(e);\n      },\n      [onLayoutInternal, onLayoutProp],\n    );\n\n    const onContentSizeChange = useCallback(\n      (w: number, h: number) => {\n        onContentSizeChangeInternal(w, h);\n        onContentSizeChangeProp?.(w, h);\n      },\n      [onContentSizeChangeInternal, onContentSizeChangeProp],\n    );\n\n    // Invisible view whose animated style changes every frame during keyboard\n    // animation. On Fabric, this forces Reanimated to schedule a commit,\n    // which flushes the scrollTo call in the same frame (fixing de-synchronization).\n    // see https://github.com/software-mansion/react-native-reanimated/issues/9000\n    const commitStyle = useAnimatedStyle(\n      () => ({\n        transform: [{ translateY: -currentHeight.value }],\n      }),\n      [],\n    );\n    const commit = useMemo(\n      () => [styles.commitView, commitStyle],\n      [commitStyle],\n    );\n\n    return (\n      <>\n        <ScrollViewWithBottomPadding\n          ref={onRef}\n          {...rest}\n          applyWorkaroundForContentInsetHitTestBug={\n            applyWorkaroundForContentInsetHitTestBug\n          }\n          bottomPadding={totalPadding}\n          contentOffsetY={contentOffsetY}\n          inverted={inverted}\n          scrollIndicatorPadding={indicatorPadding}\n          ScrollViewComponent={ScrollViewComponent}\n          onContentSizeChange={onContentSizeChange}\n          onLayout={onLayout}\n        >\n          {children}\n        </ScrollViewWithBottomPadding>\n        <Reanimated.View style={commit} />\n      </>\n    );\n  },\n);\n\nconst styles = StyleSheet.create({\n  commitView: {\n    display: \"none\",\n    position: \"absolute\",\n  },\n});\n\nexport default KeyboardChatScrollView;\n"],"mappings":";AAAA,OAAOA,KAAK,IAAIC,UAAU,EAAEC,WAAW,EAAEC,OAAO,QAAQ,OAAO;AAC/D,SAASC,UAAU,QAAQ,cAAc;AACzC,SACEC,WAAW,EACXC,cAAc,EACdC,gBAAgB,EAChBC,eAAe,QACV,yBAAyB;AAChC,OAAOC,UAAU,MAAM,yBAAyB;AAEhD,OAAOC,cAAc,MAAM,yBAAyB;AACpD,OAAOC,2BAA2B,MAAM,gCAAgC;AAExE,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SAASC,aAAa,QAAQ,iBAAiB;AAC/C,SAASC,sBAAsB,QAAQ,0BAA0B;AAKjE,MAAMC,oBAAoB,GAAGV,WAAW,CAAC,CAAC,CAAC;AAC3C,MAAMW,gBAAgB,GAAGX,WAAW,CAAC,CAAC,CAAC;AAEvC,MAAMY,sBAAsB,gBAAGhB,UAAU,CAIvC,CACE;EACEiB,QAAQ;EACRC,mBAAmB,GAAGV,UAAU,CAACW,UAAU;EAC3CC,QAAQ,GAAG,KAAK;EAChBC,oBAAoB,GAAG,QAAQ;EAC/BC,MAAM,GAAG,KAAK;EACdC,MAAM,GAAG,CAAC;EACVC,mBAAmB,GAAGV,oBAAoB;EAC1CW,UAAU,GAAGV,gBAAgB;EAC7BW,wCAAwC,GAAG,KAAK;EAChDC,QAAQ,EAAEC,YAAY;EACtBC,mBAAmB,EAAEC,uBAAuB;EAC5CC,YAAY;EACZ,GAAGC;AACL,CAAC,EACDC,GAAG,KACA;EACH,MAAMC,aAAa,GAAG7B,cAAc,CAAwB,CAAC;EAC7D,MAAM8B,KAAK,GAAG1B,cAAc,CAACwB,GAAG,EAAEC,aAAa,CAAC;EAChD,MAAME,QAAQ,GAAG7B,eAAe,CAAC,MAC/B,OAAOe,MAAM,KAAK,SAAS,GAAGA,MAAM,GAAGA,MAAM,CAACe,KAChD,CAAC;EACD,MAAM;IACJC,OAAO;IACPC,aAAa;IACbC,cAAc;IACdC,MAAM;IACNC,MAAM;IACNC,IAAI;IACJhB,QAAQ,EAAEiB,gBAAgB;IAC1Bf,mBAAmB,EAAEgB;EACvB,CAAC,GAAGlC,eAAe,CAACuB,aAAa,EAAE;IACjCd,QAAQ;IACRC,oBAAoB;IACpBC,MAAM,EAAEc,QAAQ;IAChBb,MAAM;IACNE,UAAU;IACVD;EACF,CAAC,CAAC;EAEFX,sBAAsB,CAAC;IACrBqB,aAAa;IACbV,mBAAmB;IACnBsB,eAAe,EAAER,OAAO;IACxBb,UAAU;IACVgB,MAAM;IACNC,MAAM;IACNC,IAAI;IACJH,cAAc;IACdpB,QAAQ;IACRC,oBAAoB;IACpBC,MAAM,EAAEc;EACV,CAAC,CAAC;EAEFxB,aAAa,CAAC;IACZ6B,MAAM;IACNC,MAAM;IACNC,IAAI;IACJvB,QAAQ;IACRW;EACF,CAAC,CAAC;EAEF,MAAMgB,YAAY,GAAGxC,eAAe,CAAC,MACnCyC,IAAI,CAACC,GAAG,CAACxB,UAAU,CAACY,KAAK,EAAEC,OAAO,CAACD,KAAK,GAAGb,mBAAmB,CAACa,KAAK,CACtE,CAAC;;EAED;EACA;EACA;EACA,MAAMa,gBAAgB,GAAG3C,eAAe,CACtC,MAAM+B,OAAO,CAACD,KAAK,GAAGb,mBAAmB,CAACa,KAC5C,CAAC;EAED,MAAMV,QAAQ,GAAG1B,WAAW,CACzBkD,CAAoB,IAAK;IACxBP,gBAAgB,CAACO,CAAC,CAAC;IACnBvB,YAAY,aAAZA,YAAY,eAAZA,YAAY,CAAGuB,CAAC,CAAC;EACnB,CAAC,EACD,CAACP,gBAAgB,EAAEhB,YAAY,CACjC,CAAC;EAED,MAAMC,mBAAmB,GAAG5B,WAAW,CACrC,CAACmD,CAAS,EAAEC,CAAS,KAAK;IACxBR,2BAA2B,CAACO,CAAC,EAAEC,CAAC,CAAC;IACjCvB,uBAAuB,aAAvBA,uBAAuB,eAAvBA,uBAAuB,CAAGsB,CAAC,EAAEC,CAAC,CAAC;EACjC,CAAC,EACD,CAACR,2BAA2B,EAAEf,uBAAuB,CACvD,CAAC;;EAED;EACA;EACA;EACA;EACA,MAAMwB,WAAW,GAAGhD,gBAAgB,CAClC,OAAO;IACLiD,SAAS,EAAE,CAAC;MAAEC,UAAU,EAAE,CAACjB,aAAa,CAACF;IAAM,CAAC;EAClD,CAAC,CAAC,EACF,EACF,CAAC;EACD,MAAMoB,MAAM,GAAGvD,OAAO,CACpB,MAAM,CAACwD,MAAM,CAACC,UAAU,EAAEL,WAAW,CAAC,EACtC,CAACA,WAAW,CACd,CAAC;EAED,oBACEvD,KAAA,CAAA6D,aAAA,CAAA7D,KAAA,CAAA8D,QAAA,qBACE9D,KAAA,CAAA6D,aAAA,CAAClD,2BAA2B,EAAAoD,QAAA;IAC1B7B,GAAG,EAAEE;EAAM,GACPH,IAAI;IACRN,wCAAwC,EACtCA,wCACD;IACDqC,aAAa,EAAEhB,YAAa;IAC5BP,cAAc,EAAEA,cAAe;IAC/BpB,QAAQ,EAAEA,QAAS;IACnB4C,sBAAsB,EAAEd,gBAAiB;IACzChC,mBAAmB,EAAEA,mBAAoB;IACzCW,mBAAmB,EAAEA,mBAAoB;IACzCF,QAAQ,EAAEA;EAAS,IAElBV,QAC0B,CAAC,eAC9BlB,KAAA,CAAA6D,aAAA,CAACpD,UAAU,CAACyD,IAAI;IAACC,KAAK,EAAET;EAAO,CAAE,CACjC,CAAC;AAEP,CACF,CAAC;AAED,MAAMC,MAAM,GAAGvD,UAAU,CAACgE,MAAM,CAAC;EAC/BR,UAAU,EAAE;IACVS,OAAO,EAAE,MAAM;IACfC,QAAQ,EAAE;EACZ;AACF,CAAC,CAAC;AAEF,eAAerD,sBAAsB","ignoreList":[]}

package/lib/module/components/KeyboardChatScrollView/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/components/KeyboardChatScrollView/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type {\n  AnimatedScrollViewComponent,\n  ScrollViewContentInsets,\n} from \"../ScrollViewWithBottomPadding\";\nimport type { KeyboardLiftBehavior } from \"./useChatKeyboard/types\";\nimport type { ScrollViewProps } from \"react-native\";\nimport type { SharedValue } from \"react-native-reanimated\";\n\nexport type KeyboardChatScrollViewProps = {\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 between the bottom of the screen and the `ScrollView`.\n   * When the keyboard appears, the `ScrollView` 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 | SharedValue<boolean>;\n  /**\n   * A shared value representing additional padding from external elements\n   * (e.g., a growing multiline `TextInput` in a `KeyboardStickyView`).\n   *\n   * When this value changes:\n   * - The scrollable range is always extended/contracted (via `contentInset`).\n   * - The scroll position is conditionally adjusted based on `keyboardLiftBehavior`.\n   *\n   * Default is `undefined` (no extra padding).\n   */\n  extraContentPadding?: SharedValue<number>;\n  /**\n   * When `true`, applies a runtime workaround for a React Native 0.81+ bug\n   * where the ScrollView's `contentInset` area does not respond to touch/scroll\n   * gestures (facebook/react-native#54123).\n   *\n   * This uses Objective-C runtime method swizzling on the ScrollView's container\n   * view, which is inherently fragile. Only enable if you are affected by the\n   * upstream bug and understand the risks.\n   *\n   * iOS only. Default is `false`.\n   */\n  applyWorkaroundForContentInsetHitTestBug?: boolean;\n  /**\n   * A shared value representing a minimum inset floor (in pixels).\n   *\n   * When set, the total bottom padding is computed as:\n   * `max(blankSpace, keyboardPadding + extraContentPadding)`\n   *\n   * This means the keyboard \"absorbs\" into the minimum padding rather than adding to it:\n   * - When `blankSpace >= keyboard + extraContentPadding`: content does NOT move on keyboard open/close.\n   * - When `blankSpace < keyboard + extraContentPadding`: content moves, but only by the excess amount.\n   *\n   * Useful in AI chat apps where a sent message needs space below it (to push it to the top\n   * of the viewport) while the AI response streams in, without that space causing extra movement\n   * when the keyboard opens.\n   *\n   * Default is `undefined` (equivalent to `0` — no minimum floor).\n   */\n  blankSpace?: SharedValue<number>;\n  /**\n   * Fires whenever the effective content inset changes — the static `contentInset`\n   * prop combined with the dynamic keyboard-driven padding.\n   *\n   * Useful on Android, where the synthetic content inset is not reflected in the native\n   * `onScroll` event payload. Consumers such as virtualized lists computing their own\n   * `scrollToEnd` target can use this to track the current inset alongside scroll offsets.\n   */\n  onContentInsetChange?: (insets: ScrollViewContentInsets) => void;\n  /**\n   * Fires whenever the visibility of the content \"end\" changes — both when the user\n   * arrives at the end and when they leave it. The boolean parameter reflects the new state.\n   *\n   * For non-inverted lists, the \"end\" is the bottom of the content. For inverted lists\n   * (`inverted={true}`), the \"end\" is the top of the scroll view, where the latest messages\n   * are rendered. The same internal detection drives `keyboardLiftBehavior=\"whenAtEnd\"`.\n   *\n   * The callback can be either a plain JS function or a Reanimated worklet — the type is\n   * detected automatically. Worklets run on the UI thread; plain functions are dispatched\n   * via `runOnJS`.\n   *\n   * Fires once on mount with the initial state (after the scroll view has been measured).\n   */\n  onEndVisible?: (visible: boolean) => void;\n} & ScrollViewProps;\n"],"mappings":"","ignoreList":[]}

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

@@ -0,0 +1,207 @@
+import { interpolate } from "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
+ * ```
+ */
+export const getEffectiveHeight = (height, targetKeyboardHeight, offset) => {
+  "worklet";
+
+  if (offset === 0 || targetKeyboardHeight === 0) {
+    return height;
+  }
+  return interpolate(height, [0, targetKeyboardHeight], [0, Math.max(targetKeyboardHeight - offset, 0)]);
+};
+
+/**
+ * Check whether the scroll view is at the end of its content.
+ *
+ * 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)
+ * ```
+ */
+export const isScrollAtEnd = (scrollOffset, layoutHeight, contentHeight, inverted = false) => {
+  "worklet";
+
+  if (inverted) {
+    return scrollOffset <= AT_END_THRESHOLD;
+  }
+  return scrollOffset + layoutHeight >= contentHeight - AT_END_THRESHOLD;
+};
+
+/**
+ * Decide whether content should be shifted based on the keyboard lift behavior.
+ *
+ * @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
+ * ```
+ */
+export 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)
+ * ```
+ */
+export const getVisibleMinimumPaddingFraction = (scrollOffset, layoutHeight, contentHeight, blankSpace, inverted) => {
+  "worklet";
+
+  if (blankSpace <= 0) {
+    return 0;
+  }
+  if (inverted) {
+    // Minimum padding is in contentInset.top; visible when scroll < 0
+    return Math.max(0, Math.min(1, -scrollOffset / blankSpace));
+  }
+
+  // Minimum padding is in contentInset.bottom; visible when viewport extends past content
+  const pastContentEnd = scrollOffset + layoutHeight - contentHeight;
+  return Math.max(0, Math.min(1, pastContentEnd / blankSpace));
+};
+
+/**
+ * Compute how much of the minimum content padding absorbs the keyboard + extraContentPadding.
+ *
+ * @param blankSpace - Minimum inset floor.
+ * @param extraContentPadding - Extra content padding from external elements.
+ * @returns The portion of blankSpace that absorbs keyboard displacement.
+ * @example
+ * ```ts
+ * getMinimumPaddingAbsorbed(500, 20); // 480
+ * getMinimumPaddingAbsorbed(0, 20);   // 0
+ * ```
+ */
+export const getMinimumPaddingAbsorbed = (blankSpace, extraContentPadding) => {
+  "worklet";
+
+  return Math.max(0, blankSpace - extraContentPadding);
+};
+
+/**
+ * Compute the effective scroll displacement after minimum padding absorption.
+ *
+ * @param rawEffective - Raw effective keyboard height.
+ * @param minimumPaddingAbsorbed - Amount absorbed by minimum content padding.
+ * @returns The scroll displacement after subtracting the absorbed portion.
+ * @example
+ * ```ts
+ * getScrollEffective(300, 200); // 100
+ * getScrollEffective(300, 400); // 0
+ * ```
+ */
+export const getScrollEffective = (rawEffective, minimumPaddingAbsorbed) => {
+  "worklet";
+
+  return Math.max(0, rawEffective - minimumPaddingAbsorbed);
+};
+
+/**
+ * Compute the clamped scroll target for non-inverted lists.
+ *
+ * @param offsetBeforeScroll - Scroll position before keyboard appeared.
+ * @param keyboardHeight - Current keyboard height (used for scroll displacement).
+ * @param contentHeight - Total height of the scrollable content.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param totalPaddingForMaxScroll - Total padding to use for maxScroll calculation. When provided, used instead of keyboardHeight for the scrollable range. Defaults to keyboardHeight.
+ * @returns Clamped scroll target between 0 and maxScroll.
+ * @example
+ * ```ts
+ * clampedScrollTarget(100, 300, 1000, 800); // 400
+ * clampedScrollTarget(100, 100, 1000, 800, 500); // 200, maxScroll uses 500
+ * ```
+ */
+export 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
+ * ```
+ */
+export const computeIOSContentOffset = (relativeScroll, keyboardHeight, contentHeight, layoutHeight, inverted, totalPaddingForMaxScroll) => {
+  "worklet";
+
+  const paddingForMax = totalPaddingForMaxScroll !== undefined ? totalPaddingForMaxScroll : keyboardHeight;
+  if (inverted) {
+    const maxScroll = Math.max(contentHeight - layoutHeight, 0);
+    return Math.max(Math.min(relativeScroll - keyboardHeight, maxScroll), -paddingForMax);
+  }
+  const maxScroll = Math.max(contentHeight - layoutHeight + paddingForMax, 0);
+  return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);
+};
+//# sourceMappingURL=helpers.js.map

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

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

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

@@ -0,0 +1,143 @@
+import { useSharedValue } from "react-native-reanimated";
+import { useKeyboardHandler } from "../../../hooks";
+import useScrollState from "../../hooks/useScrollState";
+import { computeIOSContentOffset, getEffectiveHeight, getScrollEffective, getVisibleMinimumPaddingFraction, isScrollAtEnd, shouldShiftContent } from "./helpers";
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * 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 = useSharedValue(0);
+  const currentHeight = useSharedValue(0);
+  const contentOffsetY = useSharedValue(0);
+  const targetKeyboardHeight = useSharedValue(0);
+  const prevAbsorption = useSharedValue(0);
+  const {
+    layout,
+    size,
+    offset: scroll,
+    onLayout,
+    onContentSizeChange
+  } = useScrollState(scrollViewRef);
+  useKeyboardHandler({
+    onStart: e => {
+      "worklet";
+
+      if (freeze.value) {
+        return;
+      }
+      if (e.height > 0) {
+        // eslint-disable-next-line react-compiler/react-compiler
+        targetKeyboardHeight.value = e.height;
+      }
+      const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
+      const atEnd = isScrollAtEnd(scroll.value, layout.value.height, size.value.height, inverted);
+
+      // Scale minimum padding absorption by how much of it is visible.
+      // Fully visible → full absorption; fully off-screen → no absorption.
+      const visibleFraction = getVisibleMinimumPaddingFraction(scroll.value, layout.value.height, size.value.height, blankSpace.value, inverted);
+      const visiblePadding = visibleFraction * blankSpace.value;
+      const minimumPaddingAbsorbed = Math.max(0, visiblePadding - extraContentPadding.value);
+      const scrollEffective = getScrollEffective(effective, minimumPaddingAbsorbed);
+      const actualTotalPadding = Math.max(blankSpace.value, effective + extraContentPadding.value);
+
+      // persistent mode: when keyboard shrinks, clamp to valid range
+      if (keyboardLiftBehavior === "persistent" && effective < padding.value) {
+        padding.value = effective;
+        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 = getScrollEffective(padding.value, prevAbsorption.value);
+      const relativeScroll = inverted ? scroll.value + prevScrollEffective : scroll.value - prevScrollEffective;
+      padding.value = effective;
+      prevAbsorption.value = minimumPaddingAbsorbed;
+      if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {
+        // Preserve current scroll position so animated props
+        // don't re-apply a stale contentOffset when padding changes
+        contentOffsetY.value = scroll.value;
+        return;
+      }
+
+      // When blankSpace fully absorbs the keyboard opening, preserve current scroll position
+      // (only when keyboard is open — effective > 0 — not when closing)
+      if (scrollEffective === 0 && minimumPaddingAbsorbed > 0 && effective > 0) {
+        contentOffsetY.value = scroll.value;
+        return;
+      }
+      contentOffsetY.value = computeIOSContentOffset(relativeScroll, scrollEffective, size.value.height, layout.value.height, inverted, actualTotalPadding);
+    },
+    onMove: () => {
+      "worklet";
+
+      // iOS doesn't need per-frame updates (contentOffset handles it)
+    },
+    onEnd: e => {
+      "worklet";
+
+      if (freeze.value) {
+        return;
+      }
+      const effective = getEffectiveHeight(e.height, targetKeyboardHeight.value, offset);
+      padding.value = effective;
+    }
+  }, [inverted, keyboardLiftBehavior, offset, extraContentPadding]);
+  return {
+    padding,
+    currentHeight,
+    contentOffsetY,
+    scroll,
+    layout,
+    size,
+    onLayout,
+    onContentSizeChange
+  };
+}
+export { useChatKeyboard };
+//# sourceMappingURL=index.ios.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useSharedValue","useKeyboardHandler","useScrollState","computeIOSContentOffset","getEffectiveHeight","getScrollEffective","getVisibleMinimumPaddingFraction","isScrollAtEnd","shouldShiftContent","useChatKeyboard","scrollViewRef","options","inverted","keyboardLiftBehavior","freeze","offset","blankSpace","extraContentPadding","padding","currentHeight","contentOffsetY","targetKeyboardHeight","prevAbsorption","layout","size","scroll","onLayout","onContentSizeChange","onStart","e","value","height","effective","atEnd","visibleFraction","visiblePadding","minimumPaddingAbsorbed","Math","max","scrollEffective","actualTotalPadding","maxScroll","min","prevScrollEffective","relativeScroll","onMove","onEnd"],"sources":["index.ios.ts"],"sourcesContent":["import { useSharedValue } from \"react-native-reanimated\";\n\nimport { useKeyboardHandler } from \"../../../hooks\";\nimport useScrollState from \"../../hooks/useScrollState\";\n\nimport {\n  computeIOSContentOffset,\n  getEffectiveHeight,\n  getScrollEffective,\n  getVisibleMinimumPaddingFraction,\n  isScrollAtEnd,\n  shouldShiftContent,\n} from \"./helpers\";\n\nimport type { UseChatKeyboardOptions, UseChatKeyboardReturn } from \"./types\";\nimport type { AnimatedRef } from \"react-native-reanimated\";\nimport type Reanimated from \"react-native-reanimated\";\n\n/**\n * Hook that manages keyboard-driven scrolling for chat-style scroll views.\n * Calculates padding (extra scrollable space) and content shift values,\n * using iOS-specific strategy (contentOffset set once in onStart).\n *\n * @param scrollViewRef - Animated ref to the scroll view.\n * @param options - Configuration for inverted and keyboardLiftBehavior.\n * @returns Shared values for padding and contentOffsetY.\n * @example\n * ```tsx\n * const { padding, contentOffsetY } = useChatKeyboard(ref, {\n *   inverted: false,\n *   keyboardLiftBehavior: \"always\",\n * });\n * ```\n */\nfunction useChatKeyboard(\n  scrollViewRef: AnimatedRef<Reanimated.ScrollView>,\n  options: UseChatKeyboardOptions,\n): UseChatKeyboardReturn {\n  const {\n    inverted,\n    keyboardLiftBehavior,\n    freeze,\n    offset,\n    blankSpace,\n    extraContentPadding,\n  } = options;\n\n  const padding = useSharedValue(0);\n  const currentHeight = useSharedValue(0);\n  const contentOffsetY = useSharedValue(0);\n  const targetKeyboardHeight = useSharedValue(0);\n  const prevAbsorption = useSharedValue(0);\n\n  const {\n    layout,\n    size,\n    offset: scroll,\n    onLayout,\n    onContentSizeChange,\n  } = useScrollState(scrollViewRef);\n\n  useKeyboardHandler(\n    {\n      onStart: (e) => {\n        \"worklet\";\n\n        if (freeze.value) {\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.value) {\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, 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":[]}