aix 0.1.0 → 0.3.0

package/README.md

@@ -97,7 +97,8 @@ The main container component that provides keyboard-aware behavior and manages s
 |------|------|---------|-------------|
 | `shouldStartAtEnd` | `boolean` | - | Whether the scroll view should start scrolled to the end of the content. |
 | `scrollOnFooterSizeUpdate` | `object` | `{ enabled: true, scrolledToEndThreshold: 100, animated: false }` | Control the behavior of scrolling when the footer size changes. By default, changing the height of the footer will shift content up in the scroll view. |
-| `scrollEndReachedThreshold` | `number` | `max(blankSize, 200)` | The number of pixels from the bottom of the scroll view to the end of the content that is considered "near the end". Used to determine if content should shift up when keyboard opens. |
+| `scrollEndReachedThreshold` | `number` | `max(blankSize, 200)` | The number of pixels from the bottom of the scroll view to the end of the content that is considered "near the end". Used by `onScrolledNearEndChange` and to determine if content should shift up when keyboard opens. |
+| `onScrolledNearEndChange` | `(isNearEnd: boolean) => void` | - | Callback fired when the scroll position transitions between "near end" and "not near end" states. Reactive to user scrolling, content size changes, parent size changes, and keyboard height changes. Uses `scrollEndReachedThreshold` to determine the threshold. |
 | `additionalContentInsets` | `object` | - | Additional content insets applied when keyboard is open or closed. Shape: `{ top?: { whenKeyboardOpen, whenKeyboardClosed }, bottom?: { whenKeyboardOpen, whenKeyboardClosed } }` |
 | `additionalScrollIndicatorInsets` | `object` | - | Additional insets for the scroll indicator, added to existing safe area insets. Applied to `verticalScrollIndicatorInsets` on iOS. |
 | `mainScrollViewID` | `string` | - | The `nativeID` of the scroll view to use. If provided, will search for a scroll view with this `accessibilityIdentifier`. |
