Add completion handler + timer to reset height changes

Author: gh123man

Examples/ContentView.swift

@@ -41,6 +41,13 @@ struct DetailsSearch: View {
                     .scaleEffect(2)
             }
         }
+//        .shouldLoadMore { done in
+//            DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(200)) {
+//                data.append(data.last! + 1)
+//                print("foo")
+//                done()
+//            }
+//        }
         .shouldLoadMore {
             await Task.sleep(seconds: 0.1)
 //            data.append(contentsOf: (data.last! + 1)...data.last! + 100)

README.md

@@ -63,6 +63,28 @@ Set the absolute offset to a fixed value:
 }
 ```
 
+### `waitForHeightChange`
+
+It may be desirable for `shouldLoadMore` to be called whenever the user scrolls - even if the scroll view content didn't change. You can change this behavior with `waitForHeightChange`: 
+```swift 
+.shouldLoadMore(waitForHeightChange: .never) { 
+    // Will be called regardless of if the height changed from a previous update
+}
+```
+
+```swift 
+.shouldLoadMore(waitForHeightChange: .always) { 
+    // Will only be called if the content height changed since last time
+}
+```
+
+```swift 
+.shouldLoadMore(waitForHeightChange: .after(2)) { 
+    // Will only be called if the content height changed since last time or after 2 seconds of no change
+}
+```
+and now `shouldLoadMore` will be called whenever it's in the offset threshold. By default `waitForHeightChange` is `true` so the function doesn't get called in quick succession when no content updates are made. 
+
 ## More details
 
 - The callback will only be called once when the bottom approaches. 
@@ -72,6 +94,17 @@ Set the absolute offset to a fixed value:
 
 # More Examples
 
+## Using a completion handler instead of `async`
+
+```swift
+.shouldLoadMore { done in
+    loadYourContent {
+        data.append(data.last! + 1)
+        done() // Call done so shouldLoadMore can be called again later
+    }
+}
+```
+
 Larger batching 
 
 ![Navigation](/images/1.gif)

Sources/ScrollViewLoader/ScrollViewLoader.swift

@@ -3,18 +3,41 @@ import SwiftUI
 import UIKit
 import Introspect
 
+public enum HeightChangeConfig {
+    case always
+    case after(TimeInterval)
+    case never
+}
+
 public enum OffsetTrigger {
     case relative(CGFloat)
     case absolute(CGFloat)
 }
 
 extension View {
     public func shouldLoadMore(bottomDistance offsetTrigger: OffsetTrigger = .relative(0.5),
-                        shouldLoadMore: @escaping () async -> ()) -> some View  {
+                               waitForHeightChange: HeightChangeConfig = .after(2),
+                               shouldLoadMore: @escaping () async -> ()) -> some View  {
         return DelegateHolder(offsetNotifier: ScrollOffsetNotifier(offsetTrigger: offsetTrigger,
+                                                                   waitForHeightChange: waitForHeightChange,
                                                                    onNotify: shouldLoadMore),
                               content: self)
     }
+    
+    public func shouldLoadMore(bottomDistance offsetTrigger: OffsetTrigger = .relative(0.5),
+                               waitForHeightChange: HeightChangeConfig = .after(2),
+                               shouldLoadMore: @escaping (_ done: @escaping () -> ()) -> ()) -> some View  {
+        return DelegateHolder(offsetNotifier: ScrollOffsetNotifier(offsetTrigger: offsetTrigger,
+                                                                   waitForHeightChange: waitForHeightChange,
+                                                                   onNotify: {
+            await withCheckedContinuation { continuation in
+                shouldLoadMore {
+                    continuation.resume()
+                }
+            }
+        }),
+                              content: self)
+    }
 }
 
 struct DelegateHolder<Content: View>: View {
@@ -38,15 +61,18 @@ class ScrollOffsetNotifier: NSObject, UIScrollViewDelegate, ObservableObject {
     private var canNotify = true
     private var trigger: OffsetTrigger
     private var oldContentHeight: Double = 0
+    private var waitForHeightChange: HeightChangeConfig
+    private var isTimerRunning = false
     weak var scrollView: UIScrollView? {
         didSet {
             scrollView?.addObserver(self, forKeyPath: "contentSize", context: nil)
         }
     }
 
-    init(offsetTrigger: OffsetTrigger, onNotify: @escaping () async -> ()) {
+    init(offsetTrigger: OffsetTrigger, waitForHeightChange: HeightChangeConfig, onNotify: @escaping () async -> ()) {
         self.trigger = offsetTrigger
         self.onNotify = onNotify
+        self.waitForHeightChange = waitForHeightChange
     }
 
     deinit {
@@ -73,14 +99,32 @@ class ScrollOffsetNotifier: NSObject, UIScrollViewDelegate, ObservableObject {
         }
 
         let bottomOffset = (scrollView.contentSize.height + scrollView.contentInset.bottom) - (scrollView.contentOffset.y + scrollView.visibleSize.height)
+        var heightChanged = false
+        
+        switch waitForHeightChange {
+        case .always:
+            heightChanged = oldContentHeight != scrollView.contentSize.height
+        case .after(let timeInterval):
+            heightChanged = oldContentHeight != scrollView.contentSize.height
+            if !isTimerRunning {
+                isTimerRunning = true
+                DispatchQueue.main.asyncAfter(deadline: .now() + timeInterval) {
+                    self.oldContentHeight = 0
+                    self.isTimerRunning = false
+                }
+            }
+        case .never:
+            heightChanged = true
+        }
 
         Task { @MainActor in
-            if bottomOffset < triggerHeight, canNotify {
+            guard canNotify else { return }
+            if bottomOffset < triggerHeight, heightChanged {
                 oldContentHeight = scrollView.contentSize.height
                 canNotify = false
                 await onNotify()
+                canNotify = true
             }
-            canNotify = bottomOffset >= triggerHeight || oldContentHeight != scrollView.contentSize.height
         }
     }
 }