@capgo/capacitor-pretty-toast 8.1.8 → 8.1.9

package/ios/Sources/PrettyToastPlugin/PassThroughWindow.swift

@@ -36,6 +36,24 @@ class PassThroughWindow: UIWindow, ObservableObject {
         return frame.insetBy(dx: -8, dy: -8).contains(point)
     }
 
+    func resolvedSafeAreaInsets(geometryInsets: EdgeInsets) -> UIEdgeInsets {
+        let geometrySafeArea = UIEdgeInsets(
+            top: geometryInsets.top,
+            left: geometryInsets.leading,
+            bottom: geometryInsets.bottom,
+            right: geometryInsets.trailing
+        )
+
+        guard let scene = windowScene else {
+            return mergedSafeAreaInsets(geometrySafeArea, safeAreaInsets)
+        }
+
+        return scene.windows
+            .filter { $0 !== self && !$0.isHidden }
+            .map(\.safeAreaInsets)
+            .reduce(mergedSafeAreaInsets(geometrySafeArea, safeAreaInsets), mergedSafeAreaInsets)
+    }
+
     // MARK: - Backdrop sampling
 
     func startBackdropSampling() {
@@ -137,3 +155,12 @@ class PassThroughWindow: UIWindow, ObservableObject {
         }
     }
 }
+
+private func mergedSafeAreaInsets(_ lhs: UIEdgeInsets, _ rhs: UIEdgeInsets) -> UIEdgeInsets {
+    UIEdgeInsets(
+        top: max(lhs.top, rhs.top),
+        left: max(lhs.left, rhs.left),
+        bottom: max(lhs.bottom, rhs.bottom),
+        right: max(lhs.right, rhs.right)
+    )
+}

package/ios/Sources/PrettyToastPlugin/PrettyToastView.swift

