@capgo/capacitor-pretty-toast 8.1.0

package/ios/Sources/PrettyToastPlugin/PrettyToastView.swift

@@ -0,0 +1,267 @@
+import SwiftUI
+
+struct PrettyToastView: View {
+    @ObservedObject var window: PassThroughWindow
+    @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
+
+            let scaleX: CGFloat = isExpanded ? 1 : (dynamicIslandWidth / expandedWidth)
+            let scaleY: CGFloat = isExpanded ? 1 : (dynamicIslandHeight / expandedHeight)
+
+            ZStack {
+                toastBackground()
+                    .overlay {
+                        toastContent(haveDynamicIsland, expandedWidth: expandedWidth)
+                            .frame(width: expandedWidth, height: expandedHeight)
+                            .scaleEffect(x: scaleX, y: scaleY)
+                    }
+                    .frame(
+                        width: isExpanded ? expandedWidth : dynamicIslandWidth,
+                        height: isExpanded ? expandedHeight : dynamicIslandHeight
+                    )
+                    .opacity(haveDynamicIsland ? 1 : (isExpanded ? 1 : 0))
+                    .modifier(CapsuleOpacityModifier(
+                        haveDynamicIsland: haveDynamicIsland,
+                        isExpanded: isExpanded
+                    ))
+                    .modifier(GeometryGroupModifier())
+                    .contentShape(Rectangle())
+                    .onTapGesture {
+                        window.wasTapped = true
+                    }
+                    .gesture(
+                        DragGesture(minimumDistance: 2).onEnded { value in
+                            if value.translation.height < -8 || value.predictedEndTranslation.height < -40 {
+                                window.isPresented = false
+                            }
+                        }
+                    )
+                    .offset(y: haveDynamicIsland ? (isExpanded ? expandedTopOffset : topOffset) : 0)
+            }
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
+            .padding(.top, haveDynamicIsland ? 0 : (isExpanded ? max(safeArea.top, 10) : 0))
+            .ignoresSafeArea()
+            .animation(.bouncy(duration: 0.3, extraBounce: 0), value: isExpanded)
+        }
+    }
+
+    @ViewBuilder
+    func toastContent(_ haveDynamicIsland: Bool, expandedWidth: CGFloat) -> some View {
+        if let toast = window.toast {
+            VStack(spacing: 0) {
+                if haveDynamicIsland && !toast.message.isEmpty {
+                    Spacer(minLength: 0)
+                }
+
+                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)
+                    }
+                }
+            }
+            .padding(.horizontal, 20)
+            .padding(.bottom, haveDynamicIsland && !toast.message.isEmpty ? 12 : 0)
+            .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)
+
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(toast.title)
+                        .font(.callout)
+                        .fontWeight(.semibold)
+
+                    if !toast.message.isEmpty {
+                        Text(toast.message)
+                            .font(.caption)
+                    }
+                }
+                .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
+            }
+        }
+    }
+
+    private func toastBackground() -> some View {
+        let accent = window.toast?.accentColor ?? .white
+        let strokeOverride = window.toast?.strokeOverride
+        let disableSampling = window.toast?.disableBackdropSampling ?? false
+        let tint: BackdropTint = disableSampling ? .gray : window.backdropTint
+        return makeStrokeBackground(
+            shape: RoundedRectangle(cornerRadius: 30, style: .continuous),
+            accent: accent,
+            strokeOverride: strokeOverride,
+            tint: tint
+        )
+    }
+
+    private func makeStrokeBackground<S: Shape>(
+        shape: S,
+        accent: Color,
+        strokeOverride: Color?,
+        tint: BackdropTint
+    ) -> some View {
+        shape
+            .fill(.black)
+            .overlay {
+                ZStack {
+                    if let override = strokeOverride {
+                        strokeLayer(shape: shape, color: override, alpha: 1.0, visible: isExpanded)
+                    } else {
+                        strokeLayer(shape: shape, color: accent, alpha: 0.2, visible: isExpanded && tint == .colored)
+                        strokeLayer(shape: shape, color: .white, alpha: 0.06, visible: isExpanded && tint == .gray)
+                    }
+                }
+            }
+    }
+
+    @ViewBuilder
+    private func strokeLayer<S: Shape>(shape: S, color: Color, alpha: Double, visible: Bool) -> some View {
+        let stroke = shape.stroke(color.opacity(alpha), lineWidth: 1.5)
+        if #available(iOS 17, *) {
+            // Scope easeInOut to opacity only; frame changes keep the bouncy
+            // ambient animation so the stroke tracks the pill geometry.
+            stroke.animation(.easeInOut(duration: 0.3)) { view in
+                view.opacity(visible ? 1 : 0)
+            }
+        } else {
+            stroke
+                .opacity(visible ? 1 : 0)
+                .animation(.easeInOut(duration: 0.3), value: visible)
+        }
+    }
+
+    var isExpanded: Bool {
+        window.isPresented
+    }
+}
+
+struct ToastIconView: View {
+    let toast: Toast
+    let isExpanded: Bool
+
+    var body: some View {
+        if let image = toast.customIcon {
+            Image(uiImage: image)
+                .resizable()
+                .renderingMode(.original)
+                .aspectRatio(contentMode: .fit)
+                .frame(width: 35, height: 35)
+        } else {
+            Image(systemName: toast.symbol)
+                .font(toast.symbolFont)
+                .foregroundStyle(toast.symbolForegroundStyle.0, toast.symbolForegroundStyle.1)
+                .modifier(WiggleModifier(isExpanded: isExpanded))
+        }
+    }
+}
+
+private struct ContentHeightKey: PreferenceKey {
+    static var defaultValue: CGFloat = 0
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = max(value, nextValue())
+    }
+}
+
+private struct WiggleModifier: ViewModifier {
+    let isExpanded: Bool
+
+    func body(content: Content) -> some View {
+        if #available(iOS 18, *) {
+            content.symbolEffect(.wiggle, value: isExpanded)
+        } else {
+            content
+        }
+    }
+}
+
+private struct CapsuleOpacityModifier: ViewModifier {
+    let haveDynamicIsland: Bool
+    let isExpanded: Bool
+
+    func body(content: Content) -> some View {
+        if #available(iOS 17, *) {
+            content
+                .animation(.linear(duration: 0.02).delay(isExpanded ? 0 : 0.28)) { inner in
+                    inner.opacity(haveDynamicIsland ? (isExpanded ? 1 : 0) : 1)
+                }
+        } else {
+            content
+                .opacity(haveDynamicIsland ? (isExpanded ? 1 : 0) : 1)
+                .animation(.linear(duration: 0.02).delay(isExpanded ? 0 : 0.28), value: isExpanded)
+        }
+    }
+}
+
+private struct GeometryGroupModifier: ViewModifier {
+    func body(content: Content) -> some View {
+        if #available(iOS 17, *) {
+            content.geometryGroup()
+        } else {
+            content
+        }
+    }
+}

