IssueTracker

The whole idea above is to have Screen*Destination classes centralized somewhere and not referenced across the whole project, but the library does not allow to declare screens like that.

Correct, this is not a scalable solution as explained in the encapsulate your navigation code guide, which shows how to split up your graph into module level chunks, which then higher level modules can put together into a completed graph.

Can you explain why exactly you are trying to centralize all of your classes in one place?

Can you also expose non-reified navigate while you're at it? I'm trying to achieve the same use case but with navGraphs. I can't use the overload since it is only limited to the library. This helps identify the heirarchy in a type-safe navigable way using a parent interface for graphs and destinations. Each could be encapsulated then brought into 1 class in some place.

Can you explain why exactly you are trying to centralize all of your classes in one place?

The idea is to have one place where the Screen*Destination classes live so that when we need to modify/add/remove something related to them the devs know where to look.

This problem is exacerbated by the BottomNavigation composable when we need to decide whether the bottom bar should be visible or whether the BottomNavigationItem is currently selected. The solution to these two problems requires us to reference Screen*Destination classes, just like the official docs do, but I want to avoid this in the first place. By having the Screen class from above, I don't really care about any Screen*Destination classes and can operate by my own:

@Composable
internal fun BottomBar(
    navController: NavHostController,
    currentScreen: Screen,
) {
    val isBottomBarScreenDisplayed = remember(currentScreen) {
        BottomNavigationItemModel
            .entries
            .any { itemModel -> itemModel.screen == currentScreen }
    }

    LaunchedEffect(isBottomBarScreenDisplayed) {
        navController.enableOnBackPressed(!isBottomBarScreenDisplayed)
    }

    AnimatedVisibility(
        visible = isBottomBarScreenDisplayed,
        enter = slideInVertically(
            animationSpec = tween(BOTTOM_BAR_ANIMATION_DURATION),
            initialOffsetY = { it },
        ),
        exit = slideOutVertically(
            animationSpec = tween(BOTTOM_BAR_ANIMATION_DURATION),
            targetOffsetY = { it },
        ),
    ) {
        BottomBarNavigation(
            navController = navController,
            currentScreen = currentScreen,
        )
    }
}

@Composable
private fun BottomBarNavigation(
    navController: NavHostController,
    currentScreen: Screen,
) {
    BottomNavigation(windowInsets = WindowInsets.navigationBars) {
        for (bottomNavigationItemModel in BottomNavigationItemModel.entries) {
            val itemScreen = bottomNavigationItemModel.screen

            BottomNavigationItem(
                selected = currentScreen == itemScreen,
                onClick = { ... },
                icon = { ... },
                label = { ... },
            )
        }
    }
}

private enum class BottomNavigationItemModel(
    @DrawableRes
    val iconId: Int,
    @StringRes
    val titleId: Int,
    val screen: Screen,
) {
    SCREEN_A(
        iconId = ...,
        titleId = ...,
        screen = Screen.ScreenA,
    ),
    SCREEN_B(
        iconId = ...,
        titleId = ...,
        screen = Screen.ScreenB,
    ),
    SCREEN_C(
        iconId = ...,
        titleId = ...,
        screen = Screen.ScreenC,
    ),
}

The bottom nav bar is just one example where I need to reference the Screen*Destination classes. I've found another case related to the destination's animations where I need to know the exact screen I'm navigating to or from to know which animation to play. By having the Screen class from above, I can have this nice and simple implementation:

private fun NavGraphBuilder.screenA(navController: NavHostController) {
    composable(
        route = Screen.ScreenA.routeClass,
        enterTransition = {
            when (Screen.forRoute(initialState.destination.requireRoute())) {
                Screen.ScreenB -> OvershootScaling.enter()
                else -> null
            }
        },
        exitTransition = {
            when (Screen.forRoute(targetState.destination.requireRoute())) {
                Screen.ScreenC -> HorizontalSliding.exit()
                else -> null
            }
        },
        popEnterTransition = {
            when (Screen.forRoute(initialState.destination.requireRoute())) {
                Screen.ScreenC -> HorizontalSliding.popEnter()
                else -> null
            }
        },
        popExitTransition = {
            when (Screen.forRoute(targetState.destination.requireRoute())) {
                Screen.ScreenA -> OvershootScaling.popExit()
                else -> null
            }
        },
    ) {

Will just post my request here since it is related: https://issuetracker.google.com/u/0/issues/366291612