@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabBarLook.kt

@@ -0,0 +1,74 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.options.BottomTabsOptions
+import dev.apexnative.navigation.options.params.ThemeColour
+import dev.apexnative.navigation.utils.UiUtils
+import dev.apexnative.navigation.views.bottomtabs.BottomTabsContainer
+
+/**
+ * What the container of the tab bar draws from `bottomTabs`: the background (`null` and `'NoColor'` the theme's), a top
+ * line shown only when `borderColor` or `borderWidth` is set (dark gray, the thin line, the width in dp), the shadow
+ * only with `shadow` (black by default, its alpha the opacity), the elevation and the corners in dp. The values alone,
+ * without views.
+ */
+internal object TabBarLook {
+    /** The line without `borderWidth`: one pixel. */
+    const val THIN_LINE_PX = 1f
+
+    private const val DARK_GRAY = 0xFF444444.toInt()
+    private const val BLACK = 0xFF000000.toInt()
+    private const val OPAQUE = 255
+    private const val RGB = 0x00FFFFFF
+    private const val ALPHA_SHIFT = 24
+
+    /**
+     * The look of [options], their colors read by [color] (none for unset and `'NoColor'`), the theme's background
+     * [defaultBackground], sizes at [densityDpi].
+     */
+    fun of(
+        options: BottomTabsOptions,
+        color: (ThemeColour) -> Int?,
+        defaultBackground: Int,
+        densityDpi: Int,
+    ): BottomTabsContainer.Look {
+        fun px(dp: Double): Float = UiUtils.dpToPixels(dp, densityDpi).toFloat()
+        val border = options.borderColor.hasValue() || options.borderWidth.hasValue()
+        val shadow = options.shadow
+        return BottomTabsContainer.Look(
+            background = color(options.backgroundColor) ?: defaultBackground,
+            borderColor = if (border) color(options.borderColor) ?: DARK_GRAY else null,
+            borderWidth = options.borderWidth.get(null)?.let(::px) ?: THIN_LINE_PX,
+            shadow = if (shadow.hasValue()) {
+                BottomTabsContainer.Shadow(
+                    color = withOpacity(color(shadow.color) ?: BLACK, shadow.opacity.get(null)),
+                    radius = shadow.radius.get(0.0).toFloat(),
+                )
+            } else {
+                null
+            },
+            elevation = px(options.elevation.get(0.0)),
+            cornerRadius = px(options.cornerRadius.get(0.0)),
+        )
+    }
+
+    /** [color] with the alpha of [opacity] (0 … 1); as it is without one. */
+    fun withOpacity(color: Int, opacity: Double?): Int {
+        opacity ?: return color
+        val alpha = (opacity.coerceIn(0.0, 1.0) * OPAQUE).toInt()
+        return (color and RGB) or (alpha shl ALPHA_SHIFT)
+    }
+
+    /**
+     * Whether every tab draws its cell (`bottomTab.component` of [components] of [count] tabs); with some but not all,
+     * [mixedWarning] says so and every tab is drawn natively.
+     */
+    fun usesRow(components: Int, count: Int): Boolean = count > 0 && components == count
+
+    /** The warning when only some tabs have a component; none otherwise. */
+    fun mixedWarning(components: Int, count: Int): String? = if (components in 1 until count) {
+        "Mixed bottomTab.component usage detected ($components of $count tabs). " +
+            "All tabs must declare a component or none — falling back to native rendering for all tabs."
+    } else {
+        null
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabBarMotion.kt

@@ -0,0 +1,83 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.views.animations.SystemTransition
+
+/**
+ * How the tab bar moves when a stack in the selected tab changes its top and the new top shows or hides the bar: with
+ * the screens of the stack's system transition, by a slide of its own, or at once. The values alone, without views; the
+ * tabs play them on the bar's container.
+ */
+internal object TabBarMotion {
+    /** How the stack's transition goes, as its queue tells it (`StackQueue.Host.tabBarTransition`). */
+    enum class Move {
+        /** The system's push: the bar rides with the screen it belongs to. */
+        WithPush,
+
+        /** The system's pop: the same, the other way. */
+        WithPop,
+
+        /**
+         * A transition of its own (a `content` animation, `animations.*.bottomTabs`) or a `setStackRoot` that fades:
+         * the bar shows or hides by the transition's `bottomTabs` side, else slides by its height, 300 ms.
+         */
+        Slide,
+
+        /** No animation: the bar is where the new top wants it at once. */
+        AtOnce,
+    }
+
+    /** The bar rides with a screen: along the x axis in dp, its alpha changing after a hold. */
+    data class Ride(
+        val fromX: Float,
+        val toX: Float,
+        val fromAlpha: Float,
+        val toAlpha: Float,
+        /** How long the alpha holds before it changes, ms. */
+        val alphaDelay: Long,
+        /** How long the alpha takes to change after its hold, ms. */
+        val alphaDuration: Long,
+        /** How long the ride takes, ms, on [SystemTransition.CURVE]. */
+        val duration: Long,
+    )
+
+    /** A slide by the bar's height: [fromY] and [toY] as parts of the height (0 at rest, 1 under the bottom). */
+    data class Slide(val fromY: Float, val toY: Float, val duration: Long)
+
+    /** How long the slide of a merge of `visible` or of a transition of its own takes. */
+    const val SLIDE_MILLIS = 300L
+
+    /**
+     * The ride for [move] (only [Move.WithPush] and [Move.WithPop]) when the bar ends [showing] or hidden, mirrored
+     * right to left ([rtl]): a push takes it away with the covered screen (0 → −96 dp, alpha 1 held 50 ms then to 0
+     * at 133 ms) or brings it in with the new one (+96 dp → 0, alpha 0 held 50 ms then to 1); a pop brings it back with
+     * the revealed screen (−96 dp → 0, alpha 0 held 35 ms then to 1 at 118 ms) or takes it away with the leaving one.
+     */
+    fun ride(move: Move, showing: Boolean, rtl: Boolean): Ride? {
+        val distance = SystemTransition.DISTANCE_DP * if (rtl) -1 else 1
+        val delay = when (move) {
+            Move.WithPush -> SystemTransition.PUSH_FADE_DELAY
+            Move.WithPop -> SystemTransition.POP_FADE_DELAY
+            else -> return null
+        }
+        // Where the bar is when hidden: with the covered screen on a push, with the leaving one on a pop.
+        val away = when {
+            move == Move.WithPush && !showing -> -distance
+            move == Move.WithPush -> distance
+            showing -> -distance
+            else -> distance
+        }
+        return Ride(
+            fromX = if (showing) away else 0f,
+            toX = if (showing) 0f else away,
+            fromAlpha = if (showing) 0f else 1f,
+            toAlpha = if (showing) 1f else 0f,
+            alphaDelay = delay,
+            alphaDuration = SystemTransition.FADE_DURATION,
+            duration = SystemTransition.DURATION,
+        )
+    }
+
+    /** The slide of the bar to [showing] or hidden. */
+    fun slide(showing: Boolean): Slide =
+        if (showing) Slide(1f, 0f, SLIDE_MILLIS) else Slide(0f, 1f, SLIDE_MILLIS)
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabCellState.kt

@@ -0,0 +1,27 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+/**
+ * What the native side tells the React component of a tab's cell (`bottomTab.component`): its tab's index, whether it
+ * is selected, the badge's text (none without one) and the dot, shown only without a badge (it takes the dot's place),
+ * with its color when the options give one (`dotColor`). The props JavaScript keeps for the cell stay there by its
+ * `componentId`.
+ */
+internal data class TabCellState(
+    val tabIndex: Int,
+    val selected: Boolean,
+    val badge: String?,
+    val dot: Boolean,
+    val dotColor: Int?,
+) {
+    companion object {
+        /** The state of the cell of the tab at [index], from the badge text and the dot its item shows. */
+        fun of(index: Int, selected: Boolean, badge: String, dotVisible: Boolean, dotColor: Int?): TabCellState =
+            TabCellState(
+                tabIndex = index,
+                selected = selected,
+                badge = badge.ifEmpty { null },
+                dot = dotVisible && badge.isEmpty(),
+                dotColor = dotColor,
+            )
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabHistory.kt

@@ -0,0 +1,38 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+/**
+ * The tabs chosen before, for `hardwareBackButton.bottomTabsOnPress: 'previous'` (
+ * `hardwareBackButton.bottomTabsOnPress`): each selection by the user or from code puts the tab it left here while the
+ * option is `previous`, never the same index twice in a row; a selection made by back adds nothing, and back takes the
+ * last entry, so back doesn't go to and fro between two tabs. Main thread only.
+ */
+internal class TabHistory {
+    private val entries = ArrayList<Int>()
+
+    /** Nothing to go back to. */
+    val isEmpty: Boolean
+        get() = entries.isEmpty()
+
+    /** The entries, oldest first. */
+    val all: List<Int>
+        get() = entries
+
+    /** The selection left the tab at [index]. */
+    fun left(index: Int) {
+        if (entries.lastOrNull() != index) entries += index
+    }
+
+    /** Whether back would find a tab other than [current]. */
+    fun hasOtherThan(current: Int): Boolean = entries.any { it != current }
+
+    /** The tab back goes to from [current]: the last entry that isn't it, taken out with those after it; none. */
+    fun takeFor(current: Int): Int? {
+        while (entries.isNotEmpty()) {
+            val last = entries.removeAt(entries.size - 1)
+            if (last != current) return last
+        }
+        return null
+    }
+
+    fun clear() = entries.clear()
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabItems.kt

@@ -0,0 +1,172 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.options.BottomTabOptions
+import dev.apexnative.navigation.options.DotIndicatorOptions
+import dev.apexnative.navigation.options.FontOptions
+import dev.apexnative.navigation.options.params.Text
+import dev.apexnative.navigation.options.params.ThemeColour
+import dev.apexnative.navigation.views.bottomtabs.BottomTabs
+
+/**
+ * What the items of the tab bar show, from the resolved `bottomTab` of each tab (`bottomTab`): the calls to the
+ * module's bar ([Call]), without views. At creation every field; at a merge only the fields it names, with their
+ * resolved values (a `badgeColor`, `fontSize` or `selectedFontSize` alone works); at the repaint the colors again. The
+ * badge text and the dot an item shows change only at creation or by a merge that carries them: a repaint, or a merge
+ * of another field, keeps them. [color] reads a color of the current mode (`'NoColor'` and unset: none, the style's
+ * color). Main thread only.
+ */
+internal class TabItems(private val color: (ThemeColour) -> Int?) {
+    /** One call to the module's bar for the item at [index]. */
+    sealed class Call {
+        abstract val index: Int
+
+        data class Title(override val index: Int, val text: String) : Call()
+
+        data class Icon(override val index: Int, val uri: String) : Call()
+
+        data class SelectedIcon(override val index: Int, val uri: String) : Call()
+
+        /** The colors over the bar's style: none is the style's. */
+        data class Colors(
+            override val index: Int,
+            val iconActive: Int?,
+            val iconInactive: Int?,
+            val titleActive: Int?,
+            val titleInactive: Int?,
+        ) : Call()
+
+        /** The icon's size in dp, width over height. */
+        data class IconSize(override val index: Int, val width: Int?, val height: Int?) : Call()
+
+        data class Font(override val index: Int, val font: FontOptions) : Call()
+
+        /** The titles' sizes in sp: selected ([active]) and the others. */
+        data class FontSizes(override val index: Int, val active: Float?, val inactive: Float?) : Call()
+
+        data class TestId(override val index: Int, val testId: String?) : Call()
+
+        data class TintDisabled(override val index: Int, val unselected: Boolean, val selected: Boolean) : Call()
+
+        /**
+         * The badge with [text] in [color] (none: the theme's), which takes the place of the dot; without a text the
+         * dot, when [dot], in [dotColor].
+         */
+        data class Badge(
+            override val index: Int,
+            val text: String,
+            val color: Int?,
+            val dot: Boolean,
+            val dotColor: Int?,
+        ) : Call()
+    }
+
+    // What each item shows of its badge and its dot.
+    private val badges = HashMap<Int, String>()
+    private val dots = HashMap<Int, DotIndicatorOptions>()
+
+    /** The badge text the item at [index] shows; empty without one. */
+    fun badgeOf(index: Int): String = badges[index].orEmpty()
+
+    /** The dot of the item at [index] as it shows: visible, and its color. */
+    fun dotOf(index: Int): DotIndicatorOptions = dots[index] ?: DotIndicatorOptions()
+
+    /** Every field of the item at [index], at its creation. */
+    fun create(index: Int, options: BottomTabOptions): List<Call> {
+        badges[index] = badgeText(options.badge)
+        dots[index] = options.dotIndicator.copy()
+        return look(index, options) + badge(index, options)
+    }
+
+    /**
+     * The fields of the item at [index] but its badge and dot, from [options]: as a screen of the tab appears, the
+     * look follows its options.
+     */
+    fun look(index: Int, options: BottomTabOptions): List<Call> = listOfNotNull(
+        Call.Title(index, options.text.get("")),
+        options.icon.get(null)?.let { Call.Icon(index, it) },
+        options.selectedIcon.get(null)?.let { Call.SelectedIcon(index, it) },
+        colors(index, options),
+        Call.IconSize(index, options.iconWidth.get(null)?.toInt(), options.iconHeight.get(null)?.toInt()),
+        Call.Font(index, options.font.copy()),
+        Call.FontSizes(index, options.selectedFontSize.get(null)?.toFloat(), options.fontSize.get(null)?.toFloat()),
+        Call.TestId(index, options.testID.get(null)),
+        Call.TintDisabled(index, options.disableIconTint.isTrue, options.disableSelectedIconTint.isTrue),
+    )
+
+    /**
+     * A `mergeOptions` of [merge] into the tab at [index] or a screen in it: the fields it names, with the values of
+     * [resolved] (the tab's resolved `bottomTab` with [merge] over it).
+     */
+    fun merge(index: Int, merge: BottomTabOptions, resolved: BottomTabOptions): List<Call> {
+        val calls = ArrayList<Call>()
+        if (merge.text.hasValue()) calls += Call.Title(index, resolved.text.get(""))
+        if (merge.icon.hasValue()) resolved.icon.get(null)?.let { calls += Call.Icon(index, it) }
+        if (merge.selectedIcon.hasValue()) {
+            resolved.selectedIcon.get(null)?.let { calls += Call.SelectedIcon(index, it) }
+        }
+        if (merge.iconColor.hasValue() || merge.selectedIconColor.hasValue() || merge.textColor.hasValue() ||
+            merge.selectedTextColor.hasValue()
+        ) {
+            calls += colors(index, resolved)
+        }
+        if (merge.iconWidth.hasValue() || merge.iconHeight.hasValue()) {
+            calls += Call.IconSize(index, resolved.iconWidth.get(null)?.toInt(), resolved.iconHeight.get(null)?.toInt())
+        }
+        if (merge.font.hasValue()) calls += Call.Font(index, resolved.font.copy())
+        if (merge.fontSize.hasValue() || merge.selectedFontSize.hasValue()) {
+            val active = resolved.selectedFontSize.get(null)?.toFloat()
+            calls += Call.FontSizes(index, active, resolved.fontSize.get(null)?.toFloat())
+        }
+        if (merge.testID.hasValue()) calls += Call.TestId(index, resolved.testID.get(null))
+        if (merge.disableIconTint.hasValue() || merge.disableSelectedIconTint.hasValue()) {
+            calls += Call.TintDisabled(index, resolved.disableIconTint.isTrue, resolved.disableSelectedIconTint.isTrue)
+        }
+        if (merge.badge.hasValue()) badges[index] = badgeText(resolved.badge)
+        if (merge.dotIndicator.hasValue()) dots[index] = resolved.dotIndicator.copy()
+        if (merge.badge.hasValue() || merge.badgeColor.hasValue() || merge.dotIndicator.hasValue()) {
+            calls += badge(index, resolved)
+        }
+        return calls
+    }
+
+    /**
+     * Light or dark changed, or new default options: the colors of the item at [index] from [options], its badge and
+     * dot as they show, the badge's color following the options.
+     */
+    fun repaint(index: Int, options: BottomTabOptions): List<Call> =
+        listOf(colors(index, options), badge(index, options))
+
+    // `selectedIconColor` defaults to `iconColor` (`bottomTab.selectedIconColor`).
+    private fun colors(index: Int, options: BottomTabOptions): Call.Colors {
+        val icon = color(options.iconColor)
+        return Call.Colors(
+            index = index,
+            iconActive = color(options.selectedIconColor) ?: icon,
+            iconInactive = icon,
+            titleActive = color(options.selectedTextColor),
+            titleInactive = color(options.textColor),
+        )
+    }
+
+    private fun badge(index: Int, options: BottomTabOptions): Call.Badge {
+        val dot = dotOf(index)
+        return Call.Badge(index, badgeOf(index), color(options.badgeColor), dot.visible.isTrue, color(dot.color))
+    }
+
+    companion object {
+        /** The badge's text: `''` and `null` take it away. */
+        fun badgeText(badge: Text): String = if (badge.isNone) "" else badge.get("")
+
+        /**
+         * The titles' mode of `bottomTabs.titleDisplayMode`: unset, Material's automatic mode when some tab has an icon
+         * ([anyIcon]), else every title.
+         */
+        fun titleState(mode: Text, anyIcon: Boolean): BottomTabs.TitleState = when (mode.get(null)) {
+            "alwaysShow" -> BottomTabs.TitleState.ALWAYS_SHOW
+            "showWhenActive" -> BottomTabs.TitleState.SHOW_WHEN_ACTIVE
+            "showWhenActiveForce" -> BottomTabs.TitleState.SHOW_WHEN_ACTIVE_FORCE
+            "alwaysHide" -> BottomTabs.TitleState.ALWAYS_HIDE
+            else -> if (anyIcon) BottomTabs.TitleState.AUTO else BottomTabs.TitleState.ALWAYS_SHOW
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabSelection.kt

@@ -0,0 +1,65 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.options.BottomTabsOptions
+
+/**
+ * What a press of a tab does (also for a cell of the custom row), and which tab a one-shot choice names: the decisions
+ * alone, without views, the same for every source of a press (the bar, a cell of the row). The tabs run what they say.
+ */
+internal object TabSelection {
+    /** What a press of a tab leads to, after its `ANN.BottomTabPressed`. */
+    enum class Action {
+        /** Another tab becomes the selected one (`ANN.BottomTabSelected` after it). */
+        Select,
+
+        /** `bottomTab.selectTabOnPress: false`: the selection stays where it is. */
+        Stay,
+
+        /** The selected tab again: its stack goes back to its first screen, or its content scrolls to the top. */
+        Repeat,
+
+        /** The selected tab again with `popToRootOnPress: false` or `selectTabOnPress: false`: nothing more. */
+        Nothing,
+    }
+
+    /**
+     * The press of a tab that [wasSelected] or not, with its resolved `bottomTab.selectTabOnPress` and
+     * `popToRootOnPress` ([selectTabOnPress], [popToRootOnPress]: `false` only when the options say so).
+     */
+    fun press(wasSelected: Boolean, selectTabOnPress: Boolean, popToRootOnPress: Boolean): Action = when {
+        !wasSelected && selectTabOnPress -> Action.Select
+        !wasSelected -> Action.Stay
+        selectTabOnPress && popToRootOnPress -> Action.Repeat
+        else -> Action.Nothing
+    }
+
+    /** The tab a one-shot choice names. */
+    sealed class Choice {
+        /** None of the two options is set, or an unknown id alone. */
+        object None : Choice()
+
+        /** The tab at [index], in layout order. */
+        data class Tab(val index: Int) : Choice()
+
+        /** `currentTabIndex` out of range: [index] (truncated) for the log; nothing changes. */
+        data class OutOfRange(val index: Int) : Choice()
+    }
+
+    /**
+     * The tab [options] choose among [count] tabs: `currentTabId` when [indexOfId] finds a tab that is that id or holds
+     * a layout with it; else `currentTabIndex`, truncated to a whole number, when it is in range, or
+     * [Choice.OutOfRange] (a negative one too); else none. Read only from the options that bring them (the layout's
+     * own, a merge's), never from resolved options.
+     */
+    fun choice(options: BottomTabsOptions, count: Int, indexOfId: (String) -> Int?): Choice {
+        val id = options.currentTabId.get(null)
+        if (!id.isNullOrEmpty()) indexOfId(id)?.let { return Choice.Tab(it) }
+        val wanted = options.currentTabIndex.get(null) ?: return Choice.None
+        val index = wanted.toInt()
+        return if (index in 0 until count && wanted >= 0) Choice.Tab(index) else Choice.OutOfRange(index)
+    }
+
+    /** The one text of an index out of range on both platforms. */
+    fun outOfRangeText(index: Int, count: Int): String =
+        "[ApexNavigation] bottomTabs.currentTabIndex $index is out of range: the layout has $count tabs"
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabsAttach.kt

@@ -0,0 +1,42 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.options.params.Text
+
+/**
+ * When the views of the tabs are made and join the tabs' view (`bottomTabs.tabsAttachMode`): the decisions alone,
+ * without views.
+ */
+internal object TabsAttach {
+    enum class Mode {
+        /** Every tab with the tabs, the unselected ones invisible but laid out: they render at once. */
+        Together,
+
+        /** The selected tab first; the others once it appeared, or a tab chosen before that at its selection. */
+        AfterInitialTab,
+
+        /** The selected tab only; another at its first selection, without a wait. */
+        OnSwitchToTab,
+    }
+
+    /** The mode of `bottomTabs.tabsAttachMode`, resolved with the defaults; `together` when unset. */
+    fun modeOf(value: Text): Mode = when (value.get(null)) {
+        "afterInitialTab" -> Mode.AfterInitialTab
+        "onSwitchToTab" -> Mode.OnSwitchToTab
+        else -> Mode.Together
+    }
+
+    /** The tabs whose views join as the tabs' view is made, [selected] among [count]. */
+    fun atCreation(mode: Mode, selected: Int, count: Int): List<Int> =
+        if (mode == Mode.Together) (0 until count).toList() else listOf(selected)
+
+    /** The tabs whose views join once the first tab appeared: every other with `afterInitialTab`. */
+    fun afterFirstAppearance(mode: Mode, count: Int): List<Int> =
+        if (mode == Mode.AfterInitialTab) (0 until count).toList() else emptyList()
+
+    /**
+     * The tabs a wait for the tabs counts though they don't show: with `together`, every tab but the selected one; none
+     * otherwise.
+     */
+    fun unseenWaited(mode: Mode, selected: Int, count: Int): List<Int> =
+        if (mode == Mode.Together) (0 until count).filter { it != selected } else emptyList()
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabsRoom.kt

@@ -0,0 +1,72 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.viewcontrollers.stack.fab.FabPlacement
+
+/**
+ * The room the tab bar takes from the screens of its tabs: from the bar as its options set it, not as it lays out now,
+ * so a screen gets its room in the same layout pass. Pure arithmetic in pixels.
+ */
+internal object TabsRoom {
+    /**
+     * The bar as its options set it: its own [height] (80 dp), the navigation bar under it ([navigationBar], the
+     * window's bottom inset), `layoutStyle: 'compact'` ([compact]), `bottomMargin` ([bottomMargin]) and what the
+     * custom row covers above it ([rowOvershoot]).
+     */
+    data class Bar(
+        val height: Int,
+        val navigationBar: Int,
+        val compact: Boolean,
+        val bottomMargin: Int,
+        val rowOvershoot: Int = 0,
+    ) {
+        /**
+         * The height of the bar's container: a stretched one goes under the navigation bar, its items above it; a
+         * compact one floats above it.
+         */
+        val containerHeight: Int
+            get() = height + if (compact) 0 else navigationBar
+
+        /**
+         * How far the container's bottom is from the bottom of the tabs: the margin, and the navigation bar of a
+         * compact one.
+         */
+        val offset: Int
+            get() = bottomMargin + if (compact) navigationBar else 0
+
+        /** From the bottom of the tabs to the top of the bar at rest. */
+        val reach: Int
+            get() = containerHeight + offset
+    }
+
+    /** What the options of the screen asking say of the bar: `bottomTabs.visible`, `drawBehind`, `hideOnScroll`. */
+    data class Screen(val hidden: Boolean, val drawBehind: Boolean, val hideOnScroll: Boolean)
+
+    /**
+     * The room a screen keeps at its bottom: the bar's reach and what the custom row covers above it, unless the screen
+     * hides the bar, draws behind it, or the bar hides on scroll (the screen goes under it then); with the room of the
+     * layouts around the tabs ([around]).
+     */
+    fun bottomInset(bar: Bar, screen: Screen, around: Int): Int {
+        if (screen.hidden || screen.drawBehind || screen.hideOnScroll) return around
+        return around + bar.reach + bar.rowOvershoot
+    }
+
+    /**
+     * The top of the bar in the window where it rests, from the bottom of the tabs in the window ([tabsBottom]); none
+     * when the screen's options hide the bar.
+     */
+    fun tabsTop(bar: Bar, screen: Screen, tabsBottom: Int): Int? =
+        if (screen.hidden) null else tabsBottom - bar.reach - bar.rowOvershoot
+
+    /**
+     * The safe area of the screen leaves its bottom edge free: the bar hides on scroll and shows for it.
+     */
+    fun leavesBottomEdgeFree(screen: Screen): Boolean = screen.hideOnScroll && !screen.hidden
+
+    /**
+     * The bar at rest under a stack's FAB: also when the screen is under it (`drawBehind`, `hideOnScroll`); none when
+     * the screen hides it.
+     */
+    fun fabTabs(bar: Bar, screen: Screen): FabPlacement.Tabs? =
+        if (screen.hidden) null else FabPlacement.Tabs(bar.containerHeight + bar.bottomMargin, bar.compact)
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/child/ChildController.kt

@@ -0,0 +1,45 @@
+package dev.apexnative.navigation.viewcontrollers.child
+
+import android.app.Activity
+import android.view.ViewGroup
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * A node that can be a child of a layout and is found by its id: it is in the activity's registry from its creation
+ * to its destruction, and applies its resolved options through its [presenter].
+ */
+abstract class ChildController<V : ViewGroup>(
+    activity: Activity,
+    private val childRegistry: ChildControllersRegistry,
+    id: String,
+    /** Applies the node's resolved options to the activity and to its view. */
+    val presenter: Presenter,
+    initialOptions: Options,
+) : ViewController<V>(activity, id, initialOptions) {
+    init {
+        childRegistry.onChildCreated(this)
+    }
+
+    /**
+     * Another node has this node's id now, in this activity's registry or in another navigation activity's: a later
+     * layout made with the same ids (a `setRoot` builds the new root before the old one goes; a new activity sets the
+     * last root again). What is kept by id belongs to that node then.
+     */
+    protected val isIdTakenByAnother: Boolean
+        get() = isOther(childRegistry.find(id)) ||
+            Navigators.all().any { isOther(it.navigator?.registry?.find(id)) }
+
+    private fun isOther(node: ViewController<*>?): Boolean = node != null && node !== this
+
+    /** `mergeOptions` while the node's view shows: its presenter applies what [options] give. */
+    override fun applyMergedOptions(options: Options) = presenter.mergeOptions(this, options)
+
+    override fun destroy() {
+        if (isDestroyed) return
+        super.destroy()
+        childRegistry.onChildDestroyed(this)
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/child/ChildControllersRegistry.kt

@@ -0,0 +1,29 @@
+package dev.apexnative.navigation.viewcontrollers.child
+
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * The nodes of an activity by id: every node a command may name, in the root, the modals and the overlays, and the
+ * screens made but not shown yet. A node is in it from its creation to its destruction. Main thread only.
+ */
+class ChildControllersRegistry {
+    private val nodes = LinkedHashMap<String, ViewController<*>>()
+
+    fun onChildCreated(child: ViewController<*>) {
+        nodes[child.id] = child
+    }
+
+    fun onChildDestroyed(child: ViewController<*>) {
+        if (nodes[child.id] === child) nodes.remove(child.id)
+    }
+
+    /** The node with [id]; none when there isn't one. */
+    fun find(id: String): ViewController<*>? = nodes[id]
+
+    /** Every node, as they were made. */
+    fun all(): List<ViewController<*>> = nodes.values.toList()
+
+    fun clear() {
+        nodes.clear()
+    }
+}