aix 0.7.0 → 0.7.1-alpha.2

package/ios/HybridAix.swift

@@ -38,7 +38,6 @@ protocol AixContext: AnyObject {
     func reportComposerHeightChange(height: CGFloat)
 
     // MARK: - Keyboard State (for composer sticky behavior)
-
     /// Current keyboard height
     var keyboardHeight: CGFloat { get }
 
@@ -107,11 +106,9 @@ extension UIView {
 }
 
 // MARK: - HybridAix (Root Context)
-
 class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
 
     var penultimateCellIndex: Double?
-    
     var shouldApplyContentInsets: Bool? = nil
     var applyContentInsetDelay: Double? = nil
     var onWillApplyContentInsets: ((_ insets: AixContentInsets) -> Void)? = nil
@@ -126,15 +123,18 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         }
     }
 
-    var scrollOnComposerSizeUpdate: AixScrollOnFooterSizeUpdate?
-
     var mainScrollViewID: String? {
         didSet {
             guard mainScrollViewID != oldValue else { return }
-            removePanGestureObserver()
+            // Reset all scroll view and cell state when ID changes
             removeScrollViewObservers()
             cachedScrollView = nil
-            didSetupPanGestureObserver = false
+            didScrollToEndInitially = false
+            prevIsScrolledNearEnd = nil
+            blankView = nil
+            cells.removeAllObjects()
+            lastReportedBlankViewSize = (size: .zero, index: 0)
+            lastCalculatedBlankSize = 0
         }
     }
     
@@ -156,7 +156,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
                 self.startEvent = KeyboardStartEvent(
                     scrollY: event.scrollY,
                     isOpening: event.isOpening,
-                    isInteractive: event.isInteractive,
                     interpolateContentOffsetY: nil
                 )
             }
@@ -165,11 +164,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         }
     }
 
-    private var didScrollToEndInitiallyForId: String? = nil
-
-    private var didScrollToEndInitially: Bool {
-        return didScrollToEndInitiallyForId == (mainScrollViewID ?? "")
-    }
+    private var didScrollToEndInitially: Bool = false
     
     // MARK: - Inner View
     
@@ -217,7 +212,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     }
 
     // MARK: - Private State
-    
     /// Queued scroll operation waiting for blank view to update
     private var queuedScrollToEnd: QueuedScrollToEnd? = nil
     
@@ -228,32 +222,20 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     /// Cached scroll view reference (weak to avoid retain cycles)
     private weak var cachedScrollView: UIScrollView?
     
-    /// Flag to track if we've set up the pan gesture observer
-    private var didSetupPanGestureObserver = false
-    
-    /// 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 {
-        didSet {
-            // Could add observers or callbacks here when blank view changes
-        }
-    }
+    weak var blankView: HybridAixCellView? = nil
     
     weak var composerView: HybridAixComposer? = nil
     
     // MARK: - Computed Properties
-    
     /// Find the scroll view within our view hierarchy
     /// We search from the superview (HybridAixComponent) since the scroll view
     /// is a sibling of our inner view, not a child
@@ -268,25 +250,18 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         var sv: UIScrollView? = nil
         if let scrollViewID = mainScrollViewID, !scrollViewID.isEmpty {
             sv = searchRoot.findScrollView(withIdentifier: scrollViewID)
-            if sv != nil {
-                print("[Aix] scrollView found by ID '\(scrollViewID)': \(String(describing: sv))")
-            }
         }
 
         // Fallback to default subview iteration if not found by ID
         if sv == nil {
             sv = searchRoot.findScrollView()
-            print("[Aix] scrollView found by iteration: \(String(describing: sv))")
         }
 
         cachedScrollView = sv
 
