Animating a child action

[JackYoustra]

Hello!

Suppose I have something along the lines of

CategorySelectionView(store: store.scope(state: \.categorySelection, action: Action.selection))
  List { // not actually a list, but same idea
      ForEachStore(store.scope(state: \.buttons, action: Action.transitionButton(id:action:))) { buttonStore in
          TransitionButton(store: buttonStore)
      }
}

And I want to animate the ForEachStore contents on changes to categorySelection to get changes to the list to animate and have the rows slide around and nice things like that.

I tried changing action: Action.selection to action: { a in withAnimation { Action.selection(a) } } but that didn't work

Changing

Scope(state: \.categorySelection, action: /Action.selection) {
    CategorySelection()
}

to

Scope(state: \.categorySelection, action: /Action.selection) {
    withAnimation {
        CategorySelection()
    }
}

gave me a compile error.

I could eschew the reducerBuilder syntax in the categorySelection Scope body, and replace with with something like

Scope(state: \.categorySelection, action: /Action.selection) {
    Reduce { state, action in
        withAnimation {
            CategorySelection().reduce(into: &state, action: action)
        }
    }
}

But that didn't work either! What should I do?

[tgrapperon]

Hey @JackYoustra! You can also try to directly act on SwiftUI:

.animation(.default, value: viewStore.categorySelection)

But the changes you'd want to animate should be simultaneous with categorySelection changes. In your case, it doesn't seem guaranteed, as you're basically nesting two sibling stores. I would expect the \.buttons domain to be a child domain of the \.categorySelection one, so maybe something is not optimal regarding domain modeling.

[JackYoustra]

Thanks for replying!
Yeah, I'm trying to avoid adding categorySelection to my ViewStore - buttons is a computed property based on categorySelection in the parent reducer. The idea is that you can add categorySelection to any reducer, and then filter... some state of yours based on the current selection. If you think there's a better way, do let me know.

Additionally, it probably won't trigger unnecessary refreshes - after all, changing the categorySelection will likely change the buttons which will cause the ForEachStore to refresh. You could imagine it not, though, and I was wondering (probably unnecessarily) how to dodge that refresh.

The parent state, btw, looks something like this:

State {
 			struct Origin {
				let choices: [Choice]
            	var categorySelection: String? = nil
			}
			var origin: Origin // non-injected properties
			let context: SomeContext

			var categorySelection: CategorySelection.State {
           	 get {
                CategorySelection.State(
                    categories: Array(choices.flatMap(\.categories).uniqued()),
                    selection: origin.categorySelection
                )
            } set {
                origin.categorySelection = newValue.selection
            }
        }

		var buttons: IdentifiedArrayOf<TransitionButtonCore<Element>.State> {
            IdentifiedArray(uniqueElements:
                choices
                .filter { choice in
                    if let selection = origin.categorySelection {
                        return choice.categories.contains(selection)
                    } else {
                        return true
                    }
                }.map { choice in
                    TransitionButtonCore.State(
                        context: context,
                        choice: choice
                    )
                }
            )
        }
}

[tgrapperon]

I wouldn't use a ForEachStore if there is no .forEach counterpart at the reducer's level, and you can't use a .forEach because your property is read-only. It seems to me that your button's array is logic-less and you may get away in pure SwiftUI with a simple ForEach without creating a new feature. In this case, you should be able to observe the button's array to trigger the animation.