@@ -5,26 +5,17 @@ struct PrettyToastView: View {
     @State private var measuredContentHeight: CGFloat = 0
 
     var body: some View {
-        GeometryReader {
-            let safeArea = $0.safeAreaInsets
-            let size = $0.size
-
-            let haveDynamicIsland: Bool = safeArea.top >= 59 && window.useDynamicIsland
-            let dynamicIslandWidth: CGFloat = 120
-            let dynamicIslandHeight: CGFloat = 36
-            let topOffset: CGFloat = 11 + max((safeArea.top - 59), 0)
-            // Nudge up 0.5pt so the centered stroke clears the DI's top line
-            // instead of sitting half-behind it.
-            let expandedTopOffset: CGFloat = topOffset - 0.5
-
-            let expandedWidth = size.width - (topOffset * 2)
-            let baseHeight: CGFloat = haveDynamicIsland ? 90 : 70
-            let baseContentArea: CGFloat = haveDynamicIsland ? (baseHeight - dynamicIslandHeight - 12) : (baseHeight - 20)
-            let overflow = max(0, measuredContentHeight - baseContentArea)
-            let expandedHeight: CGFloat = baseHeight + overflow
+        GeometryReader { proxy in
+            let safeArea = window.resolvedSafeAreaInsets(geometryInsets: proxy.safeAreaInsets)
+            let layout = PrettyToastLayout(
+                size: proxy.size,
+                safeAreaTop: safeArea.top,
+                measuredContentHeight: measuredContentHeight,
+                useDynamicIsland: window.useDynamicIsland
+            )
 
-            let scaleX: CGFloat = isExpanded ? 1 : (dynamicIslandWidth / expandedWidth)
-            let scaleY: CGFloat = isExpanded ? 1 : (dynamicIslandHeight / expandedHeight)
+            let scaleX: CGFloat = isExpanded ? 1 : (layout.compactWidth / layout.expandedWidth)
+            let scaleY: CGFloat = isExpanded ? 1 : (layout.compactHeight / layout.expandedHeight)
 
             let swipeGesture = DragGesture(minimumDistance: 2).onEnded { value in
                 if value.translation.height < -8 || value.predictedEndTranslation.height < -40 {
@@ -36,17 +27,17 @@ struct PrettyToastView: View {
                 Group {
                     let pill = toastBackground()
                         .overlay {
-                            toastContent(haveDynamicIsland, expandedWidth: expandedWidth)
-                                .frame(width: expandedWidth, height: expandedHeight)
+                            toastContent(layout)
+                                .frame(width: layout.expandedWidth, height: layout.expandedHeight)
                                 .scaleEffect(x: scaleX, y: scaleY)
                         }
                         .frame(
-                            width: isExpanded ? expandedWidth : dynamicIslandWidth,
-                            height: isExpanded ? expandedHeight : dynamicIslandHeight
+                            width: isExpanded ? layout.expandedWidth : layout.compactWidth,
+                            height: isExpanded ? layout.expandedHeight : layout.compactHeight
                         )
-                        .opacity(haveDynamicIsland ? 1 : (isExpanded ? 1 : 0))
+                        .opacity(layout.hasDynamicIsland ? 1 : (isExpanded ? 1 : 0))
                         .modifier(CapsuleOpacityModifier(
-                            haveDynamicIsland: haveDynamicIsland,
+                            haveDynamicIsland: layout.hasDynamicIsland,
                             isExpanded: isExpanded
                         ))
                         .modifier(GeometryGroupModifier())
@@ -74,10 +65,10 @@ struct PrettyToastView: View {
                         pill
                     }
                 }
-                .offset(y: haveDynamicIsland ? (isExpanded ? expandedTopOffset : topOffset) : 0)
+                .offset(y: layout.hasDynamicIsland ? (isExpanded ? layout.expandedTopOffset : layout.topOffset) : 0)
             }
             .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
-            .padding(.top, haveDynamicIsland ? 0 : (isExpanded ? max(safeArea.top, 10) : 0))
+            .padding(.top, layout.hasDynamicIsland ? 0 : (isExpanded ? max(safeArea.top, 10) : 0))
             .ignoresSafeArea()
             .coordinateSpace(name: "overlayWindow")
             .animation(.bouncy(duration: 0.3, extraBounce: 0), value: isExpanded)
@@ -85,83 +76,79 @@ struct PrettyToastView: View {
     }
 
     @ViewBuilder
-    func toastContent(_ haveDynamicIsland: Bool, expandedWidth: CGFloat) -> some View {
+    func toastContent(_ layout: PrettyToastLayout) -> some View {
         if let toast = window.toast {
             VStack(spacing: 0) {
-                if haveDynamicIsland && !toast.message.isEmpty {
-                    Spacer(minLength: 0)
+                if layout.contentTopClearance > 0 {
+                    Spacer(minLength: layout.contentTopClearance)
                 }
 
-                HStack(spacing: 10) {
-                    ToastIconView(toast: toast, isExpanded: isExpanded)
-                        .frame(width: 50)
-
-                    VStack(alignment: .leading, spacing: 4) {
-                        Text(toast.title)
-                            .font(.callout)
-                            .fontWeight(.semibold)
-                            .foregroundStyle(.white)
-
-                        if !toast.message.isEmpty {
-                            Text(toast.message)
-                                .font(.caption)
-                                .foregroundColor(.white.opacity(0.6))
-                        }
-                    }
-                    .frame(maxWidth: .infinity, alignment: .leading)
-
-                    if let label = toast.actionLabel, !label.isEmpty {
-                        Button(action: { window.actionTapped = true }) {
-                            Text(label)
-                                .font(.footnote)
-                                .fontWeight(.semibold)
-                                .foregroundStyle(toast.accentColor)
-                                .padding(.horizontal, 12)
-                                .padding(.vertical, 6)
-                                .background(
-                                    Capsule().fill(Color.white.opacity(0.12))
-                                )
-                        }
-                        .buttonStyle(.plain)
-                    }
-                }
+                toastRow(toast)
             }
             .padding(.horizontal, 20)
-            .padding(.bottom, haveDynamicIsland && !toast.message.isEmpty ? 12 : 0)
+            .padding(.bottom, layout.contentBottomPadding)
             .compositingGroup()
             .blur(radius: isExpanded ? 0 : 5)
             .opacity(isExpanded ? 1 : 0)
 
             // Hidden measurer — drives measuredContentHeight so the pill grows
             // for overflowing text.
-            HStack(spacing: 10) {
-                Color.clear.frame(width: 50, height: 1)
+            toastRow(toast, isMeasuring: true)
+                .padding(.horizontal, 20)
+                .fixedSize(horizontal: false, vertical: true)
+                .background(
+                    GeometryReader { geo in
+                        Color.clear.preference(
+                            key: ContentHeightKey.self,
+                            value: geo.size.height
+                        )
+                    }
+                )
+                .hidden()
+                .onPreferenceChange(ContentHeightKey.self) { height in
+                    measuredContentHeight = height
+                }
+        }
+    }
 
-                VStack(alignment: .leading, spacing: 4) {
-                    Text(toast.title)
-                        .font(.callout)
-                        .fontWeight(.semibold)
+    @ViewBuilder
+    private func toastRow(_ toast: Toast, isMeasuring: Bool = false) -> some View {
+        HStack(spacing: 10) {
+            ToastIconView(toast: toast, isExpanded: isMeasuring ? true : isExpanded)
+                .frame(width: 50)
 
-                    if !toast.message.isEmpty {
-                        Text(toast.message)
-                            .font(.caption)
-                    }
+            VStack(alignment: .leading, spacing: 4) {
+                Text(toast.title)
+                    .font(.callout)
+                    .fontWeight(.semibold)
+                    .foregroundStyle(.white)
+
+                if !toast.message.isEmpty {
+                    Text(toast.message)
+                        .font(.caption)
+                        .foregroundColor(.white.opacity(0.6))
                 }
-                .frame(maxWidth: .infinity, alignment: .leading)
             }
-            .padding(.horizontal, 20)
-            .fixedSize(horizontal: false, vertical: true)
-            .background(
-                GeometryReader { geo in
-                    Color.clear.preference(
-                        key: ContentHeightKey.self,
-                        value: geo.size.height
-                    )
-                }
-            )
-            .hidden()
-            .onPreferenceChange(ContentHeightKey.self) { height in
-                measuredContentHeight = height
+            .frame(maxWidth: .infinity, alignment: .leading)
+
+            if let label = toast.actionLabel, !label.isEmpty {
+                Button(action: {
+                    if !isMeasuring {
+                        window.actionTapped = true
+                    }
+                }, label: {
+                    Text(label)
+                        .font(.footnote)
+                        .fontWeight(.semibold)
+                        .foregroundStyle(toast.accentColor)
+                        .padding(.horizontal, 12)
+                        .padding(.vertical, 6)
+                        .background(
+                            Capsule().fill(Color.white.opacity(0.12))
+                        )
+                })
+                .buttonStyle(.plain)
+                .allowsHitTesting(!isMeasuring)
             }
         }
     }
@@ -220,6 +207,51 @@ struct PrettyToastView: View {
     }
 }
 
+struct PrettyToastLayout {
+    static let dynamicIslandSafeAreaThreshold: CGFloat = 59
+    static let compactIslandWidth: CGFloat = 120
+    static let compactIslandHeight: CGFloat = 36
+    private static let dynamicIslandBaseHeight: CGFloat = 90
+    private static let standardBaseHeight: CGFloat = 70
+    private static let topOffsetBase: CGFloat = 11
+    private static let expandedTopNudge: CGFloat = -0.5
+    private static let dynamicIslandContentGap: CGFloat = 2
+    private static let dynamicIslandBottomPadding: CGFloat = 12
+    private static let standardContentInset: CGFloat = 20
+
+    let hasDynamicIsland: Bool
+    let compactWidth: CGFloat
+    let compactHeight: CGFloat
+    let topOffset: CGFloat
+    let expandedTopOffset: CGFloat
+    let expandedWidth: CGFloat
+    let expandedHeight: CGFloat
+    let contentTopClearance: CGFloat
+    let contentBottomPadding: CGFloat
+    let baseContentArea: CGFloat
+
+    init(size: CGSize, safeAreaTop: CGFloat, measuredContentHeight: CGFloat, useDynamicIsland: Bool) {
+        hasDynamicIsland = safeAreaTop >= Self.dynamicIslandSafeAreaThreshold && useDynamicIsland
+        compactWidth = Self.compactIslandWidth
+        compactHeight = Self.compactIslandHeight
+        topOffset = Self.topOffsetBase + max(safeAreaTop - Self.dynamicIslandSafeAreaThreshold, 0)
+        // Nudge up 0.5pt so the centered stroke clears the DI's top line
+        // instead of sitting half-behind it.
+        expandedTopOffset = topOffset + Self.expandedTopNudge
+        expandedWidth = max(1, size.width - (topOffset * 2))
+
+        let baseHeight = hasDynamicIsland ? Self.dynamicIslandBaseHeight : Self.standardBaseHeight
+        contentTopClearance = hasDynamicIsland ? Self.compactIslandHeight + Self.dynamicIslandContentGap : 0
+        contentBottomPadding = hasDynamicIsland ? Self.dynamicIslandBottomPadding : 0
+        let reservedContentInset = hasDynamicIsland
+            ? contentTopClearance + contentBottomPadding
+            : Self.standardContentInset
+        baseContentArea = max(1, baseHeight - reservedContentInset)
+        let overflow = max(0, measuredContentHeight - baseContentArea)
+        expandedHeight = baseHeight + overflow
+    }
+}
+
 struct ToastIconView: View {
     let toast: Toast
     let isExpanded: Bool

package/ios/Tests/PrettyToastPluginTests/PrettyToastPluginTests.swift

@@ -1,4 +1,5 @@
 import XCTest
+import CoreGraphics
 @testable import PrettyToastPlugin
 
 final class PrettyToastPluginTests: XCTestCase {
@@ -18,4 +19,50 @@ final class PrettyToastPluginTests: XCTestCase {
         let color = PrettyToastColorParser.parse("#FF0000")
         XCTAssertNotNil(color)
     }
+
+    func testDynamicIslandLayoutReservesCutoutClearanceBeforeTextMeasurement() {
+        let layout = PrettyToastLayout(
+            size: CGSize(width: 402, height: 874),
+            safeAreaTop: 62,
+            measuredContentHeight: 0,
+            useDynamicIsland: true
+        )
+
+        XCTAssertTrue(layout.hasDynamicIsland)
+        XCTAssertGreaterThan(layout.contentTopClearance, PrettyToastLayout.compactIslandHeight)
+        XCTAssertEqual(layout.contentBottomPadding, 12)
+        XCTAssertGreaterThan(layout.baseContentArea, 0)
+    }
+
+    func testDynamicIslandLayoutGrowsWithoutChangingCutoutClearance() {
+        let initialLayout = PrettyToastLayout(
+            size: CGSize(width: 402, height: 874),
+            safeAreaTop: 62,
+            measuredContentHeight: 0,
+            useDynamicIsland: true
+        )
+        let overflowingContentHeight = initialLayout.baseContentArea + 24
+        let measuredLayout = PrettyToastLayout(
+            size: CGSize(width: 402, height: 874),
+            safeAreaTop: 62,
+            measuredContentHeight: overflowingContentHeight,
+            useDynamicIsland: true
+        )
+
+        XCTAssertEqual(measuredLayout.contentTopClearance, initialLayout.contentTopClearance)
+        XCTAssertEqual(measuredLayout.expandedHeight, initialLayout.expandedHeight + 24, accuracy: 0.001)
+    }
+
+    func testStandardLayoutDoesNotApplyDynamicIslandClearance() {
+        let layout = PrettyToastLayout(
+            size: CGSize(width: 390, height: 844),
+            safeAreaTop: 47,
+            measuredContentHeight: 0,
+            useDynamicIsland: true
+        )
+
+        XCTAssertFalse(layout.hasDynamicIsland)
+        XCTAssertEqual(layout.contentTopClearance, 0)
+        XCTAssertEqual(layout.contentBottomPadding, 0)
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-pretty-toast",
-  "version": "8.1.8",
+  "version": "8.1.9",
   "description": "Native-first pretty toast notifications for Capacitor and the web",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",