Refreshable async action causes parent effect to cancel

[jansvancer]

Hello,
I have a situation where I have parent and child features, where child is displayed via NavigationLink and contains a List with pull to refresh (refreshable) action. This refreshable block sends an action which is catched in parent reducer and starts some async operation. But when child feature is dismissed before asynchronous operation is done, it causes this parent operation to cancel.
Here is an example situation:

struct ParentFeature {
}

// MARK: - State

extension ParentFeature {
  struct State: Equatable {
    var childState: ChildFeature.State?
    var text = ""
  }
}

// MARK: - Action

extension ParentFeature {
  enum Action: Equatable {
    case fetchData
    case dataResponse(String)
    case showChild(Bool)
    case childAction(ChildFeature.Action)
  }
}

// MARK: - Reducer

extension ParentFeature: ReducerProtocol {
  var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      switch action {
      case .fetchData:
        return Just("Some random number: \(Int.random(in: 0..<1000))")
          .delay(for: 3, scheduler: DispatchQueue.main)
          .print()
          .eraseToEffect(Action.dataResponse)

      case let .dataResponse(text):
        state.text = text
        if state.childState != nil {
          return .task { .childAction(.receivedText(text)) }
        } else {
          return .none
        }

      case let .showChild(show):
        state.childState = show ? .init() : nil
        return .none

      case .childAction(.fetchData):
        return .task { .fetchData }

      case .childAction:
        return .none
      }
    }
    .ifLet(\.childState, action: /Action.childAction) {
      ChildFeature()
    }
  }
}

And Child:

struct ChildFeature {
}

// MARK: - State

extension ChildFeature {
  struct State: Equatable {
    var isRefreshing = false
    var text = ""
  }
}

// MARK: - Action

extension ChildFeature {
  enum Action: Equatable {
    case fetchData
    case receivedText(String)
  }
}

// MARK: - Reducer

extension ChildFeature: ReducerProtocol {
  var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      switch action {
      case .fetchData:
        state.isRefreshing = true
        return .none

      case let .receivedText(text):
        state.isRefreshing = false
        state.text = text
        return .none
      }
    }
  }
}

Child view calls that pull to refresh action:

  var body: some View {
      WithViewStore(
        store,
        observe: ViewState.init
      ) { viewStore in
        List {
          Text(viewStore.text)
        }
        .refreshable {
          await viewStore.send(.fetchData, while: \.isRefreshing)
        }
      }
   }

So when child sends .fetchData parent starts some asynchronous operation, but when you navigate back from child, while the asynchronous operation is running, it causes that this operation is canceled.

I think I understand why this is happening.
public func send(_ action: ViewAction, while predicate: @escaping (ViewState) -> Bool) async {
handles the cancelation which is cause by viewStore publisher to be cancelled, if I understand this correctly. And I think this is right behavior for most of the cases.

But how can I break the relationship between that child action which can be cancelled and parent action which performs that async operation? Or should I model this situation completely different? This is just an example. We have quite more complex logic behind it in real situation. And we want that fetching of data to be done in parent feature and just share some result to child feature.

Thank You