@@ -180,6 +181,36 @@ function Chat({ messages }) {
 }
 ```
 
+---
+
+### Scroll to End Button
+
+You can use `onScrolledNearEndChange` to show a "scroll to end" button when the user scrolls away from the bottom:
+
+```tsx
+import { Aix, useAixRef } from 'aix';
+import { useState } from 'react';
+
+function Chat() {
+  const aix = useAixRef();
+  const [isNearEnd, setIsNearEnd] = useState(false);
+
+  return (
+    <Aix
+      ref={aix}
+      scrollEndReachedThreshold={200}
+      onScrolledNearEndChange={setIsNearEnd}
+    >
+      {/* ScrollView and messages... */}
+
+      {!isNearEnd && (
+        <Button onPress={() => aix.current?.scrollToEnd(true)} />
+      )}
+    </Aix>
+  );
+}
+```
+
 ## TODOs
 
 

package/ios/HybridAix.swift

@@ -15,33 +15,35 @@ private var aixContextKey: UInt8 = 0
 protocol AixContext: AnyObject {
     /// The blank view (last cell) - used for calculating blank size
     var blankView: HybridAixCellView? { get set }
-    
+
     /// The composer view
     var composerView: HybridAixComposer? { get set }
-    
+
     /// Called when the blank view's size changes
     func reportBlankViewSizeChange(size: CGSize, index: Int)
-    
+
     /// Register a cell with the context
     func registerCell(_ cell: HybridAixCellView)
-    
+
     /// Unregister a cell from the context
     func unregisterCell(_ cell: HybridAixCellView)
-    
+
     /// Register the composer view
     func registerComposerView(_ composerView: HybridAixComposer)
-<<<<<<< HEAD
 
     /// Unregister the composer view
     func unregisterComposerView(_ composerView: HybridAixComposer)
 
     /// Called when the composer's height changes
     func reportComposerHeightChange(height: CGFloat)
-=======
-    
-    /// Unregister the composer view
-    func unregisterComposerView(_ composerView: HybridAixComposer)
->>>>>>> e1f4b6081b44dde75cebf1c5e876c6c02fd5a7ef
+
+    // MARK: - Keyboard State (for composer sticky behavior)
+
+    /// Current keyboard height
+    var keyboardHeight: CGFloat { get }
+
+    /// Keyboard height when fully open (for calculating progress)
+    var keyboardHeightWhenOpen: CGFloat { get }
 }
 
 extension UIView {
@@ -96,6 +98,10 @@ extension UIView {
 class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
 
     var penultimateCellIndex: Double?
+    
+    var shouldApplyContentInsets: Bool? = nil
+    var onWillApplyContentInsets: ((_ insets: AixContentInsets) -> Void)? = nil
+    var onScrolledNearEndChange: ((_ isNearEnd: Bool) -> Void)? = nil
 
     var additionalContentInsets: AixAdditionalContentInsetsProp?
 
@@ -202,6 +208,14 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     /// Flag to track if we're currently in an interactive keyboard dismiss
     private var isInInteractiveDismiss = false
     
+    /// Previous "scrolled near end" state for change detection
+    private var prevIsScrolledNearEnd: Bool? = nil
+    
+    /// KVO observation tokens for scroll view
+    private var contentOffsetObservation: NSKeyValueObservation?
+    private var contentSizeObservation: NSKeyValueObservation?
+    private var boundsObservation: NSKeyValueObservation?
+    
     // MARK: - Context References (weak to avoid retain cycles)
     
     weak var blankView: HybridAixCellView? = nil {
@@ -247,12 +261,41 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             scrollView.automaticallyAdjustsScrollIndicatorInsets = false
 
             setupPanGestureObserver()
+            setupScrollViewObservers(scrollView)
             applyScrollIndicatorInsets()
         }
 
         return sv
     }
     
+    /// Set up KVO observers on scroll view for contentOffset, contentSize, and bounds changes
+    private func setupScrollViewObservers(_ scrollView: UIScrollView) {
+        // Observe contentOffset (user scrolling)
+        contentOffsetObservation = scrollView.observe(\.contentOffset, options: [.new]) { [weak self] _, _ in
+            self?.updateScrolledNearEndState()
+        }
+        
+        // Observe contentSize (content size changes)
+        contentSizeObservation = scrollView.observe(\.contentSize, options: [.new]) { [weak self] _, _ in
+            self?.updateScrolledNearEndState()
+        }
+        
+        // Observe bounds (parent size changes)
+        boundsObservation = scrollView.observe(\.bounds, options: [.new]) { [weak self] _, _ in
+            self?.updateScrolledNearEndState()
+        }
+    }
+    
+    /// Clean up KVO observers
+    private func removeScrollViewObservers() {
+        contentOffsetObservation?.invalidate()
+        contentOffsetObservation = nil
+        contentSizeObservation?.invalidate()
+        contentSizeObservation = nil
+        boundsObservation?.invalidate()
+        boundsObservation = nil
+    }
+    
     /// Set up observer on scroll view's pan gesture to detect interactive keyboard dismiss
     private func setupPanGestureObserver() {
         guard let scrollView = cachedScrollView else { return }
@@ -394,14 +437,44 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         guard let scrollView else { return }
 
         let targetTop = additionalContentInsetTop
+        let targetBottom = overrideContentInsetBottom ?? self.contentInsetBottom
+        
+        // Create insets struct for callback (fields are optional in the interface)
+        let insets = AixContentInsets(
+            top: Double(targetTop),
+            left: nil,
+            bottom: Double(targetBottom),
+            right: nil
+        )
+
+        print("[aix] applyContentInset \(targetBottom)")
+        
+        // If shouldApplyContentInsets is explicitly false, call callback and return
+        if shouldApplyContentInsets == false {
+            onWillApplyContentInsets?(insets)
+            return
+        }
+        
+        // Default behavior: apply insets directly
         if scrollView.contentInset.top != targetTop {
             scrollView.contentInset.top = targetTop
         }
-
-        let targetBottom = overrideContentInsetBottom ?? self.contentInsetBottom
         if scrollView.contentInset.bottom != targetBottom {
             scrollView.contentInset.bottom = targetBottom
         }
+        
+        // Update scrolled near end state after insets change
+        updateScrolledNearEndState()
+    }
+
+    /// Centralized function to check and fire onScrolledNearEndChange callback
+    /// Called from KVO observers and after content inset changes
+    private func updateScrolledNearEndState() {
+        guard scrollView != nil else { return }
+        let isNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
+        guard isNearEnd != prevIsScrolledNearEnd else { return }
+        prevIsScrolledNearEnd = isNearEnd
+        onScrolledNearEndChange?(isNearEnd)
     }
 
     /// Apply scroll indicator insets to the scroll view
@@ -554,9 +627,12 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
                 startEvent = event
             }
         }
-        
+
         // Update keyboard state
         handleKeyboardMove(height: height, progress: progress)
+
+        // Update composer transform
+        composerView?.applyKeyboardTransform(height: height, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
     }
     
     // MARK: - Initialization
@@ -573,6 +649,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     
     deinit {
         removePanGestureObserver()
+        removeScrollViewObservers()
     }
     
     // MARK: - Lifecycle
@@ -643,6 +720,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
                 applyContentInset()
                 applyScrollIndicatorInsets()
                 scrollToEndInternal(animated: false)
+                updateScrolledNearEndState()
             }
             didScrollToEndInitially = true
         } else {
@@ -798,6 +876,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             keyboardProgress = 1.0
             applyContentInset()
             applyScrollIndicatorInsets()
+            composerView?.applyKeyboardTransform(height: targetHeight, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
             return
         }
 
@@ -812,6 +891,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             }
             self.applyContentInset()
             self.applyScrollIndicatorInsets()
+            self.composerView?.applyKeyboardTransform(height: targetHeight, heightWhenOpen: self.keyboardHeightWhenOpen, animated: false)
 
             if let (startY, endY) = self.startEvent?.interpolateContentOffsetY {
                 self.scrollView?.setContentOffset(CGPoint(x: 0, y: endY), animated: false)
@@ -839,6 +919,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             self.keyboardProgress = 0
             self.applyContentInset()
             self.applyScrollIndicatorInsets()
+            self.composerView?.applyKeyboardTransform(height: 0, heightWhenOpen: self.keyboardHeightWhenOpen, animated: false)
         }, completion: { [weak self] _ in
             self?.handleKeyboardDidMove(height: 0, progress: 0)
         })
@@ -851,6 +932,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     func keyboardDidHide(notification: NSNotification) {
         print("[Aix] keyboardDidHide")
         keyboardHeightWhenOpen = 0
+        composerView?.applyKeyboardTransform(height: 0, heightWhenOpen: 0, animated: false)
     }
 
     func keyboardWillChangeFrame(notification: NSNotification) {

package/ios/HybridAixComposer.swift

@@ -12,23 +12,34 @@ import UIKit
 /// It registers itself with the AixContext so the context can track composer height
 /// for calculating content insets
 class HybridAixComposer: HybridAixComposerSpec {
-    
+
+    // MARK: - Props
+
+    var stickToKeyboard: AixStickToKeyboard? {
+        didSet {
+            // When stickToKeyboard changes, re-apply transform with current keyboard state
+            if let ctx = cachedAixContext {
+                applyKeyboardTransform(height: ctx.keyboardHeight, heightWhenOpen: ctx.keyboardHeightWhenOpen, animated: false)
+            }
+        }
+    }
+
     // MARK: - Inner View
-    
+
     /// Custom UIView that notifies owner when layout changes
     private final class InnerView: UIView {
         weak var owner: HybridAixComposer?
-        
+
         override func layoutSubviews() {
             super.layoutSubviews()
             owner?.handleLayoutChange()
         }
-        
+
         override func didMoveToWindow() {
             super.didMoveToWindow()
             owner?.handleDidMoveToWindow()
         }
-        
+
         override func willMove(toSuperview newSuperview: UIView?) {
             super.willMove(toSuperview: newSuperview)
             if newSuperview == nil {
@@ -36,37 +47,37 @@ class HybridAixComposer: HybridAixComposerSpec {
                 owner?.handleWillRemoveFromSuperview()
             }
         }
-        
+
         // MARK: - Touch Handling
-        
+
         /// Let touches pass through to React Native children
         override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
             return false
         }
     }
-    
+
     // MARK: - Properties
-    
+
     /// The UIView for this composer
     let view: UIView
-    
+
     /// Cached reference to the AixContext (found on first access)
     private weak var cachedAixContext: AixContext?
 
     /// Last reported height (to avoid reporting unchanged heights)
     private var lastReportedHeight: CGFloat = 0
-    
+
     // MARK: - Initialization
-    
+
     override init() {
         let inner = InnerView()
         self.view = inner
         super.init()
         inner.owner = self
     }
-    
+
     // MARK: - Context Access
-    
+
     /// Get the AixContext, caching it for performance
     private func getAixContext() -> AixContext? {
         if let cached = cachedAixContext {
@@ -76,22 +87,26 @@ class HybridAixComposer: HybridAixComposerSpec {
         cachedAixContext = ctx
         return ctx
     }
-    
+
     // MARK: - Lifecycle Handlers
-    
+
     /// Called when the view is added to a window (full hierarchy is connected)
     private func handleDidMoveToWindow() {
-        guard view.window != nil else { return }
-        
+        guard view.window != nil else {
+            return
+        }
+
         // Clear cached context since hierarchy changed
         cachedAixContext = nil
-        
+
         // Register with the new context
         if let ctx = getAixContext() {
             ctx.registerComposerView(self)
+            // Initial state
+            applyKeyboardTransform(height: ctx.keyboardHeight, heightWhenOpen: ctx.keyboardHeightWhenOpen, animated: false)
         }
     }
-    
+
     /// Called when the view is about to be removed from superview
     private func handleWillRemoveFromSuperview() {
         // Unregister from context before removal
@@ -100,7 +115,7 @@ class HybridAixComposer: HybridAixComposerSpec {
         }
         cachedAixContext = nil
     }
-    
+
     /// Called when layoutSubviews fires (size may have changed)
     private func handleLayoutChange() {
         let currentHeight = view.bounds.height
@@ -109,11 +124,35 @@ class HybridAixComposer: HybridAixComposerSpec {
             getAixContext()?.reportComposerHeightChange(height: currentHeight)
         }
     }
-    
+
+    // MARK: - Keyboard handling
+
+    /// Apply keyboard transform to move the composer with the keyboard
+    /// Called by the AixContext when keyboard state changes
+    func applyKeyboardTransform(height: CGFloat, heightWhenOpen: CGFloat, animated: Bool) {
+        guard let targetView = view.superview else {
+            return
+        }
+
+        guard let settings = stickToKeyboard, settings.enabled else {
+            targetView.transform = .identity
+            return
+        }
+
+        let progress = heightWhenOpen > 0 ? height / heightWhenOpen : 0
+
+        let offsetWhenClosed = CGFloat(settings.offset?.whenKeyboardClosed ?? 0)
+        let offsetWhenOpen = CGFloat(settings.offset?.whenKeyboardOpen ?? 0)
+
+        let currentOffset = offsetWhenClosed + (offsetWhenOpen - offsetWhenClosed) * progress
+
+        let translateY = -height - currentOffset
+
+        targetView.transform = CGAffineTransform(translationX: 0, y: translateY)
+    }
+
     // MARK: - Deinitialization
-    
     deinit {
-        // Ensure we unregister when deallocated
         cachedAixContext?.unregisterComposerView(self)
     }
 }

package/lib/commonjs/aix.js

@@ -7,12 +7,27 @@ exports.Aix = void 0;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _AixConfig = _interopRequireDefault(require("../nitrogen/generated/shared/json/AixConfig.json"));
 var _react = require("react");
+var _reactNativeReanimated = _interopRequireDefault(require("react-native-reanimated"));
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const AixInternal = (0, _reactNativeNitroModules.getHostComponent)('Aix', () => _AixConfig.default);
+const AixInternal = _reactNativeReanimated.default.createAnimatedComponent((0, _reactNativeNitroModules.getHostComponent)('Aix', () => _AixConfig.default));
+
+// User-facing props type that accepts regular functions (not wrapped callbacks)
+
 const Aix = exports.Aix = /*#__PURE__*/(0, _react.forwardRef)(function Aix(props, ref) {
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(AixInternal, {
     ...props,
+    scrollOnFooterSizeUpdate: props.scrollOnFooterSizeUpdate ?? {
+      enabled: true,
+      scrolledToEndThreshold: 100,
+      animated: false
+    }
+    // Wrap onWillApplyContentInsets with callback() if provided
+    ,
+    onWillApplyContentInsets: props.onWillApplyContentInsets ? (0, _reactNativeNitroModules.callback)(props.onWillApplyContentInsets) : undefined
+    // Wrap onScrolledNearEndChange with callback() if provided
+    ,
+    onScrolledNearEndChange: props.onScrolledNearEndChange ? (0, _reactNativeNitroModules.callback)(props.onScrolledNearEndChange) : undefined,
     hybridRef: ref ? (0, _reactNativeNitroModules.callback)(r => {
       if (typeof ref === 'function') {
         ref(r);

package/lib/commonjs/aix.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","_AixConfig","_interopRequireDefault","_react","_jsxRuntime","e","__esModule","default","AixInternal","getHostComponent","AixConfig","Aix","exports","forwardRef","props","ref","jsx","hybridRef","callback","r","current","undefined"],"sourceRoot":"../../src","sources":["aix.tsx"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAKA,IAAAC,UAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAAkC,IAAAI,WAAA,GAAAJ,OAAA;AAAA,SAAAE,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAIlC,MAAMG,WAAW,GAAG,IAAAC,yCAAgB,EAClC,KAAK,EACL,MAAMC,kBACR,CAAC;AAEM,MAAMC,GAAG,GAAAC,OAAA,CAAAD,GAAA,gBAAG,IAAAE,iBAAU,EAC3B,SAASF,GAAGA,CAACG,KAAK,EAAEC,GAAG,EAAE;EACvB,oBACE,IAAAX,WAAA,CAAAY,GAAA,EAACR,WAAW;IAAA,GACNM,KAAK;IACTG,SAAS,EACPF,GAAG,GACC,IAAAG,iCAAQ,EAAEC,CAAC,IAAK;MACd,IAAI,OAAOJ,GAAG,KAAK,UAAU,EAAE;QAC7BA,GAAG,CAACI,CAAC,CAAC;MACR,CAAC,MAAM;QACLJ,GAAG,CAACK,OAAO,GAAGD,CAAC;MACjB;IACF,CAAC,CAAC,GACFE;EACL,CACF,CAAC;AAEN,CACF,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_AixConfig","_interopRequireDefault","_react","_reactNativeReanimated","_jsxRuntime","e","__esModule","default","AixInternal","Animated","createAnimatedComponent","getHostComponent","AixConfig","Aix","exports","forwardRef","props","ref","jsx","scrollOnFooterSizeUpdate","enabled","scrolledToEndThreshold","animated","onWillApplyContentInsets","callback","undefined","onScrolledNearEndChange","hybridRef","r","current"],"sourceRoot":"../../src","sources":["aix.tsx"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAKA,IAAAC,UAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AACA,IAAAI,sBAAA,GAAAF,sBAAA,CAAAF,OAAA;AAA8C,IAAAK,WAAA,GAAAL,OAAA;AAAA,SAAAE,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAI9C,MAAMG,WAAW,GAAGC,8BAAQ,CAACC,uBAAuB,CAAC,IAAAC,yCAAgB,EACnE,KAAK,EACL,MAAMC,kBACR,CAAC,CAAC;;AAEF;;AASO,MAAMC,GAAG,GAAAC,OAAA,CAAAD,GAAA,gBAAG,IAAAE,iBAAU,EAC3B,SAASF,GAAGA,CAACG,KAAK,EAAEC,GAAG,EAAE;EACvB,oBACE,IAAAb,WAAA,CAAAc,GAAA,EAACV,WAAW;IAAA,GACNQ,KAAK;IACTG,wBAAwB,EACtBH,KAAK,CAACG,wBAAwB,IAAI;MAChCC,OAAO,EAAE,IAAI;MACbC,sBAAsB,EAAE,GAAG;MAC3BC,QAAQ,EAAE;IACZ;IAEF;IAAA;IACAC,wBAAwB,EACtBP,KAAK,CAACO,wBAAwB,GAC1B,IAAAC,iCAAQ,EAACR,KAAK,CAACO,wBAAwB,CAAC,GACxCE;IAEN;IAAA;IACAC,uBAAuB,EACrBV,KAAK,CAACU,uBAAuB,GACzB,IAAAF,iCAAQ,EAACR,KAAK,CAACU,uBAAuB,CAAC,GACvCD,SACL;IACDE,SAAS,EACPV,GAAG,GACC,IAAAO,iCAAQ,EAAEI,CAAC,IAAK;MAChB,IAAI,OAAOX,GAAG,KAAK,UAAU,EAAE;QAC7BA,GAAG,CAACW,CAAC,CAAC;MACR,CAAC,MAAM;QACLX,GAAG,CAACY,OAAO,GAAGD,CAAC;MACjB;IACF,CAAC,CAAC,GACAH;EACL,CACF,CAAC;AAEN,CACF,CAAC","ignoreList":[]}

package/lib/commonjs/hooks/useContentInsetHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContentInsetHandler = useContentInsetHandler;
+var _react = require("react");
+/**
+ * Hook that creates a stable callback handler for content inset updates.
+ * Use this with `onWillApplyContentInsets` prop to receive inset updates.
+ *
+ * @example
+ * ```tsx
+ * const bottomInset = useSharedValue<number | null>(null)
+ *
+ * const contentInsetHandler = useContentInsetHandler((insets) => {
+ *   bottomInset.value = insets.bottom ?? null
+ * })
+ *
+ * <Aix
+ *   shouldApplyContentInsets={false}
+ *   onWillApplyContentInsets={contentInsetHandler}
+ * />
+ * ```
+ */
+function useContentInsetHandler(handler, dependencies = []) {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return (0, _react.useCallback)(handler, dependencies);
+}
+//# sourceMappingURL=useContentInsetHandler.js.map

package/lib/commonjs/hooks/useContentInsetHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","useContentInsetHandler","handler","dependencies","useCallback"],"sourceRoot":"../../../src","sources":["hooks/useContentInsetHandler.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,sBAAsBA,CACpCC,OAA2C,EAC3CC,YAAuB,GAAG,EAAE,EAC5B;EACA;EACA,OAAO,IAAAC,kBAAW,EAACF,OAAO,EAAEC,YAAY,CAAC;AAC3C","ignoreList":[]}

package/lib/commonjs/index.js

@@ -7,7 +7,8 @@ var _exportNames = {
   AixCell: true,
   useAixRef: true,
   Aix: true,
-  AixFooter: true
+  AixFooter: true,
+  useContentInsetHandler: true
 };
 Object.defineProperty(exports, "Aix", {
   enumerable: true,
@@ -23,6 +24,12 @@ Object.defineProperty(exports, "AixFooter", {
   }
 });
 exports.useAixRef = useAixRef;
+Object.defineProperty(exports, "useContentInsetHandler", {
+  enumerable: true,
+  get: function () {
+    return _useContentInsetHandler.useContentInsetHandler;
+  }
+});
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _AixCellViewConfig = _interopRequireDefault(require("../nitrogen/generated/shared/json/AixCellViewConfig.json"));
 var _react = require("react");
@@ -40,6 +47,7 @@ Object.keys(_fadeIn).forEach(function (key) {
 });
 var _aix = require("./aix");
 var _footer = require("./footer");
+var _useContentInsetHandler = require("./hooks/useContentInsetHandler");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const AixCell = exports.AixCell = (0, _reactNativeNitroModules.getHostComponent)('AixCellView', () => _AixCellViewConfig.default);
 function useAixRef() {

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","_AixCellViewConfig","_interopRequireDefault","_react","_fadeIn","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_aix","_footer","e","__esModule","default","AixCell","getHostComponent","AixCellViewConfig","useAixRef","useRef"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAEA,IAAAI,OAAA,GAAAJ,OAAA;AAAAK,MAAA,CAAAC,IAAA,CAAAF,OAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,OAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,OAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,IAAA,GAAAjB,OAAA;AACA,IAAAkB,OAAA,GAAAlB,OAAA;AAAoC,SAAAE,uBAAAiB,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE7B,MAAMG,OAAO,GAAAT,OAAA,CAAAS,OAAA,GAAG,IAAAC,yCAAgB,EACrC,aAAa,EACb,MAAMC,0BACR,CAAC;AAIM,SAASC,SAASA,CAAA,EAAG;EAC1B,OAAO,IAAAC,aAAM,EAAgB,IAAI,CAAC;AACpC","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_AixCellViewConfig","_interopRequireDefault","_react","_fadeIn","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_aix","_footer","_useContentInsetHandler","e","__esModule","default","AixCell","getHostComponent","AixCellViewConfig","useAixRef","useRef"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAEA,IAAAI,OAAA,GAAAJ,OAAA;AAAAK,MAAA,CAAAC,IAAA,CAAAF,OAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,OAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,OAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,IAAAS,IAAA,GAAAjB,OAAA;AACA,IAAAkB,OAAA,GAAAlB,OAAA;AACA,IAAAmB,uBAAA,GAAAnB,OAAA;AAAuE,SAAAE,uBAAAkB,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAGhE,MAAMG,OAAO,GAAAV,OAAA,CAAAU,OAAA,GAAG,IAAAC,yCAAgB,EACrC,aAAa,EACb,MAAMC,0BACR,CAAC;AAIM,SAASC,SAASA,CAAA,EAAG;EAC1B,OAAO,IAAAC,aAAM,EAAgB,IAAI,CAAC;AACpC","ignoreList":[]}

package/lib/module/aix.js

@@ -3,11 +3,26 @@
 import { callback, getHostComponent } from 'react-native-nitro-modules';
 import AixConfig from '../nitrogen/generated/shared/json/AixConfig.json';
 import { forwardRef } from 'react';
+import Animated from 'react-native-reanimated';
 import { jsx as _jsx } from "react/jsx-runtime";
-const AixInternal = getHostComponent('Aix', () => AixConfig);
+const AixInternal = Animated.createAnimatedComponent(getHostComponent('Aix', () => AixConfig));
+
+// User-facing props type that accepts regular functions (not wrapped callbacks)
+
 export const Aix = /*#__PURE__*/forwardRef(function Aix(props, ref) {
   return /*#__PURE__*/_jsx(AixInternal, {
     ...props,
+    scrollOnFooterSizeUpdate: props.scrollOnFooterSizeUpdate ?? {
+      enabled: true,
+      scrolledToEndThreshold: 100,
+      animated: false
+    }
+    // Wrap onWillApplyContentInsets with callback() if provided
+    ,
+    onWillApplyContentInsets: props.onWillApplyContentInsets ? callback(props.onWillApplyContentInsets) : undefined
+    // Wrap onScrolledNearEndChange with callback() if provided
+    ,
+    onScrolledNearEndChange: props.onScrolledNearEndChange ? callback(props.onScrolledNearEndChange) : undefined,
     hybridRef: ref ? callback(r => {
       if (typeof ref === 'function') {
         ref(r);

package/lib/module/aix.js.map

@@ -1 +1 @@
-{"version":3,"names":["callback","getHostComponent","AixConfig","forwardRef","jsx","_jsx","AixInternal","Aix","props","ref","hybridRef","r","current","undefined"],"sourceRoot":"../../src","sources":["aix.tsx"],"mappings":";;AAAA,SACEA,QAAQ,EACRC,gBAAgB,QAEX,4BAA4B;AACnC,OAAOC,SAAS,MAAM,kDAAkD;AAExE,SAASC,UAAU,QAAQ,OAAO;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAIlC,MAAMC,WAAW,GAAGL,gBAAgB,CAClC,KAAK,EACL,MAAMC,SACR,CAAC;AAED,OAAO,MAAMK,GAAG,gBAAGJ,UAAU,CAC3B,SAASI,GAAGA,CAACC,KAAK,EAAEC,GAAG,EAAE;EACvB,oBACEJ,IAAA,CAACC,WAAW;IAAA,GACNE,KAAK;IACTE,SAAS,EACPD,GAAG,GACCT,QAAQ,CAAEW,CAAC,IAAK;MACd,IAAI,OAAOF,GAAG,KAAK,UAAU,EAAE;QAC7BA,GAAG,CAACE,CAAC,CAAC;MACR,CAAC,MAAM;QACLF,GAAG,CAACG,OAAO,GAAGD,CAAC;MACjB;IACF,CAAC,CAAC,GACFE;EACL,CACF,CAAC;AAEN,CACF,CAAC","ignoreList":[]}
+{"version":3,"names":["callback","getHostComponent","AixConfig","forwardRef","Animated","jsx","_jsx","AixInternal","createAnimatedComponent","Aix","props","ref","scrollOnFooterSizeUpdate","enabled","scrolledToEndThreshold","animated","onWillApplyContentInsets","undefined","onScrolledNearEndChange","hybridRef","r","current"],"sourceRoot":"../../src","sources":["aix.tsx"],"mappings":";;AAAA,SACEA,QAAQ,EACRC,gBAAgB,QAEX,4BAA4B;AACnC,OAAOC,SAAS,MAAM,kDAAkD;AAExE,SAASC,UAAU,QAA6B,OAAO;AACvD,OAAOC,QAAQ,MAAM,yBAAyB;AAAA,SAAAC,GAAA,IAAAC,IAAA;AAI9C,MAAMC,WAAW,GAAGH,QAAQ,CAACI,uBAAuB,CAACP,gBAAgB,CACnE,KAAK,EACL,MAAMC,SACR,CAAC,CAAC;;AAEF;;AASA,OAAO,MAAMO,GAAG,gBAAGN,UAAU,CAC3B,SAASM,GAAGA,CAACC,KAAK,EAAEC,GAAG,EAAE;EACvB,oBACEL,IAAA,CAACC,WAAW;IAAA,GACNG,KAAK;IACTE,wBAAwB,EACtBF,KAAK,CAACE,wBAAwB,IAAI;MAChCC,OAAO,EAAE,IAAI;MACbC,sBAAsB,EAAE,GAAG;MAC3BC,QAAQ,EAAE;IACZ;IAEF;IAAA;IACAC,wBAAwB,EACtBN,KAAK,CAACM,wBAAwB,GAC1BhB,QAAQ,CAACU,KAAK,CAACM,wBAAwB,CAAC,GACxCC;IAEN;IAAA;IACAC,uBAAuB,EACrBR,KAAK,CAACQ,uBAAuB,GACzBlB,QAAQ,CAACU,KAAK,CAACQ,uBAAuB,CAAC,GACvCD,SACL;IACDE,SAAS,EACPR,GAAG,GACCX,QAAQ,CAAEoB,CAAC,IAAK;MAChB,IAAI,OAAOT,GAAG,KAAK,UAAU,EAAE;QAC7BA,GAAG,CAACS,CAAC,CAAC;MACR,CAAC,MAAM;QACLT,GAAG,CAACU,OAAO,GAAGD,CAAC;MACjB;IACF,CAAC,CAAC,GACAH;EACL,CACF,CAAC;AAEN,CACF,CAAC","ignoreList":[]}

package/lib/module/hooks/useContentInsetHandler.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { useCallback } from 'react';
+/**
+ * Hook that creates a stable callback handler for content inset updates.
+ * Use this with `onWillApplyContentInsets` prop to receive inset updates.
+ *
+ * @example
+ * ```tsx
+ * const bottomInset = useSharedValue<number | null>(null)
+ *
+ * const contentInsetHandler = useContentInsetHandler((insets) => {
+ *   bottomInset.value = insets.bottom ?? null
+ * })
+ *
+ * <Aix
+ *   shouldApplyContentInsets={false}
+ *   onWillApplyContentInsets={contentInsetHandler}
+ * />
+ * ```
+ */
+export function useContentInsetHandler(handler, dependencies = []) {
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useCallback(handler, dependencies);
+}
+//# sourceMappingURL=useContentInsetHandler.js.map

package/lib/module/hooks/useContentInsetHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useContentInsetHandler","handler","dependencies"],"sourceRoot":"../../../src","sources":["hooks/useContentInsetHandler.ts"],"mappings":";;AAAA,SAASA,WAAW,QAAQ,OAAO;AAGnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CACpCC,OAA2C,EAC3CC,YAAuB,GAAG,EAAE,EAC5B;EACA;EACA,OAAOH,WAAW,CAACE,OAAO,EAAEC,YAAY,CAAC;AAC3C","ignoreList":[]}

package/lib/module/index.js

@@ -6,6 +6,7 @@ import { useRef } from 'react';
 export * from './fade-in';
 export { Aix } from './aix';
 export { AixFooter } from './footer';
+export { useContentInsetHandler } from './hooks/useContentInsetHandler';
 export const AixCell = getHostComponent('AixCellView', () => AixCellViewConfig);
 export function useAixRef() {
   return useRef(null);

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["getHostComponent","AixCellViewConfig","useRef","Aix","AixFooter","AixCell","useAixRef"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,QAAwB,4BAA4B;AAC7E,OAAOC,iBAAiB,MAAM,0DAA0D;AAExF,SAASC,MAAM,QAAQ,OAAO;AAE9B,cAAc,WAAW;AAEzB,SAASC,GAAG,QAAqB,OAAO;AACxC,SAASC,SAAS,QAAQ,UAAU;AAEpC,OAAO,MAAMC,OAAO,GAAGL,gBAAgB,CACrC,aAAa,EACb,MAAMC,iBACR,CAAC;AAID,OAAO,SAASK,SAASA,CAAA,EAAG;EAC1B,OAAOJ,MAAM,CAAgB,IAAI,CAAC;AACpC","ignoreList":[]}
+{"version":3,"names":["getHostComponent","AixCellViewConfig","useRef","Aix","AixFooter","useContentInsetHandler","AixCell","useAixRef"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,gBAAgB,QAAwB,4BAA4B;AAC7E,OAAOC,iBAAiB,MAAM,0DAA0D;AAExF,SAASC,MAAM,QAAQ,OAAO;AAE9B,cAAc,WAAW;AAEzB,SAASC,GAAG,QAAqB,OAAO;AACxC,SAASC,SAAS,QAAQ,UAAU;AACpC,SAASC,sBAAsB,QAAQ,gCAAgC;AAGvE,OAAO,MAAMC,OAAO,GAAGN,gBAAgB,CACrC,aAAa,EACb,MAAMC,iBACR,CAAC;AAID,OAAO,SAASM,SAASA,CAAA,EAAG;EAC1B,OAAOL,MAAM,CAAgB,IAAI,CAAC;AACpC","ignoreList":[]}