Here I'm only calling predicate once.
The reason is that after poping, the walker might need to be re-computed in case the popped route was a route from go router.

Then why use popUntil and not pop if I pop only once? It is to be able to provide the Route<dynamic> route parameter to the predicate. I cannot access the latest route of the NavigatorState since NavigatorState._history and NavigatorState._lastRouteEntryWhereOrNull are private.

Do you have a better idea or suggestions?

@chunhtai Do you have any feedback on this?

is there a use case for Route<dynamic> route? it seems a bit out of place that we all deal with RouteBase and GoRouterState in this package.

The case I'm thinking about and I've been facing in some applications is when there are dialogs / bottom sheets / popup menus (or any other imperative routes) open

I also worked on some projects where the code base uses both go_router and Navigator.of(context).push. Either because they didn't get the time to migrate all the pages yet or because they don't want those pages to be linked to a specific URL on the web

I see, my suggestion would be changing routematch to gorouterstate.

RouteMatchBase is currently used internal only, we usually use GoRouterState for public facing API

Sure ! I changed it in refactor: Use GoRouterState instead of RouteMatchBase

is there a use case for Route<dynamic> route? it seems a bit out of place that we all deal with RouteBase and GoRouterState in this package.

I am not entirely sure why this method is needed. it seems to me that you can use predicate directly instead of wrapping in a method that doesn't do much

why not just let _popWithPredicate to return true if the predicate after pop return false? an then you can basically do

while(_popWithPredicate(popUntilPredicate));

something like this

  void popUntil(PopUntilPredicate predicate) {
    while (_popWithPredicate(predicate)) {}
  }

  bool _popWithPredicate(
    PopUntilPredicate predicate,
  ) {
    NavigatorState? state;

    if (navigatorKey.currentState?.canPop() ?? false) {
      state = navigatorKey.currentState;
    }
    List<RouteMatchBase> matches = currentConfiguration.matches;
    while (matches.last is ShellRouteMatch) {
      final ShellRouteMatch leaf = matches.last as ShellRouteMatch;
      if (leaf.navigatorKey.currentState?.canPop() ?? false) {
        state = leaf.navigatorKey.currentState;
      }
      matches = leaf.matches;
    }
    bool predicateMatched = false;
    state?.popUntil((Route<dynamic> route) {
      final RouteMatchBase leaf = matches.last;
      if (!state!.canPop() || leaf is ShellRouteMatch) {
        // If the leaf is ShellRouteMatch, it needs to pop leaf's navigator
        // first.
        return true;
      }
      predicateMatched = predicate(leaf.buildState(_configuration, currentConfiguration), route,);
      return predicateMatched;
    });
    return state != null && !predicateMatched;
  }

What do you think of refactor: Simplify the code by removing a method ?

If that's fine I can go with it and work on adding more tests

yes that looks fine

We should probably have more tests on cases where nested shellroute.