Merge pull request #2009 from jonataslaw/revert-fixOnGeneratorError

revert https://github.com/jonataslaw/getx/pull/1894

@@ -7,7 +7,7 @@ import 'routes/app_pages.dart';
 import 'shared/logger/logger_utils.dart';
 import 'shared/logger/logger_utils.dart';
 
 
 void main() {
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 }
 
 
 class MyApp extends StatelessWidget {
 class MyApp extends StatelessWidget {

 import 'package:flutter/foundation.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/widgets.dart';
 import 'package:flutter/widgets.dart';
+
 import '../../../get.dart';
 import '../../../get.dart';
 
 
 class GetInformationParser extends RouteInformationParser<GetNavConfig> {
 class GetInformationParser extends RouteInformationParser<GetNavConfig> {
@@ -14,7 +15,6 @@ class GetInformationParser extends RouteInformationParser<GetNavConfig> {
   SynchronousFuture<GetNavConfig> parseRouteInformation(
   SynchronousFuture<GetNavConfig> parseRouteInformation(
     RouteInformation routeInformation,
     RouteInformation routeInformation,
   ) {
   ) {
-    Get.log('GetInformationParser: route location: ${routeInformation.location}');
     var location = routeInformation.location;
     var location = routeInformation.location;
     if (location == '/') {
     if (location == '/') {
       //check if there is a corresponding page
       //check if there is a corresponding page
@@ -24,6 +24,8 @@ class GetInformationParser extends RouteInformationParser<GetNavConfig> {
       }
       }
     }
     }
 
 
+    Get.log('GetInformationParser: route location: $location');
+
     final matchResult = Get.routeTree.matchRoute(location ?? initialRoute);
     final matchResult = Get.routeTree.matchRoute(location ?? initialRoute);
 
 
     return SynchronousFuture(
     return SynchronousFuture(

@@ -2,50 +2,10 @@ import 'dart:async';
 
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/material.dart';
+
 import '../../../get.dart';
 import '../../../get.dart';
 import '../../../get_state_manager/src/simple/list_notifier.dart';
 import '../../../get_state_manager/src/simple/list_notifier.dart';
 
 
-/// Enables the user to customize the intended pop behavior
-///
-/// Goes to either the previous history entry or the previous page entry
-///
-/// e.g. if the user navigates to these pages
-/// 1) /home
-/// 2) /home/products/1234
-///
-/// when popping on [History] mode, it will emulate a browser back button.
-///
-/// so the new history stack will be:
-/// 1) /home
-///
-/// when popping on [Page] mode, it will only remove the last part of the route
-/// so the new history stack will be:
-/// 1) /home
-/// 2) /home/products
-///
-/// another pop will change the history stack to:
-/// 1) /home
-enum PopMode {
-  History,
-  Page,
-}
-
-/// Enables the user to customize the behavior when pushing multiple routes that
-/// shouldn't be duplicates
-enum PreventDuplicateHandlingMode {
-  /// Removes the history entries until it reaches the old route
-  PopUntilOriginalRoute,
-
-  /// Simply don't push the new route
-  DoNothing,
-
-  /// Recommended - Moves the old route entry to the front
-  ///
-  /// With this mode, you guarantee there will be only one
-  /// route entry for each location
-  ReorderRoutes
-}
-
 class GetDelegate extends RouterDelegate<GetNavConfig>
 class GetDelegate extends RouterDelegate<GetNavConfig>
     with ListenableMixin, ListNotifierMixin {
     with ListenableMixin, ListNotifierMixin {
   final List<GetNavConfig> history = <GetNavConfig>[];
   final List<GetNavConfig> history = <GetNavConfig>[];
@@ -57,7 +17,7 @@ class GetDelegate extends RouterDelegate<GetNavConfig>
   final List<NavigatorObserver>? navigatorObservers;
   final List<NavigatorObserver>? navigatorObservers;
   final TransitionDelegate<dynamic>? transitionDelegate;
   final TransitionDelegate<dynamic>? transitionDelegate;
 
 
-  GlobalKey<NavigatorState> get navigatorKey => Get.key;
+  final _allCompleters = <GetPage, Completer>{};
 
 
   GetDelegate({
   GetDelegate({
     GetPage? notFoundRoute,
     GetPage? notFoundRoute,
@@ -76,191 +36,72 @@ class GetDelegate extends RouterDelegate<GetNavConfig>
     Get.log('GetDelegate is created !');
     Get.log('GetDelegate is created !');
   }
   }
 
 
-  Future<GetNavConfig?> runMiddleware(GetNavConfig config) async {
-    final middlewares = config.currentTreeBranch.last.middlewares;
-    if (middlewares == null) {
-      return config;
-    }
-    var iterator = config;
-    for (var item in middlewares) {
-      var redirectRes = await item.redirectDelegate(iterator);
-      if (redirectRes == null) return null;
-      iterator = redirectRes;
-    }
-    return iterator;
-  }
-
-  Future<void> _unsafeHistoryAdd(GetNavConfig config) async {
-    final res = await runMiddleware(config);
-    if (res == null) return;
-    history.add(res);
+  @override
+  GetNavConfig? get currentConfiguration {
+    if (history.isEmpty) return null;
+    final route = history.last;
+    return route;
   }
   }
 
 
-  Future<void> _unsafeHistoryRemove(GetNavConfig config) async {
-    var index = history.indexOf(config);
-    if (index >= 0) await _unsafeHistoryRemoveAt(index);
-  }
+  GlobalKey<NavigatorState> get navigatorKey => Get.key;
 
 
-  Future<GetNavConfig?> _unsafeHistoryRemoveAt(int index) async {
-    if (index == history.length - 1 && history.length > 1) {
-      //removing WILL update the current route
-      final toCheck = history[history.length - 2];
-      final resMiddleware = await runMiddleware(toCheck);
-      if (resMiddleware == null) return null;
-      history[history.length - 2] = resMiddleware;
-    }
-    return history.removeAt(index);
+  Map<String, String> get parameters {
+    return currentConfiguration?.currentPage?.parameters ?? {};
   }
   }
 
 
   T arguments<T>() {
   T arguments<T>() {
     return currentConfiguration?.currentPage?.arguments as T;
     return currentConfiguration?.currentPage?.arguments as T;
   }
   }
 
 
-  Map<String, String> get parameters {
-    return currentConfiguration?.currentPage?.parameters ?? {};
-  }
-
-  // void _unsafeHistoryClear() {
-  //   history.clear();
-  // }
-
-  /// Adds a new history entry and waits for the result
-  Future<void> pushHistory(
-    GetNavConfig config, {
-    bool rebuildStack = true,
+  /// Removes routes according to [PopMode]
+  /// until it reaches the specifc [fullRoute],
+  /// DOES NOT remove the [fullRoute]
+  Future<void> backUntil(
+    String fullRoute, {
+    PopMode popMode = PopMode.Page,
   }) async {
   }) async {
-    //this changes the currentConfiguration
-    await _pushHistory(config);
-    if (rebuildStack) {
-      refresh();
-    }
-  }
-
-  Future<void> _removeHistoryEntry(GetNavConfig entry) async {
-    await _unsafeHistoryRemove(entry);
-  }
-
-  Future<void> _pushHistory(GetNavConfig config) async {
-    if (config.currentPage!.preventDuplicates) {
-      final originalEntryIndex =
-          history.indexWhere((element) => element.location == config.location);
-      if (originalEntryIndex >= 0) {
-        switch (preventDuplicateHandlingMode) {
-          case PreventDuplicateHandlingMode.PopUntilOriginalRoute:
-            await backUntil(config.location!, popMode: PopMode.Page);
-            break;
-          case PreventDuplicateHandlingMode.ReorderRoutes:
-            await _unsafeHistoryRemoveAt(originalEntryIndex);
-            await _unsafeHistoryAdd(config);
-            break;
-          case PreventDuplicateHandlingMode.DoNothing:
-          default:
-            break;
-        }
-        return;
-      }
-    }
-    await _unsafeHistoryAdd(config);
-  }
-
-  // GetPageRoute getPageRoute(RouteSettings? settings) {
-  //   return PageRedirect(settings ?? RouteSettings(name: '/404'), _notFound())
-  //       .page();
-  // }
-
-  Future<GetNavConfig?> _popHistory() async {
-    if (!_canPopHistory()) return null;
-    return await _doPopHistory();
-  }
-
-  Future<GetNavConfig?> _doPopHistory() async {
-    return await _unsafeHistoryRemoveAt(history.length - 1);
-  }
-
-  Future<GetNavConfig?> _popPage() async {
-    if (!_canPopPage()) return null;
-    return await _doPopPage();
-  }
-
-  Future<GetNavConfig?> _pop(PopMode mode) async {
-    switch (mode) {
-      case PopMode.History:
-        return await _popHistory();
-      case PopMode.Page:
-        return await _popPage();
-      default:
-        return null;
-    }
-  }
-
-  // returns the popped page
-  Future<GetNavConfig?> _doPopPage() async {
-    final currentBranch = currentConfiguration?.currentTreeBranch;
-    if (currentBranch != null && currentBranch.length > 1) {
-      //remove last part only
-      final remaining = currentBranch.take(currentBranch.length - 1);
-      final prevHistoryEntry =
-          history.length > 1 ? history[history.length - 2] : null;
-
-      //check if current route is the same as the previous route
-      if (prevHistoryEntry != null) {
-        //if so, pop the entire history entry
-        final newLocation = remaining.last.name;
-        final prevLocation = prevHistoryEntry.location;
-        if (newLocation == prevLocation) {
-          //pop the entire history entry
-          return await _popHistory();
+    // remove history or page entries until you meet route
+    var iterator = currentConfiguration;
+    while (_canPop(popMode) &&
+        iterator != null &&
+        iterator.location != fullRoute) {
+      await _pop(popMode);
+      // replace iterator
+      iterator = currentConfiguration;
     }
     }
+    refresh();
   }
   }
 
 
-      //create a new route with the remaining tree branch
-      final res = await _popHistory();
-      await _pushHistory(
-        GetNavConfig(
-          currentTreeBranch: remaining.toList(),
-          location: remaining.last.name,
-          state: null, //TOOD: persist state??
-        ),
+  @override
+  Widget build(BuildContext context) {
+    final pages = getVisualPages();
+    if (pages.length == 0) return SizedBox.shrink();
+    final extraObservers = navigatorObservers;
+    return GetNavigator(
+      key: navigatorKey,
+      onPopPage: _onPopVisualRoute,
+      pages: pages,
+      observers: [
+        GetObserver(),
+        if (extraObservers != null) ...extraObservers,
+      ],
+      transitionDelegate:
+          transitionDelegate ?? const DefaultTransitionDelegate<dynamic>(),
     );
     );
-      return res;
-    } else {
-      //remove entire entry
-      return await _popHistory();
-    }
   }
   }
 
 
-  Future<GetNavConfig?> popHistory() async {
-    return await _popHistory();
-  }
-
-  bool _canPopHistory() {
-    return history.length > 1;
-  }
+  // void _unsafeHistoryClear() {
+  //   history.clear();
+  // }
 
 
   Future<bool> canPopHistory() {
   Future<bool> canPopHistory() {
     return SynchronousFuture(_canPopHistory());
     return SynchronousFuture(_canPopHistory());
   }
   }
 
 
-  bool _canPopPage() {
-    final currentTreeBranch = currentConfiguration?.currentTreeBranch;
-    if (currentTreeBranch == null) return false;
-    return currentTreeBranch.length > 1 ? true : _canPopHistory();
-  }
-
   Future<bool> canPopPage() {
   Future<bool> canPopPage() {
     return SynchronousFuture(_canPopPage());
     return SynchronousFuture(_canPopPage());
   }
   }
 
 
-  bool _canPop(PopMode mode) {
-    switch (mode) {
-      case PopMode.History:
-        return _canPopHistory();
-      case PopMode.Page:
-      default:
-        return _canPopPage();
-    }
-  }
-
   /// gets the visual pages from the current history entry
   /// gets the visual pages from the current history entry
   ///
   ///
   /// visual pages must have [participatesInRootNavigator] set to true
   /// visual pages must have [participatesInRootNavigator] set to true
@@ -281,44 +122,104 @@ class GetDelegate extends RouterDelegate<GetNavConfig>
     }
     }
   }
   }
 
 
+  // GetPageRoute getPageRoute(RouteSettings? settings) {
+  //   return PageRedirect(settings ?? RouteSettings(name: '/404'), _notFound())
+  //       .page();
+  // }
+
+  Future<bool> handlePopupRoutes({
+    Object? result,
+  }) async {
+    Route? currentRoute;
+    navigatorKey.currentState!.popUntil((route) {
+      currentRoute = route;
+      return true;
+    });
+    if (currentRoute is PopupRoute) {
+      return await navigatorKey.currentState!.maybePop(result);
+    }
+    return false;
+  }
+
+  Future<T?>? offAndToNamed<T>(
+    String page, {
+    dynamic arguments,
+    int? id,
+    dynamic result,
+    Map<String, String>? parameters,
+    PopMode popMode = PopMode.History,
+  }) async {
+    if (parameters != null) {
+      final uri = Uri(path: page, queryParameters: parameters);
+      page = uri.toString();
+    }
+
+    await popRoute(result: result);
+    return toNamed(page, arguments: arguments, parameters: parameters);
+  }
+
+  Future<T> offNamed<T>(
+    String page, {
+    dynamic arguments,
+    Map<String, String>? parameters,
+  }) async {
+    history.removeLast();
+    return toNamed<T>(page, arguments: arguments, parameters: parameters);
+  }
+
+  Future<GetNavConfig?> popHistory() async {
+    return await _popHistory();
+  }
+
+  // returns the popped page
   @override
   @override
-  Widget build(BuildContext context) {
-    final pages = getVisualPages();
-    if (pages.length == 0) return SizedBox.shrink();
-    final extraObservers = navigatorObservers;
-    return GetNavigator(
-      key: navigatorKey,
-      onPopPage: _onPopVisualRoute,
-      pages: pages,
-      observers: [
-        GetObserver(),
-        if (extraObservers != null) ...extraObservers,
-      ],
-      transitionDelegate:
-          transitionDelegate ?? const DefaultTransitionDelegate<dynamic>(),
-    );
+  Future<bool> popRoute({
+    Object? result,
+    PopMode popMode = PopMode.Page,
+  }) async {
+    //Returning false will cause the entire app to be popped.
+    final wasPopup = await handlePopupRoutes(result: result);
+    if (wasPopup) return true;
+    final _popped = await _pop(popMode);
+    refresh();
+    if (_popped != null) {
+      //emulate the old pop with result
+      return true;
+    }
+    return false;
+  }
+
+  /// Adds a new history entry and waits for the result
+  Future<void> pushHistory(
+    GetNavConfig config, {
+    bool rebuildStack = true,
+  }) async {
+    //this changes the currentConfiguration
+    await _pushHistory(config);
+    if (rebuildStack) {
+      refresh();
+    }
+  }
+
+  Future<GetNavConfig?> runMiddleware(GetNavConfig config) async {
+    final middlewares = config.currentTreeBranch.last.middlewares;
+    if (middlewares == null) {
+      return config;
+    }
+    var iterator = config;
+    for (var item in middlewares) {
+      var redirectRes = await item.redirectDelegate(iterator);
+      if (redirectRes == null) return null;
+      iterator = redirectRes;
+    }
+    return iterator;
   }
   }
-
-  // @override
-  // Future<void> setInitialRoutePath(GetNavConfig configuration) async {
-  //   //no need to clear history with Reorder route strategy
-  //   // _unsafeHistoryClear();
-  //   // _resultCompleter.clear();
-  //   await pushHistory(configuration);
-  // }
 
 
   @override
   @override
   Future<void> setNewRoutePath(GetNavConfig configuration) async {
   Future<void> setNewRoutePath(GetNavConfig configuration) async {
     await pushHistory(configuration);
     await pushHistory(configuration);
   }
   }
 
 
-  @override
-  GetNavConfig? get currentConfiguration {
-    if (history.isEmpty) return null;
-    final route = history.last;
-    return route;
-  }
-
   Future<T> toNamed<T>(
   Future<T> toNamed<T>(
     String page, {
     String page, {
     dynamic arguments,
     dynamic arguments,
@@ -352,84 +253,73 @@ class GetDelegate extends RouterDelegate<GetNavConfig>
     }
     }
   }
   }
 
 
-  Future<T?>? offAndToNamed<T>(
-    String page, {
-    dynamic arguments,
-    int? id,
-    dynamic result,
-    Map<String, String>? parameters,
-    PopMode popMode = PopMode.History,
-  }) async {
-    if (parameters != null) {
-      final uri = Uri(path: page, queryParameters: parameters);
-      page = uri.toString();
+  bool _canPop(PopMode mode) {
+    switch (mode) {
+      case PopMode.History:
+        return _canPopHistory();
+      case PopMode.Page:
+      default:
+        return _canPopPage();
     }
     }
-
-    await popRoute(result: result);
-    return toNamed(page, arguments: arguments, parameters: parameters);
   }
   }
 
 
-  Future<T> offNamed<T>(
-    String page, {
-    dynamic arguments,
-    Map<String, String>? parameters,
-  }) async {
-    history.removeLast();
-    return toNamed<T>(page, arguments: arguments, parameters: parameters);
+  bool _canPopHistory() {
+    return history.length > 1;
   }
   }
 
 
-  /// Removes routes according to [PopMode]
-  /// until it reaches the specifc [fullRoute],
-  /// DOES NOT remove the [fullRoute]
-  Future<void> backUntil(
-    String fullRoute, {
-    PopMode popMode = PopMode.Page,
-  }) async {
-    // remove history or page entries until you meet route
-    var iterator = currentConfiguration;
-    while (_canPop(popMode) &&
-        iterator != null &&
-        iterator.location != fullRoute) {
-      await _pop(popMode);
-      // replace iterator
-      iterator = currentConfiguration;
+  bool _canPopPage() {
+    final currentTreeBranch = currentConfiguration?.currentTreeBranch;
+    if (currentTreeBranch == null) return false;
+    return currentTreeBranch.length > 1 ? true : _canPopHistory();
   }
   }
-    refresh();
+
+  Future<GetNavConfig?> _doPopHistory() async {
+    return await _unsafeHistoryRemoveAt(history.length - 1);
   }
   }
 
 
-  Future<bool> handlePopupRoutes({
-    Object? result,
-  }) async {
-    Route? currentRoute;
-    navigatorKey.currentState!.popUntil((route) {
-      currentRoute = route;
-      return true;
-    });
-    if (currentRoute is PopupRoute) {
-      return await navigatorKey.currentState!.maybePop(result);
+  // @override
+  // Future<void> setInitialRoutePath(GetNavConfig configuration) async {
+  //   //no need to clear history with Reorder route strategy
+  //   // _unsafeHistoryClear();
+  //   // _resultCompleter.clear();
+  //   await pushHistory(configuration);
+  // }
+
+  Future<GetNavConfig?> _doPopPage() async {
+    final currentBranch = currentConfiguration?.currentTreeBranch;
+    if (currentBranch != null && currentBranch.length > 1) {
+      //remove last part only
+      final remaining = currentBranch.take(currentBranch.length - 1);
+      final prevHistoryEntry =
+          history.length > 1 ? history[history.length - 2] : null;
+
+      //check if current route is the same as the previous route
+      if (prevHistoryEntry != null) {
+        //if so, pop the entire history entry
+        final newLocation = remaining.last.name;
+        final prevLocation = prevHistoryEntry.location;
+        if (newLocation == prevLocation) {
+          //pop the entire history entry
+          return await _popHistory();
         }
         }
-    return false;
       }
       }
 
 
-  @override
-  Future<bool> popRoute({
-    Object? result,
-    PopMode popMode = PopMode.Page,
-  }) async {
-    //Returning false will cause the entire app to be popped.
-    final wasPopup = await handlePopupRoutes(result: result);
-    if (wasPopup) return true;
-    final _popped = await _pop(popMode);
-    refresh();
-    if (_popped != null) {
-      //emulate the old pop with result
-      return true;
+      //create a new route with the remaining tree branch
+      final res = await _popHistory();
+      await _pushHistory(
+        GetNavConfig(
+          currentTreeBranch: remaining.toList(),
+          location: remaining.last.name,
+          state: null, //TOOD: persist state??
+        ),
+      );
+      return res;
+    } else {
+      //remove entire entry
+      return await _popHistory();
     }
     }
-    return false;
   }
   }
 
 
-  final _allCompleters = <GetPage, Completer>{};
-
   bool _onPopVisualRoute(Route<dynamic> route, dynamic result) {
   bool _onPopVisualRoute(Route<dynamic> route, dynamic result) {
     final didPop = route.didPop(result);
     final didPop = route.didPop(result);
     if (!didPop) {
     if (!didPop) {
@@ -452,21 +342,89 @@ class GetDelegate extends RouterDelegate<GetNavConfig>
 
 
     return true;
     return true;
   }
   }
+
+  Future<GetNavConfig?> _pop(PopMode mode) async {
+    switch (mode) {
+      case PopMode.History:
+        return await _popHistory();
+      case PopMode.Page:
+        return await _popPage();
+      default:
+        return null;
+    }
+  }
+
+  Future<GetNavConfig?> _popHistory() async {
+    if (!_canPopHistory()) return null;
+    return await _doPopHistory();
+  }
+
+  Future<GetNavConfig?> _popPage() async {
+    if (!_canPopPage()) return null;
+    return await _doPopPage();
+  }
+
+  Future<void> _pushHistory(GetNavConfig config) async {
+    if (config.currentPage!.preventDuplicates) {
+      final originalEntryIndex =
+          history.indexWhere((element) => element.location == config.location);
+      if (originalEntryIndex >= 0) {
+        switch (preventDuplicateHandlingMode) {
+          case PreventDuplicateHandlingMode.PopUntilOriginalRoute:
+            await backUntil(config.location!, popMode: PopMode.Page);
+            break;
+          case PreventDuplicateHandlingMode.ReorderRoutes:
+            await _unsafeHistoryRemoveAt(originalEntryIndex);
+            await _unsafeHistoryAdd(config);
+            break;
+          case PreventDuplicateHandlingMode.DoNothing:
+          default:
+            break;
+        }
+        return;
+      }
+    }
+    await _unsafeHistoryAdd(config);
+  }
+
+  Future<void> _removeHistoryEntry(GetNavConfig entry) async {
+    await _unsafeHistoryRemove(entry);
+  }
+
+  Future<void> _unsafeHistoryAdd(GetNavConfig config) async {
+    final res = await runMiddleware(config);
+    if (res == null) return;
+    history.add(res);
+  }
+
+  Future<void> _unsafeHistoryRemove(GetNavConfig config) async {
+    var index = history.indexOf(config);
+    if (index >= 0) await _unsafeHistoryRemoveAt(index);
+  }
+
+  Future<GetNavConfig?> _unsafeHistoryRemoveAt(int index) async {
+    if (index == history.length - 1 && history.length > 1) {
+      //removing WILL update the current route
+      final toCheck = history[history.length - 2];
+      final resMiddleware = await runMiddleware(toCheck);
+      if (resMiddleware == null) return null;
+      history[history.length - 2] = resMiddleware;
+    }
+    return history.removeAt(index);
+  }
 }
 }
 
 
 class GetNavigator extends Navigator {
 class GetNavigator extends Navigator {
-  GetNavigator(
-      {GlobalKey<NavigatorState>? key,
+  GetNavigator({
+    GlobalKey<NavigatorState>? key,
     bool Function(Route<dynamic>, dynamic)? onPopPage,
     bool Function(Route<dynamic>, dynamic)? onPopPage,
-      required List<GetPage> pages,
+    required List<Page> pages,
     List<NavigatorObserver>? observers,
     List<NavigatorObserver>? observers,
     bool reportsRouteUpdateToEngine = false,
     bool reportsRouteUpdateToEngine = false,
     TransitionDelegate? transitionDelegate,
     TransitionDelegate? transitionDelegate,
-      String? initialRoute})
-      : super(
+  }) : super(
           //keys should be optional
           //keys should be optional
           key: key,
           key: key,
-          initialRoute: initialRoute ?? '/',
           onPopPage: onPopPage ??
           onPopPage: onPopPage ??
               (route, result) {
               (route, result) {
                 final didPop = route.didPop(result);
                 final didPop = route.didPop(result);
@@ -475,17 +433,6 @@ class GetNavigator extends Navigator {
                 }
                 }
                 return true;
                 return true;
               },
               },
-          onGenerateRoute: (RouteSettings settings) {
-            final selectedPageList =
-                pages.where((element) => element.name == settings.name);
-            if (selectedPageList.isNotEmpty) {
-              final selectedPage = selectedPageList.first;
-              return GetPageRoute(
-                page: selectedPage.page,
-                settings: settings,
-              );
-            }
-          },
           reportsRouteUpdateToEngine: reportsRouteUpdateToEngine,
           reportsRouteUpdateToEngine: reportsRouteUpdateToEngine,
           pages: pages,
           pages: pages,
           observers: [
           observers: [
@@ -496,3 +443,44 @@ class GetNavigator extends Navigator {
               transitionDelegate ?? const DefaultTransitionDelegate<dynamic>(),
               transitionDelegate ?? const DefaultTransitionDelegate<dynamic>(),
         );
         );
 }
 }
+
+/// Enables the user to customize the intended pop behavior
+///
+/// Goes to either the previous history entry or the previous page entry
+///
+/// e.g. if the user navigates to these pages
+/// 1) /home
+/// 2) /home/products/1234
+///
+/// when popping on [History] mode, it will emulate a browser back button.
+///
+/// so the new history stack will be:
+/// 1) /home
+///
+/// when popping on [Page] mode, it will only remove the last part of the route
+/// so the new history stack will be:
+/// 1) /home
+/// 2) /home/products
+///
+/// another pop will change the history stack to:
+/// 1) /home
+enum PopMode {
+  History,
+  Page,
+}
+
+/// Enables the user to customize the behavior when pushing multiple routes that
+/// shouldn't be duplicates
+enum PreventDuplicateHandlingMode {
+  /// Removes the history entries until it reaches the old route
+  PopUntilOriginalRoute,
+
+  /// Simply don't push the new route
+  DoNothing,
+
+  /// Recommended - Moves the old route entry to the front
+  ///
+  /// With this mode, you guarantee there will be only one
+  /// route entry for each location
+  ReorderRoutes
+}