Add overscroll callback

Author: gh123man

Examples/LazyPagerExampleApp/FullTestView.swift

@@ -64,6 +64,13 @@ struct FullTestView: View {
                 .shouldLoadMore(on: .lastElement(minus: 2)) {
                     data.append(Foo(img: "nora4", idx: data.count))
                 }
+                .overscroll { position in
+                    if position == .beginning {
+                        print("Swiped past beginning")
+                    } else {
+                        print("Swiped past end")
+                    }
+                }
                 .background(.black.opacity(opacity))
                 .background(ClearFullScreenBackground())
                 .ignoresSafeArea()

Examples/LazyPagerExampleApp/SimpleExample.swift

@@ -13,11 +13,31 @@ struct SimpleExample: View {
         "nora6",
     ]
 
+    @State var show = false
+    
     var body: some View {
-        LazyPager(data: data) { element in
-            Image(element)
-                .resizable()
-                .aspectRatio(contentMode: .fit)
+        VStack {
+            Button("Show") {
+                show.toggle()
+            }
+        }
+        .fullScreenCover(isPresented: $show) {
+            LazyPager(data: data) { element in
+                VStack {
+                    Image(element)
+                        .resizable()
+                        .aspectRatio(contentMode: .fit)
+                        .onTapGesture {
+                            print("tap image")
+                        }
+                }
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .contentShape(Rectangle())
+                .onTapGesture {
+                    show.toggle()
+                    print("tap background")
+                }
+            }
         }
     }
 }

Examples/LazyPagerExampleApp/VerticalMediaPager.swift

@@ -25,6 +25,13 @@ struct VerticalMediaPager: View {
                         .resizable()
                         .aspectRatio(contentMode: .fill)
                 }
+                .overscroll {
+                    if $0 == .beginning {
+                        print("Swiped past beginning")
+                    } else if $0 == .end {
+                        print("Swiped past end")
+                    }
+                }
                 .ignoresSafeArea()
 
                 VStack(alignment: .leading) {

README.md

@@ -89,6 +89,15 @@ var body: some View {
         .shouldLoadMore {
             data.append("foobar")
         }
+        
+        // Get notified when swiping past the beginning or end of the list 
+        .overscroll { position in
+            if position == .beginning {
+                print("Swiped past beginning")
+            } else {
+                print("Swiped past end")
+            }
+        }
 
         // Set the background color with the drag opacity control
         .background(.black.opacity(opacity))
@@ -130,7 +139,7 @@ For a full working example, [open the sample project](https://github.com/gh123ma
 - Works with `.ignoresSafeArea()` (or not) to get a true full screen view.
 - Drag to dismiss is supported with `.onDismiss` - Supply a binding opacity value to control the background opacity during the transition. 
 - Tap events are handled internally, so use `.onTap` to handle single taps (useful for hiding and showing UI)
-- Use `.settings` to [modify advanced settings](https://github.com/gh123man/SwiftUI-LazyPager/blob/master/Sources/LazyPager/LazyPager.swift#L54)
+- Use `.settings` to [modify advanced settings](https://github.com/gh123man/SwiftUI-LazyPager/blob/master/Sources/LazyPager/LazyPager.swift#L62)
 
 
 # Detailed usage

Sources/LazyPager/LazyPager.swift

@@ -23,6 +23,11 @@ public enum Direction {
     case vertical
 }
 
+public enum ListPosition {
+    case beginning
+    case end
+}
+
 public struct Config {
     /// binding variable to control a custom background opacity. LazyPager is transparent by default
     public var backgroundOpacity: Binding<CGFloat>?
@@ -51,7 +56,10 @@ public struct Config {
     /// Direction of the pager
     public var direction : Direction = .horizontal
 
-    /// Advanced settings (only accessible via .settings)
+    /// Called whent the end of data is reached and the user tries to swipe again
+    public var overscrollCallback: ((ListPosition) -> ())?
+
+    /// Advanced settings (only accessibleevia .settings)
 
     /// How may out of view pages to load in advance (forward and backwards)
     public var preloadAmount: Int = 3
@@ -74,6 +82,9 @@ public struct Config {
 
     /// The minimum scroll distance the in which the pinch gesture is enabled
     public var pinchGestureEnableOffset: Double = 10
+    
+    /// % ammount (from 0-1) of overscroll needed to call overscrollCallback
+    public var overscrollThreshold: Double = 0.15
 }
 
 public struct LazyPager<Element, DataCollecton: RandomAccessCollection, Content: View> where DataCollecton.Index == Int, DataCollecton.Element == Element {
@@ -133,6 +144,12 @@ public extension LazyPager {
         adjust(&this.config)
         return this
     }
+    
+    func overscroll(_ callback: @escaping (ListPosition) -> ()) -> LazyPager {
+        var this = self
+        this.config.overscrollCallback = callback
+        return this
+    }
 }
 
 extension LazyPager: UIViewControllerRepresentable {

Sources/LazyPager/PagerView.swift

@@ -295,22 +295,37 @@ class PagerView<Element, Loader: ViewLoader, Content: View>: UIScrollView, UIScr
     // MARK: UISCrollVieDelegate methods
 
     var lastPos: CGFloat = 0
+    var hasNotfiedOverscroll = false
 
     public func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        var relativeIndex: Int
+        var absoluteOffset: CGFloat
+        if config.direction == .horizontal {
+            absoluteOffset = scrollView.contentOffset.x / scrollView.frame.width
+            relativeIndex = Int(round(absoluteOffset))
+        } else {
+            absoluteOffset = scrollView.contentOffset.y / scrollView.frame.height
+            relativeIndex = Int(round(absoluteOffset))
+        }
+        relativeIndex = relativeIndex < 0 ? 0 : relativeIndex
+        relativeIndex = relativeIndex >= loadedViews.count ? loadedViews.count-1 : relativeIndex
+        
         if !scrollView.isTracking, !isRotating  {
-            var relativeIndex: Int
-            if config.direction == .horizontal {
-                relativeIndex = Int(round(scrollView.contentOffset.x / scrollView.frame.width))
-            } else {
-                relativeIndex = Int(round(scrollView.contentOffset.y / scrollView.frame.height))
-            }
-            relativeIndex = relativeIndex < 0 ? 0 : relativeIndex
-            relativeIndex = relativeIndex >= loadedViews.count ? loadedViews.count-1 : relativeIndex
-            
             currentIndex = loadedViews[relativeIndex].index
             page.wrappedValue = currentIndex
         }
 
+        if !hasNotfiedOverscroll {
+            if relativeIndex >= loadedViews.count-1, absoluteOffset - CGFloat(relativeIndex) > config.overscrollThreshold {
+                config.overscrollCallback?(.end)
+                hasNotfiedOverscroll = true
+            }
+            
+            if relativeIndex <= 0, absoluteOffset - CGFloat(relativeIndex) < -config.overscrollThreshold {
+                config.overscrollCallback?(.beginning)
+                hasNotfiedOverscroll = true
+            }
+        }
 
         // Horribly janky way to detect when scrolling (both touching and animation) is finnished.
         let caputred: CGFloat
@@ -324,6 +339,7 @@ class PagerView<Element, Loader: ViewLoader, Content: View>: UIScrollView, UIScr
         lastPos = caputred
         DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(100)) {
             if self.lastPos == caputred, !scrollView.isTracking {
+                self.hasNotfiedOverscroll = false
                 self.resizeOutOfBoundsViews()
             }
         }