How I Fixed SwiftUI NavigationStack's Maddening Re-Rendering Loop That Crashed My App

// This innocent-looking code was causing 47 re-renders per second
struct ContentView: View {
    @StateObject private var dataModel = DataModel()
    @State private var navigationPath = NavigationPath()
    
    var body: some View {
        NavigationStack(path: $navigationPath) {
            List(dataModel.items) { item in
                NavigationLink(value: item) {
                    ItemRow(item: item)
                        // This was the killer - updating in the navigation context
                        .onAppear {
                            dataModel.markAsViewed(item.id)
                        }
                }
            }
            .navigationDestination(for: Item.self) { item in
                DetailView(item: item, dataModel: dataModel)
            }
        }
    }
}

// DON'T DO THIS - This pattern caused our performance disaster
class DataModel: ObservableObject {
    @Published var items: [Item] = []
    @Published var selectedItemID: UUID?  // This single property caused chaos
    
    func updateItem(_ id: UUID) {
        // Any update here triggered full navigation re-render
        if let index = items.firstIndex(where: { $0.id == id }) {
            items[index].viewCount += 1
            selectedItemID = id  // The rendering explosion starts here
        }
    }
}

// The solution: Separate navigation state from data state
struct ContentView: View {
    @StateObject private var dataModel = DataModel()
    @StateObject private var navigationModel = NavigationModel()  // Separate state!
    
    var body: some View {
        NavigationStack(path: $navigationModel.path) {
            ItemListView()
                .environmentObject(dataModel)
                .environmentObject(navigationModel)
        }
    }
}

// Isolated navigation state management
class NavigationModel: ObservableObject {
    @Published var path = NavigationPath()
    
    // Only navigation-specific logic here
    func navigateToItem(_ item: Item) {
        path.append(item)
    }
}

// Data updates no longer trigger navigation re-renders
struct ItemRow: View {
    let item: Item
    @EnvironmentObject var dataModel: DataModel
    
    var body: some View {
        HStack {
            Text(item.title)
            Spacer()
            // This update no longer causes navigation chaos
            if item.isViewed {
                Image(systemName: "checkmark.circle.fill")
            }
        }
        .task {  // Use task instead of onAppear for async updates
            await dataModel.markAsViewedAsync(item.id)
        }
    }
}

// This coordinator pattern has saved me countless hours
@MainActor
class NavigationCoordinator: ObservableObject {
    @Published var path = NavigationPath()
    private var pathCache: [AnyHashable] = []  // Prevent duplicate navigations
    
    func navigate<T: Hashable>(to destination: T) {
        // Debounce navigation to prevent double-taps
        guard !pathCache.contains(AnyHashable(destination)) else { return }
        
        pathCache.append(AnyHashable(destination))
        path.append(destination)
        
        // Clear cache after navigation completes
        Task {
            try? await Task.sleep(for: .milliseconds(500))
            pathCache.removeAll(where: { $0 == AnyHashable(destination) })
        }
    }
    
    func popToRoot() {
        path.removeLast(path.count)
        pathCache.removeAll()
    }
}

// This pattern eliminated 90% of unnecessary re-renders
struct DetailViewModel {
    let item: Item
    let updateHandler: (Item) -> Void
    
    // Computed properties don't trigger re-renders
    var displayTitle: String {
        item.isViewed ? "✓ \(item.title)" : item.title
    }
    
    func markAsViewed() {
        var updatedItem = item
        updatedItem.isViewed = true
        updateHandler(updatedItem)  // Update happens outside navigation context
    }
}

struct OptimizedNavigationStack: View {
    @StateObject private var coordinator = NavigationCoordinator()
    @StateObject private var dataModel = DataModel()
    
    var body: some View {
        NavigationStack(path: $coordinator.path) {
            ItemListView()
                .navigationDestination(for: Item.self) { item in
                    // Use .id() to control re-rendering
                    DetailView(item: item)
                        .id(item.id)  // This prevents unnecessary re-renders
                        .equatable()  // Custom equality checking
                }
        }
        .environmentObject(coordinator)
        .environmentObject(dataModel)
        // This modifier is crucial for performance
        .navigationViewStyle(.stack)
    }
}

// Implement Equatable for fine-grained control
struct DetailView: View, Equatable {
    let item: Item
    
    static func == (lhs: DetailView, rhs: DetailView) -> Bool {
        // Only re-render if critical properties change
        lhs.item.id == rhs.item.id && 
        lhs.item.title == rhs.item.title
    }
    
    var body: some View {
        // View implementation
    }
}

// Add this to your app during development
extension View {
    func debugRendering(_ label: String) -> some View {
        let _ = Self._printChanges()  // SwiftUI's hidden debugging gem
        return self.onChange(of: UUID()) { _ in
            print("🔄 \(label) rendered at \(Date())")
        }
    }
}

// Usage in your views
NavigationStack(path: $path) {
    ContentView()
        .debugRendering("NavigationStack")
}

// This pattern can still cause rendering issues
.onOpenURL { url in
    // Rapidly pushing multiple views can overwhelm NavigationStack
    if let path = parseDeepLink(url) {
        for destination in path {
            navigationPath.append(destination)  // Potential rendering explosion
        }
    }
}

// The fix: Batch navigation updates
.onOpenURL { url in
    if let destinations = parseDeepLink(url) {
        Task {
            for (index, destination) in destinations.enumerated() {
                navigationPath.append(destination)
                // Critical: Allow render cycle to complete
                if index < destinations.count - 1 {
                    try? await Task.sleep(for: .milliseconds(50))
                }
            }
        }
    }
}

// Add this to prevent restoration rendering issues
.onAppear {
    // Disable automatic state restoration during critical operations
    if ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] == nil {
        // Your navigation setup here
    }
}