How Can I wrapping .sheet modifier for version branching.

[JongHoooon]

Hello!

I want wrapping .sheet modifier for version branching

• modifier

import SwiftUI

import ComposableArchitecture

struct CustomBottomSheetModifer<BottomSheetContent: View>: ViewModifier {
    @State private var bottomSheetHeight: CGFloat = 0.0
    private let showDragIndicator: Bool
    @Binding private var item: StoreOf<Reduce<Any, Never>>?
    private let bottomSheetContent: BottomSheetContent

    init(
        showDragIndicator: Bool,
        item: Binding<StoreOf<Reduce<Any, Never>>?>,
        @ViewBuilder bottomSheetContent: () -> BottomSheetContent
    ) {
        self.showDragIndicator = showDragIndicator
        self._item = item
        self.bottomSheetContent = bottomSheetContent()
    }
    
    func body(content: Content) -> some View {
        content
            .sheet(
                item: $item,
                content: { _ in
                    if #available(iOS 16.4, *) {
                        bottomSheetContent
                            .scrollBounceBehavior(.basedOnSize)
                            .presentationCornerRadius(20.0)
                    } else {
                        bottomSheetContent
                    }
                }
            )
    }
}

• view for using

@Perception.Bindable private var store: StoreOf<TestFeature>
    
    init(
        store: StoreOf<TestFeature>
    ) {
        self.store = store
    }
    
    var body: some View {
        WithPerceptionTracking {
          ScrollView {

          }
          .customBottomSheet(
                showDragIndicator: true,
                item: $store.scope(
                    state: \.destination?.selectCardInstallmentOptionBottomSheet,
                    action: \.destination.selectCardInstallmentOptionBottomSheet
                ),
                bottomSheetContent: {
                    Color(.red)
                        .frame(maxWidth: .infinity)
                        .frame(height: 300.0)
                }
            )
      }
}

• reducer for using

import ComposableArchitecture

@Reducer
struct TestFeature {
    @ObservableState
    struct State: Equatable {
        @Presents var destination: Destination.State?
        init(
            checkoutOrderSeq: Int
        ) {
            self.checkoutOrderSeq = checkoutOrderSeq
        }
    }
    
    enum Action: BindableAction {
        case binding(BindingAction<State>)
        case destination(PresentationAction<Destination.Action>)
    }

    @Dependency(\.dismiss) var dismiss
    
    var body: some ReducerOf<Self> {
        BindingReducer()
        
        Reduce<State, Action> { state, action in
            switch action {
       
            case .selectCardInstallmentOptionButtonTapped:
                state.destination = .selectCardInstallmentOptionBottomSheet

            default:
                return .none
            }
        }
        .ifLet(\.$destination, action: \.destination)
    }
}

extension PaymentFeature {
    
    // MARK: - Destination
    
    @Reducer(state: .equatable)
    enum Destination {
        case selectCardInstallmentOptionBottomSheet
    }
}

it presents sheet at view onAppeared time and occurs this error

How can I fix it?? help me please 🙇‍♂️