This file provides a safe way to open URLs in SwiftUI applications.

View+OpenUrl.swift

//
//  View+OpenUrl.swift
//
//  Created by James Sedlacek on 11/26/24.
//

/// This file provides a safe way to open URLs in SwiftUI applications.
/// It adds a view modifier that handles URL opening with user confirmation
/// and multiple opening options (browser, in-app, or copy to clipboard).
///
/// Usage example:
/// ```swift
/// struct ContentView: View {
///     @State private var urlToOpen: URL?
///
///     var body: some View {
///         Button("Open Website") {
///             urlToOpen = URL(string: "https://example.com")
///         }
///         .open(url: $urlToOpen)
///     }
/// }
/// ```

import SwiftUI
import WebKit

/// Provides safe URL opening functionality to any SwiftUI View.
@MainActor
public extension View {
    /// Adds safe URL opening functionality with user confirmation.
    /// - Parameter url: A binding to an optional URL that should be opened.
    /// - Returns: A view with URL opening capabilities.
    func open(url: Binding<URL?>) -> some View {
        modifier(OpenURLModifier(url: url))
    }
}

@MainActor
struct OpenURLModifier {
    @Environment(\.openURL) private var openURL
    @Binding private var urlToOpen: URL?
    @State private var isConfirmationPresented = false
    @State private var isWebViewPresented = false
    @State private var isCopyAlertPresented = false

    init(url: Binding<URL?>) {
        self._urlToOpen = url
    }

    private func onURLChange(_ oldUrl: URL?, _ newUrl: URL?) {
        guard newUrl != nil else { return }
        isConfirmationPresented = true
    }

    private func copyLinkAction() {
        guard let linkString = urlToOpen?.absoluteString else { return }
        ClipboardService.copy(linkString)
        isCopyAlertPresented = true
    }

    private func openInBrowserAction() {
        guard let urlToOpen else { return }
        openURL(urlToOpen)
        resetURLAction()
    }

    private func openInAppAction() {
        isWebViewPresented = true
    }

    private func resetURLAction() {
        Task {
            // Add a small delay to allow animations to complete
            // and provide a better user experience when transitioning
            // between different states (alerts, sheets, etc.)
            try? await Task.sleep(for: .seconds(1))
            urlToOpen = nil
        }
    }
}

extension OpenURLModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .onChange(of: urlToOpen, onURLChange)
            .confirmationDialog(
                .confirmationTitle,
                isPresented: $isConfirmationPresented,
                titleVisibility: .visible,
                actions: confirmationButtons
            )
            .alert(
                .copiedToClipboard,
                isPresented: $isCopyAlertPresented,
                actions: alertButtons
            )
            .sheet(
                isPresented: $isWebViewPresented,
                onDismiss: resetURLAction,
                content: webView
            )
    }

    @ViewBuilder
    private func confirmationButtons() -> some View {
        Button(.openInBrowser, action: openInBrowserAction)
        Button(.openInApp, action: openInAppAction)
        Button(.copyLink, action: copyLinkAction)
        Button(.cancel, role: .cancel, action: resetURLAction)
    }

    private func alertButtons() -> some View {
        Button(.ok, role: .cancel, action: resetURLAction)
    }

    @ViewBuilder
    private func webView() -> some View {
        if let urlToOpen {
            WebView(url: urlToOpen)
        }
    }
}

#if os(iOS)
typealias ViewRepresentable = UIViewRepresentable
#elseif os(macOS)
typealias ViewRepresentable = NSViewRepresentable
#endif

struct WebView: ViewRepresentable {
    let url: URL

    #if os(iOS)
    func makeUIView(context: Context) -> WKWebView {
        WKWebView()
    }

    func updateUIView(_ webView: WKWebView, context: Context) {
        webView.load(URLRequest(url: url))
    }
    #elseif os(macOS)
    func makeNSView(context: Context) -> WKWebView {
        WKWebView()
    }

    func updateNSView(_ webView: WKWebView, context: Context) {
        webView.load(URLRequest(url: url))
    }
    #endif
}

#if os(macOS)
import AppKit
#endif

struct ClipboardService {
    static func copy(_ string: String) {
        #if os(iOS)
        UIPasteboard.general.string = string
        #elseif os(macOS)
        NSPasteboard.general.clearContents()
        NSPasteboard.general.setString(string, forType: .string)
        #endif
    }
}

@MainActor
extension LocalizedStringKey {
    static let confirmationTitle = LocalizedStringKey("How would you like to handle this link?")
    static let openInBrowser = LocalizedStringKey("Open in Browser")
    static let openInApp = LocalizedStringKey("Open in App")
    static let copyLink = LocalizedStringKey("Copy Link")
    static let cancel = LocalizedStringKey("Cancel")
    static let copiedToClipboard = LocalizedStringKey("Copied to Clipboard")
    static let ok = LocalizedStringKey("OK")
}

Good job

Nice

It might be overcomplicating the implementation, but one thing I've been trying to do in my own code is to be more aware of Alex Ozun's points around type safety and illegal state

He talks about it here: https://swiftology.io/articles/making-illegal-states-unrepresentable/

In the OpenURLModifier, there are three bools where it looks like only one should be true at any time

I made a slight change to use an enum:

private enum PresentedOption {
   case confirmationDialog
   case webView
   case copyAlert
   case none
}

Handled as an @State:

struct OpenURLModifier {
   @State private var presentedOption: PresentedOption = .none
}

Which is used in place of the bools, for example:

    private func openInAppAction() {
        presentedOption = .webView
    }

That enum is then converted to a binding using an extension on OpenURLModifier:

extension OpenURLModifier {
   private func binding(for option: PresentedOption) -> Binding<Bool> {
       Binding(
           get: { presentedOption == option },
           set: { presentedOption = $0 ? option : .none }
       )
   }
}

And those bindings can be passed in where the bools were being used with the confirmationDialog, alert, and sheet:

    func body(content: Content) -> some View {
        content
            .onChange(of: urlToOpen, onURLChange)
            .confirmationDialog(
                .confirmationTitle,
                isPresented: binding(for: .confirmationDialog), // new binding created from enum
                titleVisibility: .visible,
                actions: confirmationButtons
            )
            .alert(
                .copiedToClipboard,
                isPresented: binding(for: .copyAlert),  // new binding created from enum
                actions: alertButtons
            )
            .sheet(
                isPresented: binding(for: .webView),  // new binding created from enum
                onDismiss: resetURLAction,
                content: webView
            )
    }

It's probably overkill in this use case, but it's a good thought exercise for identifying where illegal states can be implicit or hidden

It's not likely this code would change much, but if two of those bools were accidentally set to true at the same time it could cause a crash (just tested it in my simulator)

I really like this idea! I'll work on updating it later today.

extension OpenURLModifier {
   private func binding(for option: PresentedOption) -> Binding<Bool> {
       Binding(
           get: { presentedOption == option },
           set: { presentedOption = $0 ? option : .none }
       )
   }
}

I think it's nice to model state in a enum but the closure based Binding has to be evaluated all the time which is ineffecient.

Yeah I just messed around with the enum idea and I think it makes sense to stick with what I have.