Abstracting from PresentedAction/State and StackAction/State

[rzolin]

The idea here is to create a generic router for features to construct the view hierarchy based on a set of parameter, such as NSUserActivity and URLs (deep links and restoration).
So my thinking is to create a sub reducer and try to route all UI actions (that change the state and set destinations) through its actions. Something like below (some code is redacted for simplicity):

public enum RouteAction<State, Action> {
    case show(state: State)
}

public struct ATAppFeature: Reducer {
    
    public struct State: Equatable {
        @PresentationState var route: Route.State?
        public var login = ATLoginFeature.State()
        
    }
    
    public enum Action: Equatable {
        case switchLogin
        case route(RouteAction<Route.State, Route.State>)
    }
    
    
    public var body: some ReducerOf<Self> {
        
        Reduce<State, Action> { state, action in
            switch action {

            case .switchToLogin:
                    .route(
                        .show(
                            state: .login(ATLoginFeature.State())
                        )
                    )}

            case let .route(action):
                switch action {
                case let .show(state: routeState):
                    switch routeState {
                    case let .login(loginState):
                        state.route = .login(loginState)   // <<-- That's where I end up
                        return .none
                    default: return .none
                    }
                default: return .none
                }
                return .none
            }
     }
}

extension ATAppFeature {
 
    public enum Route: Reducer {

        public enum State: Equatable {
            case login(ATLoginFeature.State)
        }

        public enum Action: Equatable {
            case toLogin(ATLoginFeature.Action)
        }
        
        public var body: some ReducerOf<Self> {
            Reduce<State, Action> { state, action in
                switch action {
                case let .toLogin(state):
                    return .none
                }
            }
        }
    }    
}

I get to the point where I set the ATAppFeature.State.route (seems like too deep, and not quite useful), but not sure where to go from here. Also probably the RouteAction/State should be extended/defined, as well as the @PresentationState is not the right wrapper (need a new one)?

Or is the whole approach flawed, and I should think "functions" on the reducer?

[rzolin]

It seems there is simpler way with enum and functions:

extension ATAppFeature {

    enum Route {
        case login(sessionId: UUID? = nil, userName: String? = nil, password: String? = nil)
        case signup(sessionId: UUID? = nil, userName: String? = nil, password: String? = nil, email: String? = nil, token: String? = nil)
        case content(tab: Int? = nil)
        
        func view(with store: StoreOf<ATAppFeature>) -> some View {
            Group {
                switch self {

                case .login:
                    NavigationStack {
                        ATLoginView(
                            store: store.scope(
                                state: \.login,
                                action: ATAppFeature.Action.showLogin
                            )
                        )
                    }
                    
                case .signup, .signupEmailVerification:
                    NavigationStack {
                        ATSignupView(
                            store: store.scope(
                                state: \.signup,
                                action: ATAppFeature.Action.showSignup
                            )
                        )
                    }
                
                case .content:
                    ATContentView()
                }
            }
        }
    }
    
    func route(to route: Route, with state: inout ATAppFeature.State) -> Effect<ATAppFeature.Action> {
        switch route {
            
        case let .login(_, userName, password):
            state.login.userName = userName
            state.login.password = password
            state.flow = .login
            return .none

        case let .signup(_, userName, password, _, _):
            state.signup.userName = userName
            state.signup.password = password
            state.flow = .signup
            return .none
    
        case let .signupEmailVerification(_, userName, password, email, token):
            state.signup.userName = userName
            state.signup.password = password
            state.signup.destination = .emailVerification(ATEmailConfirmationFeature.State(email: email, login: userName, token: token))
            state.flow = .signup
            return .none
        
        case .content:
            state.flow = .content
            return .none
        }
    }  
}

and now I can use it...

in Reducer:

            case let .showLogin:
                return route(to: .login(), with: &state)

in View:

 public var body: some View {
        WithViewStore(self.store, observe: ViewState.init) { viewStore in
            Group {
                switch (viewStore.flow) {
                case .login:        ATAppFeature.Route.login().view(with: store)
                case .signup:       ATAppFeature.Route.signup().view(with: store)
                case .content:      ATAppFeature.Route.content().view(with: store)
                }
            }

The only thing that bothers me is the need to provide state. Would be great to access it through the feature, but haven't found the way. As well as shortening the ATAppFeature.Route.login() to something like .login()