Merge pull request #3 from Ryu0118/feature/delay

Add option to delay display of popups

Author: Ryu0118

Examples/Examples/ContentView.swift

@@ -4,7 +4,8 @@ import FullscreenPopup
 struct ContentView: View {
     @State var isExample1Presented = false
     @State var isExample2Presented = false
-    @State var example3Item: MyItem?
+    @State var isExample3Presented = false
+    @State var example4Item: MyItem?
 
     var body: some View {
         Color.white
@@ -24,21 +25,30 @@ struct ContentView: View {
                         }
 
                         Button {
-                            example3Item = .init(id: UUID())
+                            isExample3Presented = true
                         } label: {
-                            Text("Show Alert 3")
+                            Text("Show Delay Alert 3")
+                        }
+
+                        Button {
+                            example4Item = .init(id: UUID())
+                        } label: {
+                            Text("Show Alert 4")
                         }
                     }
                     .navigationTitle("Title")
                     .toolbarTitleDisplayMode(.inline)
                     .popup(isPresented: $isExample1Presented) {
                         Example1Alert(isPresented: $isExample1Presented)
                     }
-                    .popup(item: $example3Item) { item in
+                    .popup(isPresented: $isExample3Presented, delay: .seconds(1)) {
+                        Example1Alert(isPresented: $isExample3Presented)
+                    }
+                    .popup(item: $example4Item) { item in
                         VStack {
                             Text(item.id.uuidString)
                             Button {
-                                example3Item = nil
+                                example4Item = nil
                             } label: {
                                 Text("Close")
                             }

Sources/FullscreenPopup/AnimatableFullScreenViewModifier.swift

@@ -5,6 +5,7 @@ extension View {
     func animatableFullScreenCover(
         isPresented: Binding<Bool>,
         duration nanoseconds: UInt64,
+        delay: UInt64? = nil,
         content: @escaping () -> some View,
         onAppear: @escaping () -> Void,
         onDisappear: @escaping () -> Void
@@ -13,6 +14,7 @@ extension View {
             AnimatableFullScreenViewModifier(
                 isPresented: isPresented,
                 duration: nanoseconds,
+                delay: delay,
                 fullScreenContent: content,
                 onAppear: onAppear,
                 onDisappear: onDisappear
@@ -23,6 +25,7 @@ extension View {
     func animatableFullScreenCover<Item: Identifiable & Equatable>(
         item: Binding<Item?>,
         duration nanoseconds: UInt64,
+        delay: UInt64? = nil,
         content: @escaping (Item) -> some View,
         onAppear: @escaping () -> Void,
         onDisappear: @escaping () -> Void
@@ -31,6 +34,7 @@ extension View {
             AnimatableFullScreenItemViewModifier(
                 item: item,
                 duration: nanoseconds,
+                delay: delay,
                 fullScreenContent: content,
                 onAppear: onAppear,
                 onDisappear: onDisappear
@@ -44,19 +48,22 @@ private struct AnimatableFullScreenItemViewModifier<FullScreenContent: View, Ite
     @State var isActualPresented: Item?
 
     let nanoseconds: UInt64
+    let delay: UInt64?
     let fullScreenContent: (Item) -> (FullScreenContent)
     let onAppear: () -> Void
     let onDisappear: () -> Void
 
     init(
         item: Binding<Item?>,
         duration nanoseconds: UInt64,
+        delay: UInt64?,
         fullScreenContent: @escaping (Item) -> FullScreenContent,
         onAppear: @escaping () -> Void,
         onDisappear: @escaping () -> Void
     ) {
         self._isUserInstructToPresentItem = item
         self.nanoseconds = nanoseconds
+        self.delay = delay
         self.fullScreenContent = fullScreenContent
         self.onAppear = onAppear
         self.onDisappear = onDisappear
@@ -68,7 +75,14 @@ private struct AnimatableFullScreenItemViewModifier<FullScreenContent: View, Ite
             .onChange(of: isUserInstructToPresentItem) { isUserInstructToPresent in
                 UIView.setAnimationsEnabled(false)
                 if isUserInstructToPresent != nil {
-                    isActualPresented = isUserInstructToPresent
+                    if let delay {
+                        Task {
+                            try await Task.sleep(nanoseconds: delay)
+                            isActualPresented = isUserInstructToPresent
+                        }
+                    } else {
+                        isActualPresented = isUserInstructToPresent
+                    }
                 } else {
                     Task {
                         try await Task.sleep(nanoseconds: nanoseconds)
@@ -100,19 +114,22 @@ private struct AnimatableFullScreenViewModifier<FullScreenContent: View>: ViewMo
     @State var isActualPresented: Bool
 
     let nanoseconds: UInt64
+    let delay: UInt64?
     let fullScreenContent: () -> (FullScreenContent)
     let onAppear: () -> Void
     let onDisappear: () -> Void
 
     init(
         isPresented: Binding<Bool>,
         duration nanoseconds: UInt64,
+        delay: UInt64?,
         fullScreenContent: @escaping () -> FullScreenContent,
         onAppear: @escaping () -> Void,
         onDisappear: @escaping () -> Void
     ) {
         self._isUserInstructToPresent = isPresented
         self.nanoseconds = nanoseconds
+        self.delay = delay
         self.fullScreenContent = fullScreenContent
         self.onAppear = onAppear
         self.onDisappear = onDisappear
@@ -124,7 +141,14 @@ private struct AnimatableFullScreenViewModifier<FullScreenContent: View>: ViewMo
             .onChange(of: isUserInstructToPresent) { isUserInstructToPresent in
                 UIView.setAnimationsEnabled(false)
                 if isUserInstructToPresent {
-                    isActualPresented = isUserInstructToPresent
+                    if let delay {
+                        Task {
+                            try await Task.sleep(nanoseconds: delay)
+                            isActualPresented = isUserInstructToPresent
+                        }
+                    } else {
+                        isActualPresented = isUserInstructToPresent
+                    }
                 } else {
                     Task {
                         try await Task.sleep(nanoseconds: nanoseconds)

Sources/FullscreenPopup/PopupItemModifier.swift

@@ -11,12 +11,14 @@ struct PopupItemModifier<Popup: View, Background: View, Item: Identifiable & Equ
 
     let animation: Animation
     let duration: UInt64
+    let delay: UInt64?
     let popup: (Item) -> Popup
     let background: (Bool) -> Background
 
     init(
         item: Binding<Item?>,
         duration nanoseconds: UInt64,
+        delay: UInt64? = nil,
         animation: Animation,
         @ViewBuilder popup: @escaping (_ item: Item) -> Popup,
         @ViewBuilder background: @escaping (_ isPresented: Bool) -> Background
@@ -25,6 +27,7 @@ struct PopupItemModifier<Popup: View, Background: View, Item: Identifiable & Equ
         self._isUserInstructToPresent = item
         self._item = item
         self.duration = nanoseconds
+        self.delay = delay
         self.animation = animation
         self.popup = popup
         self.background = background
@@ -33,7 +36,8 @@ struct PopupItemModifier<Popup: View, Background: View, Item: Identifiable & Equ
     func body(content: Content) -> some View {
         content.animatableFullScreenCover(
             item: $isUserInstructToPresent,
-            duration: duration
+            duration: duration,
+            delay: delay
         ) { item in
             popup(item)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)

Sources/FullscreenPopup/PopupModifier.swift

@@ -10,18 +10,21 @@ struct PopupModifier<Popup: View, Background: View>: ViewModifier {
 
     let animation: Animation
     let duration: UInt64
+    let delay: UInt64?
     let popup: (Bool) -> Popup
     let background: (Bool) -> Background
 
     init(
         isPresented: Binding<Bool>,
         duration nanoseconds: UInt64,
+        delay: UInt64? = nil,
         animation: Animation,
         @ViewBuilder popup: @escaping (_ isPresented: Bool) -> Popup,
         @ViewBuilder background: @escaping (_ isPresented: Bool) -> Background
     ) {
         self._isUserInstructToPresent = isPresented
         self.duration = nanoseconds
+        self.delay = delay
         self.animation = animation
         self.popup = popup
         self.background = background
@@ -30,7 +33,8 @@ struct PopupModifier<Popup: View, Background: View>: ViewModifier {
     func body(content: Content) -> some View {
         content.animatableFullScreenCover(
             isPresented: $isUserInstructToPresent,
-            duration: duration
+            duration: duration,
+            delay: delay
         ) {
             popup(presentationAnimationTrigger)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)