Register delegate call from child within parent

[appfrosch]

I am on

• Xcode 14.3
• TCA prerelease/1.0

I have a simple list of items in one screen and a settings screen. What I want to accomplish is

• navigating to the settings screen
• clear the item list there (in my real world app I'd like clear from persistence there)
• when I get back to the list view, obviously I'd like the list in memory to be cleared as well

I think I learnt in https://www.pointfree.co/collections/composable-architecture/navigation/ep222-composable-navigation-tabs, that such things are done with delegates.

I have implemented such a delegate and a delegate action in the settings screen, but right now, I am failing to listen to this delegate from the parent.

Specifically, I am getting the following errors in the item list reducer:

1. Cannot infer contextual base in reference to member 'clearListInMemory'
2. Type 'PresentationAction<SettingsDomain.Action>' has no member 'delegate'

What am I missing?

Here's the code:

import ComposableArchitecture
import SwiftUI

struct ContentView: View {
    var body: some View {
        ItemListView(
            store: Store(
                initialState: ItemListDomain.State(
                    items: [
                        Item(id: UUID()),
                        Item(id: UUID()),
                        Item(id: UUID()),
                    ]
                ),
                reducer: ItemListDomain()
            )
        )
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

struct Item: Identifiable, Equatable {
    let id: UUID
    var description: String {
        self.id.uuidString
    }
}

struct ItemListDomain: Reducer {
    struct State: Equatable {
        var items: [Item]
        @PresentationState var showSettings: SettingsDomain.State?
    }
    enum Action: Equatable {
        case showSettings(PresentationAction<SettingsDomain.Action>)
        case showSettingsButtonTapped
    }
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
                
            // below line produces the following errors:
            // 1. Cannot infer contextual base in reference to member 'clearListInMemory'
            // 2. Type 'PresentationAction<SettingsDomain.Action>' has no member 'delegate'
            case .showSettings(.delegate(.clearListInMemory)):
                return .none
            case .showSettings:
                return .none
            case .showSettingsButtonTapped:
                state.showSettings = SettingsDomain.State(items: state.items)
                return .none
            }
        }
        ._printChanges()
        .ifLet(\.$showSettings, action: /Action.showSettings) { SettingsDomain() }
    }
}

struct ItemListView: View {
    let store: StoreOf<ItemListDomain>
    
    var body: some View {
        WithViewStore(self.store, observe: { $0 }) { viewStore in
            NavigationStack {
                List {
                    ForEach(viewStore.items) { item in
                        Text(item.description)
                    }
                }
                .toolbar {
                    ToolbarItem(placement: .automatic) {
                        Button {
                            viewStore.send(.showSettingsButtonTapped)
                        } label: {
                            Label("Settings", systemImage: "gear")
                        }
                        .navigationDestination(
                            store: self.store.scope(
                                state: \.$showSettings,
                                action: ItemListDomain.Action.showSettings
                            )
                        ) { store in
                                SettingsView(store: store)
                        }
                    }
                }
            }
        }
    }
}

struct SettingsDomain: Reducer {
    struct State: Equatable {
        var items: [Item]
    }
    enum Action: Equatable {
        case clearAllItemsButtonTapped
        case delegate(Delegate)
        
        enum Delegate: Equatable {
            case clearListInMemory
        }
    }
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .clearAllItemsButtonTapped:
                state.items.removeAll()
                return .send(.delegate(.clearListInMemory))
            case .delegate:
                return .none
            }
        }
        ._printChanges()
    }
}

struct SettingsView: View {
    let store: StoreOf<SettingsDomain>
    
    var body: some View {
        WithViewStore(self.store, observe: { $0 }) { viewStore in
            Form {
                Button("Clear all items") {
                    viewStore.send(.clearAllItemsButtonTapped)
                }
            }
        }
    }
}

[ghost]

The problem with the line

            case .showSettings(.delegate(.clearListInMemory)):

is that the showSettings action takes in a PresentationAction of a SettingsDomain.Action, not a SettingsDomain.Action on its own:

        case showSettings(PresentationAction<SettingsDomain.Action>)

So, I think your handler case needs to be:

            case .showSettings(.presented(.delegate(.clearListInMemory))):

If you think about it, it makes sense because you only want to respond to that action when the child is presented.

I haven't tried the code above so I can't be 100% sure that it will work but I think what I wrote above is correct.

[appfrosch]

Thanks a lot, this absolutely resolved my issue, you were 💯 correct.

[ghost]

Most welcome. 😃