-        // Set up pan gesture observer when we find the scroll view
-        if let scrollView = sv, !didSetupPanGestureObserver {
-            // Disable automatic scroll indicator inset adjustment so we can control it manually
+        // Set up observers when we find the scroll view
+        if let scrollView = sv {
             scrollView.automaticallyAdjustsScrollIndicatorInsets = false
-
-            setupPanGestureObserver()
             setupScrollViewObservers(scrollView)
             applyScrollIndicatorInsets()
         }
@@ -322,89 +297,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         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 }
-        didSetupPanGestureObserver = true
-        
-        scrollView.panGestureRecognizer.addTarget(self, action: #selector(handlePanGesture(_:)))
-        print("[Aix] Pan gesture observer set up")
-    }
-    
-    /// Clean up pan gesture observer to avoid retain cycles
-    private func removePanGestureObserver() {
-        guard didSetupPanGestureObserver, let scrollView = cachedScrollView else { return }
-        scrollView.panGestureRecognizer.removeTarget(self, action: #selector(handlePanGesture(_:)))
-        didSetupPanGestureObserver = false
-    }
-    
-    /// Handle pan gesture state changes to detect interactive keyboard dismiss
-    @objc private func handlePanGesture(_ gesture: UIPanGestureRecognizer) {
-        guard let scrollView = cachedScrollView,
-              scrollView.keyboardDismissMode == .interactive,
-              keyboardHeight > 0 else { return }
-
-        switch gesture.state {
-        case .began, .changed:
-            // Check if finger has reached the top of composer (or keyboard if no composer)
-            if !isInInteractiveDismiss && isFingerAtComposerTop(gesture: gesture) {
-                startInteractiveKeyboardDismiss()
-            }
-
-        case .ended, .cancelled, .failed:
-            if isInInteractiveDismiss {
-                // The keyboard manager will handle the end via notifications
-            }
-
-        default:
-            break
-        }
-    }
-
-    /// Check if the finger position has reached the top of the composer view
-    private func isFingerAtComposerTop(gesture: UIPanGestureRecognizer) -> Bool {
-        guard let window = view.window else { return false }
-
-        // Get finger location in window coordinates
-        let fingerLocationInWindow = gesture.location(in: window)
-
-        // Get the threshold Y position (top of composer, or top of keyboard if no composer)
-        let thresholdY: CGFloat
-        if let composerView = composerView?.view, let composerWindow = composerView.window {
-            // Convert composer's frame to window coordinates
-            let composerFrameInWindow = composerView.convert(composerView.bounds, to: composerWindow)
-            thresholdY = composerFrameInWindow.minY
-        } else {
-            // Fallback: use keyboard top position
-            let screenHeight = UIScreen.main.bounds.height
-            thresholdY = screenHeight - keyboardHeight
-        }
-
-        // Finger has reached the composer top when its Y >= threshold
-        return fingerLocationInWindow.y >= thresholdY
-    }
-    
-    /// Start tracking an interactive keyboard dismiss
-    private func startInteractiveKeyboardDismiss() {
-        return // this is totally broken rn, full of false positives
-        guard !isInInteractiveDismiss else { return }
-        isInInteractiveDismiss = true
-        
-        let scrollY = scrollView?.contentOffset.y ?? 0
-        
-        print("[Aix] Starting interactive keyboard dismiss from height=\(keyboardHeight), scrollY=\(scrollY)")
-        
-        // Calculate proper interpolation values (same as non-interactive close)
-        let interpolation = getContentOffsetYWhenClosing(scrollY: scrollY)
-        
-        startEvent = KeyboardStartEvent(
-            scrollY: scrollY,
-            isOpening: false,
-            isInteractive: true,
-            interpolateContentOffsetY: interpolation, 
-        )
-    }
-    
     /// Height of the composer view
     private var composerHeight: CGFloat {
         let h = composerView?.view.bounds.height ?? 0
@@ -429,33 +321,58 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         return 0
     }
 
+    /// Cache the last successfully calculated blank size to avoid jumps when cells are temporarily missing
+    private var lastCalculatedBlankSize: CGFloat = 0
+
     private func calculateBlankSize(keyboardHeight: CGFloat, additionalContentInsetBottom: CGFloat) -> CGFloat {
-        guard let scrollView, let blankView else { return 0 }
+        guard let scrollView, let blankView else { return lastCalculatedBlankSize }
         
+        let blankViewIndex = Int(blankView.index)
+        let endIndex = blankViewIndex - 1
         let startIndex: Int
-        let endIndex = Int(blankView.index) - 1
+        
         if let penultimateCellIndex {
-            startIndex = Int(penultimateCellIndex)
+            let penultimate = Int(penultimateCellIndex)
+            // Ensure penultimateCellIndex is valid (not beyond current cells)
+            // If penultimateCellIndex >= blankViewIndex, it means props are out of sync with cells
+            if penultimate >= blankViewIndex {
+                // Props are ahead of cells - use previous behavior (last cell before blank)
+                startIndex = endIndex
+            } else {
+                startIndex = penultimate
+            }
         } else {
             startIndex = endIndex
         }
         
         var cellsBeforeBlankViewHeight: CGFloat = 0
-        if startIndex <= endIndex {
+        var hasMissingCells = false
+        if startIndex >= 0 && startIndex <= endIndex {
             for i in startIndex...endIndex {
                 if let cell = getCell(index: i) {
                     cellsBeforeBlankViewHeight += cell.view.frame.height
+                } else {
+                    hasMissingCells = true
                 }
             }
         }
         
-        let blankViewHeight = blankView.view.frame.height
+        // If any required cells are missing, return the last known good value to avoid jumps
+        // When all cells register, we'll calculate correctly
+        if hasMissingCells {
+            return lastCalculatedBlankSize
+        }
         
-        // Calculate visible area above all bottom chrome (keyboard, composer, additional insets)
-        // The blank size fills the remaining space so the last message can scroll to the top
+        let blankViewHeight = blankView.view.frame.height
         let visibleAreaHeight = scrollView.bounds.height - keyboardHeight - composerHeight - additionalContentInsetBottom
         let inset = visibleAreaHeight - blankViewHeight - cellsBeforeBlankViewHeight
-        return max(0, inset)
+        
+        // Cache this value for when cells are temporarily missing
+        lastCalculatedBlankSize = inset
+        
+        // Return raw inset value (can be negative when cells are taller than visible area)
+        // The clamping happens in contentInsetBottom to ensure total inset is never negative
+        return inset
     }
     
     /// Calculate the blank size - the space needed to push content up
@@ -467,7 +384,9 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     /// The content inset for the bottom of the scroll view
     
     private func calculateContentInsetBottom(keyboardHeight: CGFloat, blankSize: CGFloat, additionalContentInsetBottom: CGFloat) -> CGFloat {
-        return blankSize + keyboardHeight + composerHeight + additionalContentInsetBottom
+        // Clamp to 0 here instead of in calculateBlankSize to preserve correct math
+        // when keyboard is open and blankSize goes negative
+        return max(0, blankSize + keyboardHeight + composerHeight + additionalContentInsetBottom)
     }
     var contentInsetBottom: CGFloat {
         return calculateContentInsetBottom(keyboardHeight: self.keyboardHeight, blankSize: self.blankSize, additionalContentInsetBottom: self.additionalContentInsetBottom)
@@ -475,12 +394,12 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     
     /// Apply the current content inset to the scroll view
     func applyContentInset(contentInsetBottom overrideContentInsetBottom: CGFloat? = nil) {
-        guard let scrollView else { return }
+        guard let _ = scrollView else { return }
 
         let targetTop = additionalContentInsetTop
         let targetBottom = overrideContentInsetBottom ?? self.contentInsetBottom
         
-        // Create insets struct for callback (fields are optional in the interface)
+        // Create insets struct for callback
         let insets = AixContentInsets(
             top: Double(targetTop),
             left: nil,
@@ -488,10 +407,8 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             right: nil
         )
 
-        print("[aix] applyContentInset \(targetBottom)")
         onWillApplyContentInsets?(insets)
         
-        // If shouldApplyContentInsets is explicitly false, call callback and return
         if shouldApplyContentInsets == false {
             return
         }
@@ -518,7 +435,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     }
 
     /// Centralized function to check and fire onScrolledNearEndChange callback
-    /// Called from KVO observers and after content inset changes
     private func updateScrolledNearEndState() {
         guard didScrollToEndInitially, scrollView != nil else { return }
         let isNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
@@ -560,9 +476,15 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         }
     }
 
+    /// Apply both content insets and scroll indicator insets
+    private func applyAllInsets() {
+        applyContentInset()
+        applyScrollIndicatorInsets()
+    }
+
     private func scrollToEndInternal(animated: Bool?) {
         guard let scrollView else { return }
-        
+
         // Calculate the offset to show the bottom of content
         let bottomOffset = CGPoint(
             x: 0,
@@ -572,8 +494,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     }
 
     
-    // MARK: - Keyboard Observer (notification-based)
-
+    // MARK: - Keyboard Management
     private lazy var keyboardNotifications: KeyboardNotifications = {
         return KeyboardNotifications(notifications: [.willShow, .willHide, .didShow, .didHide, .willChangeFrame], delegate: self)
     }()
@@ -582,7 +503,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     private struct KeyboardStartEvent {
         let scrollY: CGFloat
         let isOpening: Bool
-        var isInteractive: Bool
         let interpolateContentOffsetY: (CGFloat, CGFloat)?
     }
     
@@ -596,11 +516,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
             keyboardHeightWhenOpen = targetHeight
         }
         
-        // If we're already in an interactive dismiss, don't overwrite
-        if isInInteractiveDismiss {
-            return
-        }
-        
         let scrollY = scrollView?.contentOffset.y ?? 0
         
         var interpolateContentOffsetY: (CGFloat, CGFloat)? = {
@@ -612,102 +527,50 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         }()
         
         if queuedScrollToEnd != nil {
-            // don't interpolate the keyboard if we're planning to scroll to end
             interpolateContentOffsetY = nil
         }
         
-        print("[Aix] handleKeyboardWillMove: isOpening=\(isOpening), interpolate=\(String(describing: interpolateContentOffsetY))")
-        
         startEvent = KeyboardStartEvent(
             scrollY: scrollY,
             isOpening: isOpening,
-            isInteractive: false,
             interpolateContentOffsetY: interpolateContentOffsetY
         )
     }
     
-    /// Handle keyboard frame updates during animation
-    private func handleKeyboardMove(height: CGFloat, progress: CGFloat) {
-        if keyboardHeightWhenOpen > 0 {
-            keyboardProgress = height / keyboardHeightWhenOpen
-        }
-        keyboardHeight = height
-        
-        guard let startEvent else { return }
-
-        applyContentInset()
-        applyScrollIndicatorInsets()
-
-        if let (startY, endY) = startEvent.interpolateContentOffsetY {
-            // Normalize progress to always go from 0 to 1 (start to end)
-            // For opening: progress goes 0→1, so use as-is
-            // For closing: progress goes 1→0, so invert it
-            let normalizedProgress = startEvent.isOpening ? progress : (1 - progress)
-            let newScrollY = startY + (endY - startY) * normalizedProgress
-            scrollView?.setContentOffset(CGPoint(x: 0, y: newScrollY), animated: false)
-        }
-    }
-    
     /// Handle keyboard animation end
     private func handleKeyboardDidMove(height: CGFloat, progress: CGFloat) {
-        // Ensure final height is applied
         keyboardHeight = height
         if keyboardHeightWhenOpen > 0 {
             keyboardProgress = height / keyboardHeightWhenOpen
         }
 
-        applyContentInset()
-        applyScrollIndicatorInsets()
+        applyAllInsets()
 
         startEvent = nil
-        isInInteractiveDismiss = false
         
         if queuedScrollToEnd?.waitForKeyboardToEnd == true {
             flushQueuedScrollToEnd(force: true)
         }
     }
     
-    /// Handle interactive keyboard dismissal
-    private func handleKeyboardMoveInteractive(height: CGFloat, progress: CGFloat) {
-        // Mark that we're in an interactive dismiss if not already
-        if !isInInteractiveDismiss && startEvent != nil {
-            isInInteractiveDismiss = true
-            if var event = startEvent {
-                event.isInteractive = true
-                startEvent = event
-            }
-        }
-
-        // Update keyboard state
-        handleKeyboardMove(height: height, progress: progress)
-
-        // Update composer transform
-        composerView?.applyKeyboardTransform(height: height, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
-    }
-    
     // MARK: - Initialization
-    
     override init() {
         let inner = InnerView()
         self.view = inner
         super.init()
         inner.owner = self
-        print("[Aix] HybridAix initialized, attaching context to view")
         // Attach this context to our inner view
         view.aixContext = self
     }
     
     deinit {
-        removePanGestureObserver()
         removeScrollViewObservers()
     }
     
     // MARK: - Lifecycle
-
     /// Called when our view is added to or removed from the HybridAixComponent
     private func handleDidMoveToSuperview() {
         if let superview = view.superview {
-            print("[Aix] View added to superview: \(type(of: superview)), attaching context")
             // Attach context to the superview (HybridAixComponent) so children can find it
             superview.aixContext = self
 
@@ -753,42 +616,52 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     }
 
     // MARK: - AixContext Protocol
-
     private var lastReportedBlankViewSize = (size: CGSize.zero, index: 0)
     
     func reportBlankViewSizeChange(size: CGSize, index: Int) {
         let didAlreadyUpdate = size.height == lastReportedBlankViewSize.size.height && size.width == lastReportedBlankViewSize.size.width && index == lastReportedBlankViewSize.index
-        if didAlreadyUpdate {
-            return
-        }
+        if didAlreadyUpdate { return }
 
         lastReportedBlankViewSize = (size: size, index: index)
 
-        // Check if we have a queued scroll waiting for this index
+        // Initial mount setup (tied to mainScrollViewID)
         if !didScrollToEndInitially {
             UIView.performWithoutAnimation {
-                applyContentInset()
-                applyScrollIndicatorInsets()
-                scrollToEndInternal(animated: false)
+                applyAllInsets()
+                
+                if shouldStartAtEnd {
+                    scrollToEndInternal(animated: false)
+                }
+                
+                // Set initial state based on actual scroll position after layout
                 prevIsScrolledNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
             }
-            didScrollToEndInitiallyForId = mainScrollViewID ?? ""
-        } else {
-            applyContentInset()
-            applyScrollIndicatorInsets()
+            
+            // Enable callbacks only after all setup is complete
+            didScrollToEndInitially = true
+            return
+        }
+        
+        applyAllInsets()
 
-            if let queued = queuedScrollToEnd, index == queued.index {
-                flushQueuedScrollToEnd()
-            }
+        if let queued = queuedScrollToEnd, index == queued.index {
+            flushQueuedScrollToEnd()
         }
     }
     
     func registerCell(_ cell: HybridAixCellView) {
         cells.setObject(cell, forKey: NSNumber(value: cell.index))
         
-        // If this cell is marked as last, update our blank view reference
         if cell.isLast {
             blankView = cell
+
+            // Trigger initial setup 
+            let currentSize = cell.view.bounds.size
+            reportBlankViewSizeChange(size: currentSize, index: Int(cell.index))
+        } else if didScrollToEndInitially {
+            // A content cell registered after initial setup - recalculate insets
+            // since this cell's height affects the blank size calculation
+            applyAllInsets()
         }
     }
     
@@ -798,7 +671,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         // If this was our blank view, clear it
         if blankView === cell {
             blankView = nil
-        }
+                    }
     }
     
     func registerComposerView(_ composerView: HybridAixComposer) {
@@ -814,72 +687,33 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     private var lastReportedComposerHeight: CGFloat = 0
 
     func reportComposerHeightChange(height: CGFloat) {
-        if height == lastReportedComposerHeight {
-            return
-        }
-
-        let previousHeight = lastReportedComposerHeight
-        let isShrinking = height < previousHeight
-
+        guard height != lastReportedComposerHeight else { return }
         lastReportedComposerHeight = height
-
-        if !didScrollToEndInitially {
-            return
-        }
-
+        
+        guard didScrollToEndInitially else { return }
+        
         let shouldScroll = shouldScrollOnFooterSizeUpdate()
-        let animated = scrollOnFooterSizeUpdate?.animated ?? false
-
-        if shouldScroll && animated && isShrinking {
-            guard let scrollView else {
-                applyContentInset()
-                applyScrollIndicatorInsets()
-                return
-            }
-
-            let newContentInsetBottom = self.contentInsetBottom
-            let bottomOffset = CGPoint(
-                x: 0,
-                y: max(0, scrollView.contentSize.height - scrollView.bounds.height + newContentInsetBottom)
-            )
-
-            UIView.animate(withDuration: 0.25, delay: 0, options: [.curveEaseOut]) {
-                scrollView.contentInset.bottom = newContentInsetBottom
-                scrollView.contentOffset = bottomOffset
-            }
-            applyScrollIndicatorInsets()
-        } else {
-            applyContentInset()
-            applyScrollIndicatorInsets()
-
-            if shouldScroll {
-                scrollToEndInternal(animated: animated)
-            }
+        applyAllInsets()
+        
+        if shouldScroll {
+            let animated = scrollOnFooterSizeUpdate?.animated ?? false
+            scrollToEndInternal(animated: animated)
         }
     }
 
     private func shouldScrollOnFooterSizeUpdate() -> Bool {
-        guard let settings = scrollOnFooterSizeUpdate, settings.enabled else {
+        guard let settings = scrollOnFooterSizeUpdate, settings.enabled ?? true else {
             return false
         }
-        guard let scrollView else {
+        guard scrollView != nil else {
             return false
         }
 
-        let contentHeight = scrollView.contentSize.height
-        let scrollViewHeight = scrollView.bounds.height
-        let currentOffsetY = scrollView.contentOffset.y
-        let bottomInset = scrollView.contentInset.bottom
-
-        let maxOffsetY = max(0, contentHeight - scrollViewHeight + bottomInset)
-        let distanceFromEnd = maxOffsetY - currentOffsetY
-
-        let threshold = settings.scrolledToEndThreshold ?? 0
-        return distanceFromEnd <= CGFloat(threshold)
+        let threshold = settings.scrolledToEndThreshold ?? 100
+        return distFromEnd <= CGFloat(threshold)
     }
 
     // MARK: - Cell Access
-    
     /// Get a cell by its index
     func getCell(index: Int) -> HybridAixCellView? {
         return cells.object(forKey: NSNumber(value: index))
@@ -887,7 +721,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
 
     
     // MARK: - Scrolling
-
     func getIsQueuedScrollToEndReady(queuedScrollToEnd: QueuedScrollToEnd) -> Bool {
         guard let blankView else { return false }
         if queuedScrollToEnd.waitForKeyboardToEnd == true && startEvent != nil {
@@ -905,7 +738,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
     }
     
     // MARK: - Keyboard Notification Handlers
-
     func keyboardWillShow(notification: NSNotification) {
         guard let userInfo = notification.userInfo,
               let keyboardFrame = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect,
@@ -913,7 +745,6 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
               let curveValue = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? UInt else { return }
 
         let targetHeight = keyboardFrame.height
-        print("[Aix] keyboardWillShow: targetHeight=\(targetHeight), duration=\(duration)")
 
         guard duration > 0 else { return }
 
@@ -924,8 +755,7 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
         if !didScrollToEndInitially {
             keyboardHeight = targetHeight
             keyboardProgress = 1.0
-            applyContentInset()
-            applyScrollIndicatorInsets()
+            applyAllInsets()
             composerView?.applyKeyboardTransform(height: targetHeight, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
             return
         }
@@ -934,17 +764,16 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
 
         let options = UIView.AnimationOptions(rawValue: curveValue << 16)
         UIView.animate(withDuration: duration, delay: 0, options: options, animations: { [weak self] in
-            guard let self = self else { return }
-            self.keyboardHeight = targetHeight
-            if self.keyboardHeightWhenOpen > 0 {
-                self.keyboardProgress = targetHeight / self.keyboardHeightWhenOpen
+            guard let self else { return }
+            keyboardHeight = targetHeight
+            if keyboardHeightWhenOpen > 0 {
+                keyboardProgress = targetHeight / keyboardHeightWhenOpen
             }
-            self.applyContentInset()
-            self.applyScrollIndicatorInsets()
-            self.composerView?.applyKeyboardTransform(height: targetHeight, heightWhenOpen: self.keyboardHeightWhenOpen, animated: false)
+            applyAllInsets()
+            composerView?.applyKeyboardTransform(height: targetHeight, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
 
-            if let (startY, endY) = self.startEvent?.interpolateContentOffsetY {
-                self.scrollView?.setContentOffset(CGPoint(x: 0, y: endY), animated: false)
+            if let (_, endY) = startEvent?.interpolateContentOffsetY {
+                scrollView?.setContentOffset(CGPoint(x: 0, y: endY), animated: false)
             }
         }, completion: { [weak self] _ in
             self?.handleKeyboardDidMove(height: targetHeight, progress: 1.0)
@@ -956,249 +785,73 @@ class HybridAix: HybridAixSpec, AixContext, KeyboardNotificationsDelegate {
               let duration = userInfo[UIResponder.keyboardAnimationDurationUserInfoKey] as? Double,
               let curveValue = userInfo[UIResponder.keyboardAnimationCurveUserInfoKey] as? UInt else { return }
 
-        print("[Aix] keyboardWillHide: duration=\(duration)")
-
-        // Don't interpolate scroll position when closing, the inset change will handle the visual transition
         startEvent = nil
 
         let options = UIView.AnimationOptions(rawValue: curveValue << 16)
         UIView.animate(withDuration: duration, delay: 0, options: options, animations: { [weak self] in
-            guard let self = self else { return }
-
-            self.keyboardHeight = 0
-            self.keyboardProgress = 0
-            self.applyContentInset()
-            self.applyScrollIndicatorInsets()
-            self.composerView?.applyKeyboardTransform(height: 0, heightWhenOpen: self.keyboardHeightWhenOpen, animated: false)
+            guard let self else { return }
+            keyboardHeight = 0
+            keyboardProgress = 0
+            applyAllInsets()
+            composerView?.applyKeyboardTransform(height: 0, heightWhenOpen: keyboardHeightWhenOpen, animated: false)
         }, completion: { [weak self] _ in
             self?.handleKeyboardDidMove(height: 0, progress: 0)
         })
     }
 
     func keyboardDidShow(notification: NSNotification) {
-        print("[Aix] keyboardDidShow")
     }
 
     func keyboardDidHide(notification: NSNotification) {
-        print("[Aix] keyboardDidHide")
         keyboardHeightWhenOpen = 0
         composerView?.applyKeyboardTransform(height: 0, heightWhenOpen: 0, animated: false)
     }
 
     func keyboardWillChangeFrame(notification: NSNotification) {
-        guard let userInfo = notification.userInfo,
-              let keyboardFrameEnd = userInfo[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
-
-        let screenHeight = UIScreen.main.bounds.height
-        let keyboardTop = keyboardFrameEnd.origin.y
-        let newHeight = max(0, screenHeight - keyboardTop)
-
-        if startEvent != nil && !isInInteractiveDismiss {
-            return
-        }
-
-        if isInInteractiveDismiss && newHeight != keyboardHeight {
-            let progress = keyboardHeightWhenOpen > 0 ? newHeight / keyboardHeightWhenOpen : 0
-            handleKeyboardMoveInteractive(height: newHeight, progress: progress)
-        }
     }
 }
 
 // MARK: - Scroll Position Helpers
-
 extension HybridAix {
-    /// Check if an interactive keyboard dismiss is in progress by examining scroll view state
-    private func isInteractiveDismissInProgress() -> Bool {
-        guard let scrollView = scrollView else { return false }
-        
-        // Check if scroll view has interactive keyboard dismiss mode
-        guard scrollView.keyboardDismissMode == .interactive else { return false }
-        
-        // Check if pan gesture is active (user is scrolling)
-        let panGesture = scrollView.panGestureRecognizer
-        let gestureState = panGesture.state
-        
-        // Pan gesture states: .began = 1, .changed = 2
-        return gestureState == .began || gestureState == .changed
-    }
-
     /// Distance from current scroll position to the maximum scroll position (end)
     var distFromEnd: CGFloat {
-        guard let scrollView = scrollView else { return 0 }
-        let maxScrollY = scrollView.contentSize.height - scrollView.bounds.height + contentInsetBottom
-        return maxScrollY - scrollView.contentOffset.y
+        guard let scrollView else { return 0 }
+        return scrollView.contentSize.height - scrollView.bounds.height + contentInsetBottom - scrollView.contentOffset.y
     }
     
     func getIsScrolledNearEnd(distFromEnd: CGFloat) -> Bool {
+        guard scrollView != nil else { return false }
         return distFromEnd <= (scrollEndReachedThreshold ?? max(200, blankSize))
     }
-    
+
     func getContentOffsetYWhenOpening(scrollY: CGFloat) -> (CGFloat, CGFloat)? {
-        guard let scrollView else { return nil } 
-        let isScrolledNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
-        let shouldShiftContentUp = blankSize == 0 && isScrolledNearEnd
-        
-        // Use the target additionalContentInsetBottom when keyboard is fully open
-        let targetAdditionalInset = CGFloat(self.additionalContentInsets?.bottom?.whenKeyboardOpen ?? 0)
+        guard let scrollView, getIsScrolledNearEnd(distFromEnd: distFromEnd), blankSize <= keyboardHeightWhenOpen else {
+            return nil
+        }
         
-        // Calculate the max scroll position when keyboard is open
-        // This is where we want to scroll to: contentSize - bounds + contentInset
-        // When blankSize is 0: contentInset = keyboard + composer + additionalInset
-        let shiftContentUpToY = scrollView.contentSize.height - scrollView.bounds.height + keyboardHeightWhenOpen + composerHeight + targetAdditionalInset
+        let targetAdditionalInset = CGFloat(additionalContentInsets?.bottom?.whenKeyboardOpen ?? 0)
+        let targetY = scrollView.contentSize.height - scrollView.bounds.height + keyboardHeightWhenOpen + composerHeight + targetAdditionalInset
         
-        if shouldShiftContentUp {
-            return (scrollY, shiftContentUpToY)    
-        }
-
-        let hasBlankSizeLessThanOpenKeyboardHeight = blankSize > 0 && blankSize <= keyboardHeightWhenOpen
-
-        if hasBlankSizeLessThanOpenKeyboardHeight && isScrolledNearEnd {
-            return (scrollY, shiftContentUpToY)    
-        }
-
-        return nil
+        return (scrollY, targetY)
     }
     
     func getContentOffsetYWhenClosing(scrollY: CGFloat) -> (CGFloat, CGFloat)? {
-        guard keyboardHeightWhenOpen > 0 else { return nil }
-        let isScrolledNearEnd = getIsScrolledNearEnd(distFromEnd: distFromEnd)
-
-        if !isScrolledNearEnd {
+        guard scrollView != nil, keyboardHeightWhenOpen > 0, getIsScrolledNearEnd(distFromEnd: distFromEnd) else {
             return nil
         }
 
-        let additionalContentInsetBottomWithKeyboard = CGFloat(self.additionalContentInsets?.bottom?.whenKeyboardOpen ?? 0)
-        let additionalContentInsetBottomWithoutKeyboard = CGFloat(self.additionalContentInsets?.bottom?.whenKeyboardClosed ?? 0)
+        let additionalInsetOpen = CGFloat(additionalContentInsets?.bottom?.whenKeyboardOpen ?? 0)
+        let additionalInsetClosed = CGFloat(additionalContentInsets?.bottom?.whenKeyboardClosed ?? 0)
         
-        // Calculate how much content inset will decrease when keyboard closes
-        let blankSizeWithKeyboard = calculateBlankSize(keyboardHeight: keyboardHeightWhenOpen, additionalContentInsetBottom: additionalContentInsetBottomWithKeyboard)
-        let blankSizeWithoutKeyboard = calculateBlankSize(keyboardHeight: 0, additionalContentInsetBottom: additionalContentInsetBottomWithoutKeyboard)
+        let blankSizeOpen = calculateBlankSize(keyboardHeight: keyboardHeightWhenOpen, additionalContentInsetBottom: additionalInsetOpen)
+        let blankSizeClosed = calculateBlankSize(keyboardHeight: 0, additionalContentInsetBottom: additionalInsetClosed)
         
-        // Calculate actual content insets (including composer)
-        let insetWithKeyboard = calculateContentInsetBottom(keyboardHeight: keyboardHeightWhenOpen, blankSize: blankSizeWithKeyboard, additionalContentInsetBottom: additionalContentInsetBottomWithKeyboard)
-        let insetWithoutKeyboard = calculateContentInsetBottom(keyboardHeight: 0, blankSize: blankSizeWithoutKeyboard,
-           additionalContentInsetBottom: additionalContentInsetBottomWithoutKeyboard
-        )
-        let insetDecrease = insetWithKeyboard - insetWithoutKeyboard
+        let insetOpen = calculateContentInsetBottom(keyboardHeight: keyboardHeightWhenOpen, blankSize: blankSizeOpen, additionalContentInsetBottom: additionalInsetOpen)
+        let insetClosed = calculateContentInsetBottom(keyboardHeight: 0, blankSize: blankSizeClosed, additionalContentInsetBottom: additionalInsetClosed)
         
-        // To keep the visual content position stable, we need to decrease scrollY 
-        // by the same amount the inset decreases
-        let targetScrollY = max(0, scrollY - insetDecrease)
+        let targetScrollY = max(0, scrollY - (insetOpen - insetClosed))
         
-        // Only interpolate if there's actually movement needed
         guard abs(scrollY - targetScrollY) > 1 else { return nil }
-        
         return (scrollY, targetScrollY)
     }
 }
-
-// Source - https://stackoverflow.com/a
-// Posted by Vasily  Bodnarchuk, modified by community. See post 'Timeline' for change history
-// Retrieved 2026-01-07, License - CC BY-SA 4.0
-
-protocol KeyboardNotificationsDelegate: AnyObject {
-    func keyboardWillShow(notification: NSNotification)
-    func keyboardWillHide(notification: NSNotification)
-    func keyboardDidShow(notification: NSNotification)
-    func keyboardDidHide(notification: NSNotification)
-    func keyboardWillChangeFrame(notification: NSNotification)
-}
-
-extension KeyboardNotificationsDelegate {
-    func keyboardWillShow(notification: NSNotification) {}
-    func keyboardWillHide(notification: NSNotification) {}
-    func keyboardDidShow(notification: NSNotification) {}
-    func keyboardDidHide(notification: NSNotification) {}
-    func keyboardWillChangeFrame(notification: NSNotification) {}
-}
-
-class KeyboardNotifications {
-    fileprivate var _isEnabled: Bool
-    fileprivate var notifications: [KeyboardNotificationsType]
-    fileprivate weak var delegate: KeyboardNotificationsDelegate?
-
-    init(notifications: [KeyboardNotificationsType], delegate: KeyboardNotificationsDelegate) {
-        _isEnabled = false
-        self.notifications = notifications
-        self.delegate = delegate
-    }
-
-    deinit { if isEnabled { isEnabled = false } }
-}
-
-// MARK: - enums
-
-extension KeyboardNotifications {
-
-    enum KeyboardNotificationsType {
-        case willShow, willHide, didShow, didHide, willChangeFrame
-
-        var selector: Selector {
-            switch self {
-                case .willShow: return #selector(keyboardWillShow(notification:))
-                case .willHide: return #selector(keyboardWillHide(notification:))
-                case .didShow: return #selector(keyboardDidShow(notification:))
-                case .didHide: return #selector(keyboardDidHide(notification:))
-                case .willChangeFrame: return #selector(keyboardWillChangeFrame(notification:))
-            }
-        }
-
-        var notificationName: NSNotification.Name {
-            switch self {
-                case .willShow: return UIResponder.keyboardWillShowNotification
-                case .willHide: return UIResponder.keyboardWillHideNotification
-                case .didShow: return UIResponder.keyboardDidShowNotification
-                case .didHide: return UIResponder.keyboardDidHideNotification
-                case .willChangeFrame: return UIResponder.keyboardWillChangeFrameNotification
-            }
-        }
-    }
-}
-
-// MARK: - isEnabled
-
-extension KeyboardNotifications {
-
-    private func addObserver(type: KeyboardNotificationsType) {
-        NotificationCenter.default.addObserver(self, selector: type.selector, name: type.notificationName, object: nil)
-    }
-
-    var isEnabled: Bool {
-        set {
-            if newValue {
-                for notificaton in notifications { addObserver(type: notificaton) }
-            } else {
-                NotificationCenter.default.removeObserver(self)
-            }
-            _isEnabled = newValue
-        }
-
-        get { return _isEnabled }
-    }
-
-}
-
-// MARK: - Notification functions
-
-extension KeyboardNotifications {
-
-    @objc func keyboardWillShow(notification: NSNotification) {
-        delegate?.keyboardWillShow(notification: notification)
-    }
-
-    @objc func keyboardWillHide(notification: NSNotification) {
-        delegate?.keyboardWillHide(notification: notification)
-    }
-
-    @objc func keyboardDidShow(notification: NSNotification) {
-        delegate?.keyboardDidShow(notification: notification)
-    }
-
-    @objc func keyboardDidHide(notification: NSNotification) {
-        delegate?.keyboardDidHide(notification: notification)
-    }
-
-    @objc func keyboardWillChangeFrame(notification: NSNotification) {
-        delegate?.keyboardWillChangeFrame(notification: notification)
-    }
-}