registerAppRouter<T extends BaseAppRouter> method

void registerAppRouter<T extends BaseAppRouter>(T? router, { bool enableNavigationLogs = true, })

Registers the app router and navigator for navigation management.

Parameters:

• router: The router instance that extends BaseAppRouter
• enableNavigationLogs: Controls whether navigation logs are printed

This method:

1. Registers router itself under both T and BaseAppRouter
2. Creates and registers an AppNavigator wrapping it, under both its own type and INavigator

Example:

void configureInjectionApp() {
  getIt.registerAppRouter<AppRouter>(AppRouter());

  // With navigation logs disabled
  getIt.registerAppRouter<AppRouter>(AppRouter(), enableNavigationLogs: false);
}

Each registration is guarded independently, so calling this after some other setup has already registered one of the three types is safe.

Implementation

void registerAppRouter<T extends BaseAppRouter>(
  T? router, {
  bool enableNavigationLogs = true,
}) {
  if (router == null) {
    throw ArgumentError.notNull('router');
  }

  try {
    // Register the instance we were handed. Previously the argument was
    // discarded and the body registered `() => get<T>()`, resolving a T that
    // nothing had registered — so even the happy path threw.
    if (!isRegistered<T>()) {
      registerSingleton<T>(router);
    }
    if (!isRegistered<BaseAppRouter>()) {
      registerLazySingleton<BaseAppRouter>(() => get<T>());
    }
    if (!isRegistered<AppNavigator>()) {
      registerLazySingleton<AppNavigator>(
        () => AppNavigator(
          get<BaseAppRouter>(),
          enableNavigationLogs: enableNavigationLogs,
        ),
      );
    }
    // Also expose it behind the interface so consumers can resolve — and
    // fake — navigation without depending on the concrete type.
    if (!isRegistered<INavigator>()) {
      registerLazySingleton<INavigator>(() => get<AppNavigator>());
    }
  } catch (e) {
    throw DependencyRegistrationException('Failed to register router', e);
  }
}