package/ios/Sources/PrettyToastPlugin/Toast.swift

@@ -0,0 +1,29 @@
+import SwiftUI
+import UIKit
+
+struct Toast {
+    private(set) var id: String = UUID().uuidString
+    var symbol: String
+    var symbolFont: Font
+    var symbolForegroundStyle: (Color, Color)
+    var title: String
+    var message: String
+    /// Optional custom icon image, resolved from an ImageSourcePropType URI.
+    /// When present, overrides the SF Symbol.
+    var customIcon: UIImage?
+    /// Explicit accent override — when set, drives both the icon fill and the
+    /// pill's accent stroke, bypassing the symbol-derived default.
+    var accentOverride: Color?
+    /// Explicit stroke color — when set, bypasses the backdrop sampler and
+    /// paints a fixed outline.
+    var strokeOverride: Color?
+    /// Skip the backdrop luminance sampler. The outline falls back to the
+    /// neutral gray stroke on any backdrop.
+    var disableBackdropSampling: Bool = false
+    /// Label for an optional trailing action button in the pill.
+    var actionLabel: String?
+
+    /// SF Symbol fill color — doubles as the pill's accent tint for the
+    /// Apple-style stroke we draw around the expanded pill in dark mode.
+    var accentColor: Color { accentOverride ?? symbolForegroundStyle.1 }
+}

package/ios/Sources/PrettyToastPlugin/ToastManager.swift

