Issues with SwiftUI LazyVStack and onLoad Modifier below iOS 17

[marisol-develop]

Hello! 👋

I am using SwiftUI + TCA with a minimum deployment target of iOS 16.0.
I am encountering some issues where certain features work correctly on iOS 17 and above but behave differently on versions below 17.

1.

In the LazyVStack's Section header, I have a condition to show a specific view if the condition is true and hide it if false. However, even when the condition is false, the view is still being displayed. Only when I set the opacity based on the same condition does the view finally get hidden.

Why is the view being displayed even when the condition is false?

LazyVStack(spacing: 0.0, pinnedViews: .sectionHeaders) {
    Section {
        VStack { ... }
    } header: {
        if store.scrollViewOffset <= store.scrollViewOffsetLimit { // ✔️ same condition (but doesn't work ❌)
            WithPerceptionTracking {
                headerView
                    .opacity(store.scrollViewOffset <= store.scrollViewOffsetLimit ? 1 : 0) // ✔️ same condition (work as expect ✅)
            }
        }
    }
}

2.

I am using an onLoad view modifier to execute logic only when the view is first loaded. However, on versions below 17, onLoad is being called twice. I suspect that the state of the didLoad property inside onLoad might be getting reset. I am curious about this as well.

[onLoad Modifier Implementation]

private struct ViewDidLoadModifier: ViewModifier {

    @State private var didLoad = false
    private let action: () -> Void

    init(perform action: @escaping () -> Void) {
        self.action = action
    }

    func body(content: Content) -> some View {
        content.task {
            if didLoad == false {
                didLoad = true
                action()
            }
        }
    }
}

extension View {
    func onLoad(perform action: @escaping () -> Void) -> some View {
        modifier(ViewDidLoadModifier(perform: action))
    }
}

[onLoad ViewModifier Usage]

struct SomeView: View {
    @Perception.Bindable private var store: StoreOf<SomeFeature>

    var body: some View {
        WithPerceptionTracking {
            Group {
                // view implementation
            }
            .onLoad {
                store.send(.onLoad) <- 🛑 called twice
            }
        }
    }
}

@Reducer
struct CSFeature {
    @ObservableState
    struct State: Equatable {
        var isLoaded: Bool = false
        ...
    }

    enum Action: BindableAction {
        case onLoad
        ...
    }

    var body: some ReducerOf<Self> {
        BindingReducer()
        
        Reduce<State, Action> { state, action in
            switch action {
            case .onLoad:
                guard state.isLoaded == false else {
                    return .none
                }
                
                state.isLoaded = true
                
                return .run { send in
                    // some api request
                }
            // other actions...
            }
        }
    }
}

Thank you in advance for your help, and please let me know if you need any additional information! 🙇‍♀️

[Alex293]

Move the perceptiontracking up above the condition

[marisol-develop]

i already tried it but didn't work :(
Does WithPerceptionTracking should be outside of the condition to work properly?

[Alex293]

Yes inside each lazy closure where you access a property of the store. Here you need one inside the lazy stack