@@ -0,0 +1,392 @@
+import SwiftUI
+import Combine
+import UIKit
+
+// The bridge intentionally mirrors the JS payload shape, so the public
+// native entrypoints are wider than SwiftLint's default preference.
+// swiftlint:disable function_parameter_count
+@objc public class ToastManager: NSObject {
+    private var overlayWindow: PassThroughWindow?
+    private var hostingController: CustomHostingView?
+    private var autoDismissTimer: Timer?
+    private var dismissCancellable: AnyCancellable?
+    private var tapCancellable: AnyCancellable?
+    private var actionCancellable: AnyCancellable?
+    // Guards against double-firing onDismiss when a programmatic dismiss
+    // also trips the Combine subscription on `isPresented`.
+    private var isDismissing = false
+    // Deferred so the status bar doesn't flash back in mid-collapse, and
+    // cancellable so a queued toast keeps it hidden across the handoff.
+    private var statusBarRestoreWorkItem: DispatchWorkItem?
+    private var imageLoadTask: URLSessionDataTask?
+
+    @objc public var onDismiss: (() -> Void)?
+    @objc public var onPress: (() -> Void)?
+    @objc public var onActionPress: (() -> Void)?
+
+    @objc public func show(
+        icon: String,
+        iconUri: String,
+        title: String,
+        message: String,
+        duration: Int,
+        autoDismiss: Bool,
+        enableSwipeDismiss: Bool,
+        useDynamicIsland: Bool,
+        accentColor: UIColor?,
+        strokeColor: UIColor?,
+        disableBackdropSampling: Bool,
+        actionLabel: String,
+        accessibilityAnnouncement: String
+    ) {
+        let isFirstShow = overlayWindow == nil
+        ensureOverlayWindow()
+
+        guard let overlayWindow else { return }
+
+        let (primary, secondary) = iconColors(for: icon)
+        let accent = accentColor.map { Color($0) }
+        let stroke = strokeColor.map { Color($0) }
+
+        let toast = Toast(
+            symbol: icon,
+            symbolFont: .system(size: 35),
+            symbolForegroundStyle: (primary, accent ?? secondary),
+            title: title,
+            message: message,
+            customIcon: nil,
+            accentOverride: accent,
+            strokeOverride: stroke,
+            disableBackdropSampling: disableBackdropSampling,
+            actionLabel: actionLabel.isEmpty ? nil : actionLabel
+        )
+
+        overlayWindow.toast = toast
+        overlayWindow.useDynamicIsland = useDynamicIsland
+        overlayWindow.wasTapped = false
+        overlayWindow.actionTapped = false
+        isDismissing = false
+
+        loadCustomIconIfNeeded(uri: iconUri)
+
+        let present = { [weak self] in
+            guard let self, let overlayWindow = self.overlayWindow else { return }
+            overlayWindow.isPresented = true
+            if !disableBackdropSampling {
+                overlayWindow.startBackdropSampling()
+            }
+            self.cancelStatusBarRestore()
+            self.hostingController?.isStatusBarHidden = true
+            overlayWindow.makeKey()
+
+            self.cancelTimer()
+            if autoDismiss && duration > 0 {
+                let interval = TimeInterval(duration) / 1000.0
+                self.autoDismissTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
+                    DispatchQueue.main.async {
+                        self?.dismiss()
+                    }
+                }
+            }
+
+            if !accessibilityAnnouncement.isEmpty {
+                UIAccessibility.post(notification: .announcement, argument: accessibilityAnnouncement)
+            }
+        }
+
+        if isFirstShow {
+            DispatchQueue.main.async(execute: present)
+        } else {
+            present()
+        }
+    }
+
+    @objc public func update(
+        icon: String,
+        iconUri: String,
+        title: String,
+        message: String,
+        duration: Int,
+        autoDismiss: Bool,
+        accentColor: UIColor?,
+        strokeColor: UIColor?,
+        disableBackdropSampling: Bool,
+        actionLabel: String
+    ) {
+        guard let overlayWindow, overlayWindow.isPresented else { return }
+
+        let (primary, secondary) = iconColors(for: icon)
+        let accent = accentColor.map { Color($0) }
+        let stroke = strokeColor.map { Color($0) }
+
+        // Carry the resolved customIcon forward; loadCustomIconIfNeeded
+        // swaps it if the URI changed.
+        let previous = overlayWindow.toast
+        overlayWindow.toast = Toast(
+            symbol: icon,
+            symbolFont: .system(size: 35),
+            symbolForegroundStyle: (primary, accent ?? secondary),
+            title: title,
+            message: message,
+            customIcon: previous?.customIcon,
+            accentOverride: accent,
+            strokeOverride: stroke,
+            disableBackdropSampling: disableBackdropSampling,
+            actionLabel: actionLabel.isEmpty ? nil : actionLabel
+        )
+
+        loadCustomIconIfNeeded(uri: iconUri)
+
+        if disableBackdropSampling {
+            overlayWindow.stopBackdropSampling()
+        } else if overlayWindow.isPresented {
+            overlayWindow.startBackdropSampling()
+        }
+
+        cancelTimer()
+        if autoDismiss && duration > 0 {
+            let interval = TimeInterval(duration) / 1000.0
+            autoDismissTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: false) { [weak self] _ in
+                DispatchQueue.main.async {
+                    self?.dismiss()
+                }
+            }
+        }
+    }
+
+    @objc public func dismiss() {
+        cancelTimer()
+
+        guard let overlayWindow, overlayWindow.isPresented, !isDismissing else { return }
+        isDismissing = true
+
+        overlayWindow.isPresented = false
+        overlayWindow.stopBackdropSampling()
+        imageLoadTask?.cancel()
+        imageLoadTask = nil
+        scheduleStatusBarRestore()
+
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self] in
+            self?.onDismiss?()
+        }
+    }
+
+    // MARK: - Overlay Window
+
+    private func ensureOverlayWindow() {
+        guard let windowScene = UIApplication.shared.connectedScenes
+                .compactMap({ $0 as? UIWindowScene })
+                .first(where: { $0.activationState == .foregroundActive }) else { return }
+
+        if let existing = windowScene.windows.first(where: { $0.tag == 1009 }) as? PassThroughWindow {
+            overlayWindow = existing
+            hostingController = existing.rootViewController as? CustomHostingView
+        } else {
+            let window = PassThroughWindow(windowScene: windowScene)
+            window.backgroundColor = .clear
+            window.isHidden = false
+            window.isUserInteractionEnabled = true
+            window.tag = 1009
+
+            let hosting = CustomHostingView(
+                rootView: PrettyToastView(window: window)
+            )
+            hosting.view.backgroundColor = .clear
+            window.rootViewController = hosting
+
+            overlayWindow = window
+            hostingController = hosting
+        }
+
+        observeDismiss()
+        observeTap()
+        observeAction()
+    }
+
+    // Catches swipe-dismissals that flip `isPresented` from outside dismiss().
+    private func observeDismiss() {
+        guard let overlayWindow else { return }
+
+        dismissCancellable = overlayWindow.$isPresented
+            .dropFirst()
+            .filter { !$0 }
+            .sink { [weak self] _ in
+                guard let self, !self.isDismissing else { return }
+                self.isDismissing = true
+                self.cancelTimer()
+                self.overlayWindow?.stopBackdropSampling()
+                self.scheduleStatusBarRestore()
+
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self] in
+                    self?.onDismiss?()
+                }
+            }
+    }
+
+    private func observeTap() {
+        guard let overlayWindow else { return }
+
+        tapCancellable = overlayWindow.$wasTapped
+            .dropFirst()
+            .filter { $0 }
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.overlayWindow?.wasTapped = false
+                self.onPress?()
+            }
+    }
+
+    private func observeAction() {
+        guard let overlayWindow else { return }
+
+        actionCancellable = overlayWindow.$actionTapped
+            .dropFirst()
+            .filter { $0 }
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.overlayWindow?.actionTapped = false
+                self.onActionPress?()
+            }
+    }
+
+    // MARK: - Helpers
+
+    private func loadCustomIconIfNeeded(uri: String) {
+        imageLoadTask?.cancel()
+        imageLoadTask = nil
+
+        if uri.isEmpty {
+            overlayWindow?.toast?.customIcon = nil
+            return
+        }
+
+        if let image = imageFromDataURL(uri) {
+            if var currentToast = overlayWindow?.toast {
+                currentToast.customIcon = image
+                overlayWindow?.toast = currentToast
+            }
+            return
+        }
+
+        // file:// URIs load synchronously; remote URLs fall through below.
+        if let url = URL(string: uri),
+           url.isFileURL,
+           let image = UIImage(contentsOfFile: url.path) {
+            overlayWindow?.toast?.customIcon = image
+            // Reassign the whole struct so @Published fires.
+            if var currentToast = overlayWindow?.toast {
+                currentToast.customIcon = image
+                overlayWindow?.toast = currentToast
+            }
+            return
+        }
+
+        guard let url = URL(string: uri) else { return }
+
+        imageLoadTask = URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
+            guard let self, let data, let image = UIImage(data: data) else { return }
+            DispatchQueue.main.async {
+                if var currentToast = self.overlayWindow?.toast {
+                    currentToast.customIcon = image
+                    self.overlayWindow?.toast = currentToast
+                }
+            }
+        }
+        imageLoadTask?.resume()
+    }
+
+    private func restoreKeyWindow() {
+        UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.tag != 1009 && !$0.isHidden }?
+            .makeKey()
+    }
+
+    private func cancelTimer() {
+        autoDismissTimer?.invalidate()
+        autoDismissTimer = nil
+    }
+
+    // 0.5s ≈ collapse animation (0.35s) + JS round-trip slack so a follow-up
+    // show() can cancel this and keep the status bar hidden. Key-window
+    // handoff is bundled in to prevent the status bar from fading in
+    // behind the shrinking pill.
+    private func scheduleStatusBarRestore() {
+        statusBarRestoreWorkItem?.cancel()
+        let work = DispatchWorkItem { [weak self] in
+            guard let self else { return }
+            self.hostingController?.isStatusBarHidden = false
+            self.restoreKeyWindow()
+        }
+        statusBarRestoreWorkItem = work
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: work)
+    }
+
+    private func cancelStatusBarRestore() {
+        statusBarRestoreWorkItem?.cancel()
+        statusBarRestoreWorkItem = nil
+    }
+
+    private func imageFromDataURL(_ uri: String) -> UIImage? {
+        guard uri.starts(with: "data:"),
+              let commaIndex = uri.firstIndex(of: ",") else {
+            return nil
+        }
+
+        let metadata = String(uri[..<commaIndex])
+        let encodedPayload = String(uri[uri.index(after: commaIndex)...])
+
+        if metadata.contains(";base64"),
+           let data = Data(base64Encoded: encodedPayload) {
+            return UIImage(data: data)
+        }
+
+        let payload = encodedPayload.removingPercentEncoding ?? encodedPayload
+        return UIImage(data: Data(payload.utf8))
+    }
+
+    deinit {
+        // deinit may run off-main; Timer/UIWindow teardown must happen on
+        // main, so hop over before breaking the retain cycle.
+        let window = overlayWindow
+        let dismissCancel = dismissCancellable
+        let tapCancel = tapCancellable
+        let actionCancel = actionCancellable
+        let timer = autoDismissTimer
+        let workItem = statusBarRestoreWorkItem
+        let loadTask = imageLoadTask
+        DispatchQueue.main.async {
+            timer?.invalidate()
+            workItem?.cancel()
+            dismissCancel?.cancel()
+            tapCancel?.cancel()
+            actionCancel?.cancel()
+            loadTask?.cancel()
+            window?.stopBackdropSampling()
+            // Break the window ↔ hosting controller ↔ PrettyToastView cycle
+            // so the window can actually deallocate.
+            window?.rootViewController = nil
+            window?.isHidden = true
+        }
+    }
+
+    private func iconColors(for symbol: String) -> (Color, Color) {
+        if symbol.contains("checkmark") {
+            return (.white, .green)
+        } else if symbol.contains("xmark") {
+            return (.white, .red)
+        } else if symbol.contains("exclamation") {
+            return (.white, .orange)
+        } else if symbol.contains("info") {
+            return (.white, .blue)
+        } else if symbol.contains("heart") {
+            return (.white, .pink)
+        } else if symbol.contains("arrow") {
+            return (.white, .blue)
+        } else {
+            return (.white, .gray)
+        }
+    }
+}
+// swiftlint:enable function_parameter_count